Google’s Antigravity SDK now supports local model inference — and the headline number is hard to dismiss. In Google’s own benchmark, 97.2% of roughly 3,400 tokens ran on the developer’s machine, with only 95 touching the cloud. That single stat reframes what an AI agent can look like: lower API bills, no code exfiltration risk, and an operating cost that trends toward zero for workloads that burn through tokens.
What Shipped on September 23 #
The update adds two local execution paths to the Antigravity Python SDK. The first is a native LiteRT path that runs Gemma 4 26B A4B fully on-device using Google AI Edge’s LiteRT runtime — no API calls, no internet required after the initial model download. The second is an OpenAI-compatible path that connects to any local inference server: Ollama, LM Studio, or vLLM.
Setup for the native path is two commands:
pip install google-antigravity litert-lm
The LiteRT checkpoint weighs in at 16.8 GB. After that one-time download, inference runs entirely offline. The hardware bar is real — Google recommends 24+ GB of VRAM or unified memory. M3 Pro and M4 Max MacBooks qualify, as do high-end workstations with an RTX 4090 or better. For teams without that hardware, the Ollama path works with a smaller model and a lower memory floor, though quality trade-offs apply.
The Real Use Case: Don’t Go Fully Local #
The most useful thing Google shipped isn’t the option to run everything locally — it’s the Architect-Builder pattern it documents alongside it. The pattern splits agent work by data sensitivity: a cloud model handles planning; a local model handles execution.
In practice, a lightweight cloud agent (Gemini 3.8 Flash) receives only filenames and metadata — never source code. It writes the task plan and delegates. The local Gemma 4 26B instance then does the token-intensive work: reading files, generating patches, running regression tests. Source code never leaves the developer’s machine during the build phase.
Google demonstrated this pattern patching three vulnerable Python modules. The cloud handled planning in 95 tokens. The local agent handled everything else across the remaining ~3,300. The result is a workflow that is both cheap to run and compliant by design.
The Economics and the Privacy Case #
Cloud API billing is per-token. A code auditing agent that reads a mid-size codebase can burn tens of thousands of tokens in a single run. With local inference, the cost model flips: one-time hardware plus electricity, regardless of how many tokens the agent processes.
The privacy angle is equally concrete. A Stack Overflow survey found 81% of developers cite data privacy as their top concern with AI agents. A separate study found 63% of employees have pasted sensitive code — proprietary logic, internal architecture — into personal chatbot sessions. Local execution eliminates that surface entirely. GDPR and HIPAA compliance becomes more tractable when your agent’s working directory never leaves your network.
The Catch Worth Knowing #
The 97% local token figure is real, but it doesn’t mean “97% faster” or “97% cheaper” on every machine. Inference on consumer hardware is slow — Google’s own sample scripts note a query “could take several minutes.” That is fine for batch jobs, security scans, or async pipelines. It is not a drop-in replacement for interactive agent workflows where sub-second responses matter.
The hardware gate also matters. Without M3 Pro/M4 Max machines or equivalent workstations, the full LiteRT experience is out of reach. The Ollama path lowers the bar, but model capability drops with it.
Who Should Try This Now #
The local model announcement is live, the SDK is on pip, and the official documentation includes working examples of the Architect-Builder pattern. The strongest immediate candidates: teams doing code auditing, security scanning, IP-sensitive code generation, or any agentic workflow where source code leaving the building is a compliance problem.
For individual developers on M-series MacBooks who want to experiment with genuinely offline agents — this is the first credible path from a major vendor that doesn’t require building the orchestration layer yourself. It is not production-ready for every use case today. But the pattern it introduces, and the cost argument it makes, are going to be the default architecture for agent-heavy workloads within the next 12 months.