Google Antigravity SDK: Google is pushing AI coding agents closer to thedeveloper’ss own machine. The latest Antigravity SDK support lets agents use local models through Google AI Edge LiteRT or OpenAI-compatible local servers.
The bigger story, however, is hybrid execution: developers can configure hybrid workflows in which a cloud model handles planning while local agents perform code-heavy work.
Google Antigravity SDK Agents Can Now Run Without the Cloud
Google’s Antigravity SDK now provides two dedicated paths for local model execution.
| Configuration | Local model path |
| LiteRTAgentConfig | Models such as Gemma 4 26B A4B through Google AI Edge LiteRT |
| LocalOpenAIAgentConfig | OpenAI-compatible local servers such as Ollama, LM Studio and vLLM |
A fully local setup can operate without an API key or internet connection after the SDK, runtime and model checkpoint have already been installed or downloaded, while avoiding per-token cloud inference charges.
That also means source code and prompts can remain on the machine when the entire workload is configured locally. However, this is a capability of the local configuration not a guarantee that every Antigravity workflow is private or offline.
Google formally announced the capability on September 23. The underlying local-model configuration classes date back to SDK 0.1.6 in July, while version 0.1.18 on September 21 marked the feature as officially ready to use and added further local-model optimizations.
Google Uses Gemma 4 as the Local WorkeGoogle’s
Google’s featured local setup uses Gemma 4 26B A4B through the LiteRT runtime. That model is not designed around lightweight laptop hardware. Google recommends a system with at least 24GB of VRAM or unified memory, while the featured checkpoint is approximately 16.8GB to download.
LiteRT can use supported hardware backends including Apple Silicon Metal and NVIDIA CUDA, with NPU support also available through its supported backend architecture. So the headline should not be interpreted as any laptop can now run Google’s full coding agent locally. The hardware requirement is substantial, particularly for developers who want the larger 26B model.
You’re Not Locked to Google’s Local Runtime.
The more interesting part is that Antigravity’s local-agent architecture isn’t restricted to Gemma or LiteRT. Developers can connect LocalOpenAIAgentConfig to local servers such as:
These expose OpenAI-compatible endpoints, letting developers keep the broader Antigravity agent workflow while swapping the local inference stack underneath. That creates more flexibility for developers who already have a preferred local model runtime or want to experiment with different models without rebuilding the entire agent workflow.
One technical caveat: Google specifically says not to use LocalOpenAIAgentConfig with litert-lm serve. LiteRT models should use LiteRTAgentConfig, which manages the LiteRT server lifecycle itself.
The Bigger Idea Is Hybrid AI
This is where Google’s demonstration becomes more interesting than a simple “Gemma runs locally” announcement.
Google demonstrates an Architect–Builder pattern:
Cloud model → planning and orchestration
Local agents → coding, auditing, patching, and testing
This is a deliberately configured workflow, not an automatic behavior of Antigravity. In Google’s demonstration, Gemini 3.8 Flash acted as the cloud planner while local Gemma 4 26B agents handled the code-heavy work.
The local Gemma agents then performed activities such as:
- source-code analysis
- vulnerability reproduction
- patch generation
- code review
- regression testing
- Google’s 97.2% Local-Token Demonstration
Google’s strongest demonstration involved a security-patching task covering three files. In that recorded three-file security-patching demonstration, 3,322 tokens, or 97.2% of the total, were processed locally, while Gemini 3.8 Flash used just 95 cloud tokens for planning.
Google says Gemini received only filenames and task descriptions in that example, while the source code remained local. The local Gemma agents then reproduced vulnerabilities, proposed fixes, reviewed those fixes, and ran regression tests. The 97.2% figure is therefore a result from this specific three-file demonstration, not a performance or privacy guarantee for every Antigravity project.
Why Companies May Care About Local Agents?
Local inference could be particularly relevant where developers need tighter control over proprietary material.
Potential use cases include:
- Privacy: proprietary code can remain on local hardware in fully local configurations.
- Offline development: agents can continue working without an active internet connection after setup.
- Cost control: local inference does not incur per-token cloud API charges.
- Rate-limit independence: local workloads do not depend on cloud API quotas in the same way.
- Compliance: organizations with strict data-handling requirements can consider architectures that keep sensitive workloads on-device.
- Flexible infrastructure: developers can choose between LiteRT and compatible local inference servers.
A fully local workflow can keep code and prompts on-device, but hybrid privacy depends on what developers choose to send to cloud-side models. But local execution should not automatically be equated with security.
An agent running on your own machine can still access files, terminals, and other tools,s depending on how it is configured. Google’s examples demonstrate agent tool usage, so permissions and tool policies remain part of the security model. Hybrid workflows also require careful attention to what information the cloud-side planner receives.
What You Need to Run It?
Developers looking to reproduceGoogle’ss local workflow need more than the Antigravity SDK itself.
The practical requirements include:
| Requirement | What does it mean? |
| Antigravity SDK | Provides the agent configuration |
| Local runtime | LiteRT-LM or compatible local server |
| Model | Gemma 4 26B A4B isGoogle’ss featured configuration |
| Hardware | Google recommends 24GB+ VRAM or unified memory |
| Alternative runtimes | Ollama, LM Studio or vLLM |
| Permissions | Local agent tools still need appropriate restrictions |
The 24GB figure is a recommendation for the featured Gemma 4 26B A4B configuration, not a universal hardware minimum for every local model or setup.
Google’s documentation also indicates that Gemma 4 26B A4B is the configuration that works best for the LiteRT workflow, while other LiteRT checkpoints may not work as reliably. That makes this an evolving local-agent ecosystem rather than a universal plug-and-play solution.
What Local AI StillDoesn’tt Solve?
Moving inference onto adeveloper’ss machine comes with trade-offs.
- Hardware: Larger models demand substantial memory.
- Performance: Local inference speed depends heavily on the available GPU, unified memory, and runtime.
- Capability: A local model may not match a frontier cloud model on every reasoning or coding task.
- Compatibility: Models and runtimes need to work correctly with the agent framework and its tools.
- Security: Running locally does not eliminate risks from excessive tool permissions or shell access.
- Hybrid privacy: If cloud models remain part of the workflow, developers still need to understand exactly what information leaves the machine.
That makes Google’ss hybrid architecture particularly interesting: it is not trying to replace cloud AI outright. Instead, it creates the possibility of splitting workloads according to capability, privacy, and cost.
WhatGoogle’ss Antigravity Update Really Means?
The significance of the announcement goes beyond adding Gemma 4 to another developer tool. Antigravity can now give developers a choice between fully local execution, cloud execution, or a combination of both. That makes the location of AI inference part of the development architecture itself.
For privacy-sensitive or offline workloads, local models can keep computation close to the source code. For tasks that benefit from stronger cloud reasoning, developers can still use cloud models where appropriate. The interesting shift is therefore not simply that Gemma can run on-device. It is that AI coding workflows are becoming configurable across the cloud and thedeveloper’ss own hardware.
Final Thoughts: Google’s
Google’s Antigravity SDK makes local agent execution practical while opening a hybrid path between cloud reasoning and on-device coding.
With the Antigravity SDK, developers can now decide which parts of an agent workflow run locally and which, if any, use cloud models.
(Source)