Google Antigravity SDK Adds Local Models for Token Efficiency

Google has introduced local-model support in the Antigravity SDK, so developers can build and execute agentic workflows on their own machines and still mix in cloud-based models for higher-level tasks. Sergio De Simone's October 14, 2026 InfoQ's report describes that release as hybrid agent orchestration, adapting Google's Architect-Builder pattern to a mixed cloud-local environment. Google says the approach gives developers greater control over data privacy, inference costs, network dependencies, and computational workload distribution.

This piece covers the SDK change, how a cloud architect and local builders divide a task, and which local runtimes the SDK accepts. It is for developers who build their own AI agents programmatically with the Antigravity SDK, and for teams comparing that SDK with the Antigravity IDE, which is powered by the same agent infrastructure.

Google Antigravity SDK: what actually changed

The initial implementation focuses on running Gemma 4 26B A4B through Google's LiteRT technology. Developers are not limited to LiteRT exclusively. The Antigravity SDK also supports OpenAI-compatible local inference servers through LocalOpenAIAgentConfig, including Ollama, LM Studio, and vLLM. A cloud model can still take the higher-level tasks while those local servers run builder steps on the machine. Support for Ollama, LM Studio, and vLLM goes through LocalOpenAIAgentConfig. Through those local servers, developers execute agentic workflows directly on their own machines.

Hybrid agent orchestration is the capability this local support extends. One primary, high-context AI agent, the architect, holds the macro-level system view, including dependencies, architectural guardrails, and detailed specifications or implementation plans. Once the architect has defined a plan, several parallel specialized AI agents, the builders, work independently in isolated environments to execute discrete, narrow tasks mapped out by the specification. Google adapts that Architect-Builder pattern to mixed cloud-local compute, placing the architect in the cloud and the builders on their own machines.

Google Antigravity SDK: how it works

Google says the architect operates in the cloud. It devises a strategy and breaks the task into smaller units using filenames and task descriptions, without requiring access to the source code itself. The plan it holds is the macro-level system view: dependencies, architectural guardrails, and detailed specifications or implementation plans. The builders run locally and perform tasks such as reproducing security vulnerabilities, proposing code fixes, reviewing candidate patches, and running regression tests. Additional specialized local agents can validate proposed changes against the provided test suites, keeping the code-intensive stages of the workflow on-device.

In a demonstration involving the auditing and patching of three vulnerable Python modules, Google reports that only 95 out of approximately 3400 tokens were used on the cloud for planning, while the remaining 97.2% were spent locally. Google also states that no source code was uploaded to the cloud. The cloud share in that run was planning through filenames and task descriptions. Reproducing vulnerabilities, proposing fixes, reviewing candidate patches, running regression tests, and validating changes against the provided test suites stayed with the local builders.

Google Antigravity SDK: why it matters now

The privacy and network claims rest on that three-module demonstration. The architect works from filenames and task descriptions and does not require access to the source code, and Google states that no source code from the three vulnerable Python modules was uploaded to the cloud. The stages that read and change code, reproducing security vulnerabilities, proposing code fixes, reviewing candidate patches, running regression tests, and validating proposed changes against the provided test suites, stay on-device with the local builders. Google presents that split as greater control over data privacy and network dependencies.

In the three-module demonstration, 95 of approximately 3400 tokens were used on the cloud for planning, and the remaining 97.2% were spent locally. The initial local implementation runs Gemma 4 26B A4B through LiteRT, and the SDK can also call Ollama, LM Studio, or vLLM through LocalOpenAIAgentConfig. The cloud model keeps the architect role and its high-context plan, including dependencies, architectural guardrails, and the specification, while local hardware carries the larger token share. Google describes that split as control over inference costs and computational workload distribution.

Google Antigravity SDK: who is affected

The Antigravity SDK should not be confused with the Antigravity IDE. The SDK lets developers build their own AI agents programmatically, rather than simply using them for coding tasks. The Antigravity IDE is an IDE powered by the Antigravity SDK. They share the same underlying agent infrastructure and serve different purposes. Local-model support is an SDK feature for people assembling agents in their own programs, and the IDE applies that shared infrastructure to coding tasks. Programmatic agent construction stays with the SDK.

Companies that want tighter control of the model are the group ambassadortim described. Reddit user ambassadortim said that "companies can have more control over their AI model and when to change or at least have more control over that". In a separate discussion, FollowingTop3534 called the recommended 24GB+ VRAM or unified memory a real gate. Machines that can host Gemma 4 26B A4B on LiteRT, or that already serve Ollama, LM Studio, or vLLM through LocalOpenAIAgentConfig, are the ones that can take the local builder role used in the demo.

Google Antigravity SDK: what to watch

Google's 97.2% figure is the local share from one demonstration, 95 tokens on the cloud out of approximately 3400, and FollowingTop3534 questioned whether the cloud-token share tells the whole story. The comment named the missing checks: "I'd benchmark patch acceptance, wall time, and energy alongside the cloud-token share. '97.2% of tokens ran locally' is interesting, but it doesn't tell you whether the run was faster or cheaper on your hardware, and the recommended 24GB+ VRAM or unified memory is a real gate."

Reddit user Latter_Crazy described the same capabilities this way: "it can do things I could not do before with the cloud rules. Cost, speed, quality are all going up and this is just the start. Highly recommend looking into this." The local runtimes named for that path are Gemma 4 26B A4B through Google's LiteRT technology and OpenAI-compatible servers through LocalOpenAIAgentConfig, including Ollama, LM Studio, and vLLM. FollowingTop3534 said the recommended 24GB+ VRAM or unified memory is a real gate on your hardware.