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

Google has introduced local model support in the Antigravity SDK, letting developers build and execute agent workflows directly on their own machines while retaining the flexibility to mix in cloud models for higher-level tasks. According to the InfoQ report, this approach gives developers greater control over data privacy, inference cost, network dependency, and the distribution of compute load.

The question truly worth asking is not "can it run locally," but which stages localization takes away from the cloud and what cost it leaves behind. The demo numbers Google provides are: in a task auditing and patching three vulnerable Python modules, only 95 of roughly 3,400 tokens were used for cloud planning, with the remaining 97.2% consumed locally, and it states that no source code was uploaded to the cloud. These numbers are vendor self-reports with no independent verification, so they are better treated as a starting point to be tested rather than a conclusion.

A core capability of the Antigravity SDK is hybrid agent orchestration, adapting the Architect-Builder pattern proposed by Google to a hybrid cloud-and-local compute environment. Under this pattern, a high-context lead agent, the "architect," holds the macro system view—dependencies, architectural guardrails, and detailed specs or implementation plans; then multiple parallel specialized "builder" agents independently execute discrete, narrow tasks split out from the spec in isolated environments.

The key to the division of labor lies in the information boundary. Google says the Antigravity SDK lets the architect run in the cloud, using file names and task descriptions to set strategy and break tasks into smaller units without accessing the source code itself. The builder runs locally, executing tasks such as reproducing security vulnerabilities, proposing code fixes, reviewing candidate patches, and running regression tests; additional specialized local agents can also verify proposed changes against a given test suite, keeping code-intensive stages on the device.

The direct implication of this design is: the cloud sees task structure rather than code content, while the local side takes on the intensive work that requires touching source code. But "the architect does not access source code" is Google's claim and a vendor self-report; the report provides no evidence of how it performs and holds up in real production environments.

The initial implementation focuses on running Gemma 4 26B A4B via Google's LiteRT technology. This means the capability ceiling on the local side is, at least in the starting phase, tied to this model and this runtime.

Developers are not limited to LiteRT. The Antigravity SDK also supports OpenAI-compatible local inference servers through LocalOpenAIAgentConfig, including Ollama, LM Studio, and vLLM. For teams that have already built their own local inference stacks, this compatibility path lowers migration costs and means "local model" need not equal "Google's designated local model."

What needs to be distinguished is the product boundary: the Antigravity SDK should not be confused with the Antigravity IDE, which is an IDE powered by the Antigravity SDK. The two share the same underlying agent infrastructure but serve different purposes; the SDK lets people programmatically build their own AI agents, not just use them for coding tasks.

In a Reddit discussion, user ambassadortim commented that enterprises can have more control over their own AI models and when to switch models. This echoes Google's statements about control, but it is likewise a community member's personal opinion, not a verifiable conclusion about product capability.

More worthy of attention is the skepticism about the metric. User FollowingTop3534 questioned whether the cloud token share metric tells the whole story, suggesting benchmarking patch acceptance rate, wall-clock time, and energy consumption as well. The user also mentioned that the recommended configuration is 24GB or more of VRAM or unified memory, calling it a real barrier.

These two community opinions point to the same gap: the 97.2% local token share describes workload distribution, but does not directly indicate whether this run is faster or cheaper on specific hardware. Metrics such as patch acceptance rate, wall-clock time, and energy consumption were not disclosed in the report.

Another user, Latter_Crazy, expressed enthusiasm for the new capability, saying it can do things that were previously impossible under cloud rules, and believes cost, speed, and quality are all improving. This is a subjective community assessment, and the report provides no supporting data.

All of the above information comes from a single InfoQ report, in which Google's demo data and claims are vendor self-reports and have not yet been independently verified by a third party. This means the 95/3,400 token distribution, the 97.2% local share, and "no source code uploaded to the cloud" should all be read as Google's statements, not confirmed facts.

Also in an unverified state are the degree to which the 24GB or more VRAM or unified memory threshold affects practical usability, and the performance and stability of hybrid orchestration in real production environments. Apart from the InfoQ report, there is a lack of other independent sources for cross-verification.

Therefore, a reasonable judgment of this approach is: the product direction and architectural division of labor have been clearly described, but the magnitude of benefits and engineering usability still await independent measurement.