Google Antigravity SDK Adds Local Model Support for Greater Token Efficiency and Code Privacy

Google has introduced support for local models in the Antigravity SDK, letting developers build and run agentic workflows on their own machines while still mixing in cloud-based models for higher-level tasks. The addition was reported by InfoQ's Sergio De Simone. The stated aim is greater developer control over data privacy, inference costs, network dependencies, and how computational work is distributed.
The centerpiece is hybrid agent orchestration, which applies Google's proposed Architect-Builder pattern to a mixed cloud-and-local setup. Under that pattern, a single high-context agent, the architect, keeps the macro-level view: dependencies, architectural guardrails, and detailed specifications or implementation plans. Once the architect has a plan, several specialized builder agents work in parallel inside isolated environments on discrete, narrow tasks mapped to that specification.
In the Antigravity SDK's version of this, the architect runs in the cloud and breaks the work into smaller units using filenames and task descriptions, without needing access to the source code itself. The builders run locally and handle code-intensive steps such as reproducing security vulnerabilities, proposing fixes, reviewing candidate patches, and running regression tests. Additional specialized local agents can validate proposed changes against the provided test suites, keeping those stages on-device.
Google's numbers come from a demonstration covering the auditing and patching of three vulnerable Python modules. It reports that only 95 of roughly 3,400 tokens were spent in the cloud on planning, with the other 97.2% spent locally. Google also states that no source code was uploaded to the cloud. Those figures come from Google's own demo, so they describe one workload rather than a general guarantee about token use.
The first implementation focuses on running Gemma 4 26B A4B through Google's LiteRT technology. Developers are not locked to LiteRT: the SDK also supports OpenAI-compatible local inference servers through LocalOpenAIAgentConfig, including Ollama, LM Studio, and vLLM. In practice that means a team already running a local server can point the SDK at it rather than adopting Google's runtime. This is a familiar split in agent tooling, where the frontier model handles planning and smaller or local models handle execution, and it echoes the long-running hybrid pattern in tools like Continue and Aider, which can route requests to local or hosted endpoints.
Community reaction was mixed. Reddit user ambassadortim noted that companies can have more control over their AI model and when to change it, framing the benefit as organizational as much as technical. Another user, FollowingTop3534, questioned whether a cloud-token share tells the whole story, saying they would benchmark patch acceptance, wall time, and energy alongside it, and describing the recommended 24GB or more of VRAM or unified memory as a real gate. A third user, Latter_Crazy, was enthusiastic, describing capabilities they could not achieve before with cloud rules and saying cost, speed, and quality are all improving.
The VRAM point deserves unpacking. Running a model locally means the weights must fit in GPU or unified memory, and 24GB is enough for some mid-sized open models but not for frontier-scale ones. So the local half of this architecture is likely to be a smaller model, and quality on tasks like patch generation may differ from what a cloud model produces. A likely trade-off is that privacy and predictable per-token cost come at the price of more setup, more hardware, and potentially weaker reasoning on hard tasks. The demo's 97.2% local token share also measures where tokens ran, not how long the run took or how much energy it consumed; a mostly local run could still be slower than a cloud-only one on the same job. Those are reasonable questions to test on your own workload rather than take from a token-share figure.
One distinction worth keeping clear: the Antigravity SDK is not the Antigravity IDE. The IDE is powered by the SDK, and the two share underlying agent infrastructure, but they serve different purposes. The SDK is for building your own AI agents programmatically; the IDE is for using agents in coding tasks.
Why it matters: Teams with privacy or cost constraints now have a documented path to keep source code on-device while still using a cloud model for planning, which is most relevant to security, compliance, and platform engineering groups. Developers should expect to prototype against Ollama or vLLM with a capable local machine, then measure patch acceptance and wall time instead of trusting token share alone. The 24GB memory recommendation is the practical gate to check before committing, and anyone building agents rather than using an IDE should evaluate the SDK directly.
Based on reporting from the original publisher. Visit the source for full context and later updates.
Publisher excerpt
Google has introduced support for local models in the Antigravity SDK, enabling developers to build and execute agentic workflows directly on their own machines, while retaining the flexibility to mix in cloud-based models for higher-level tasks. This approach gives developers greater control over data privacy, inference costs, network dependencies, and computational workload distribution. By Sergio De Simone