Google's agent SDK will now run on your own GPU for nothing — the bill just moved from the meter to the VRAM

What shipped

Google published the change on 23 September 2026, credited to group product manager Sachin Kotwani and principal engineer Taylor Mullen. The Antigravity SDK — the programmatic layer under Google’s agentic development platform — can now drive agents that never touch a Google endpoint.

Two configuration classes do the work:

The documented path is two commands:

pip install google-antigravity litert-lm
litert-lm import \
  --from-huggingface-repo=litert-community/gemma-4-26B-A4B-it-litert-lm \
  gemma-4-26B-A4B-it-gpu.litertlm gemma4-26b

Weights land at ~/.litert-lm/models/gemma4-26b/model.litertlm. The recommended build is gemma-4-26B-A4B-it-gpu.litertlm, and Google’s stated requirement is more than 24GB of VRAM or unified memory.

The pitch is three words long and all three are accurate: zero token cost, total data privacy, offline reliability.

The model is the reason this fits on one GPU

Gemma 4 26B A4B is a mixture-of-experts model: 25.2 billion total parameters, roughly 3.8 billion active per token, a 260k-token context window, released under Apache 2.0.

That architecture is the whole feasibility argument. You hold 25B parameters resident in memory but pay compute for fewer than 4B on each token. Memory becomes the binding constraint and throughput stops being one, which is precisely the trade that turns a 26B-class model into something a single consumer GPU can serve at usable speed.

The licence deserves a line of its own. Earlier Gemma generations shipped under a bespoke Gemma Terms of Use carrying usage carve-outs that made enterprise legal review a genuine project. Gemma 4 moved to Apache 2.0. For a company deciding whether developers may run a model on laptops holding client code, that change is worth more than a benchmark point.

What the architecture does not do is make a 3.8B-active model a frontier planner. Google knows this, and the hybrid pattern it chose to showcase is the admission.

Architect-Builder, and the 2.8% that matters

The headline pattern in the announcement is Architect-Builder: a cloud model — Gemini 3.8 Flash — acts as architect and conductor, decomposing a task and routing subtasks to a local swarm of Gemma 4 instances that execute them on-device.

Google’s demonstrated run: 97.2% of 3,322 tokens ran locally.

That is a striking number and it is easy to read wrong. Token share is not value share. The 2.8% that stayed in the cloud is the planning — the decomposition, the routing, the decision about what the other 97.2% should be spent on. A cheap executor following a good plan is an excellent trade. A cheap executor following a bad plan burns your electricity instead of Google’s credits and returns the same wrong answer.

There is also a plainer consequence that the framing obscures: Architect-Builder is not offline. It has a cloud dependency in the control path. If your reason for wanting local inference is an air-gapped network, a data-residency obligation or a client contract forbidding third-party processing, the hybrid pattern does not qualify for any of them. You need the pure LiteRTAgentConfig path, and you take the planning-quality ceiling that comes with it.

Two genuinely different products are being announced under one heading. Decide which one you are adopting before you quote a saving.

The cost did not vanish. It changed shape.

“Zero token costs” is true and incomplete. Local inference converts a recurring operating cost into a one-time capital cost, and that is only a saving if your meter spend was large enough to amortise the hardware.

The floor is more than 24GB of VRAM or unified memory. In practice:

• Apple silicon: a 32GB M-series machine is the comfortable entry point. A 24GB Mac sits at the documented edge with an OS and an editor also resident. 16GB is out.
• NVIDIA: 24GB means a 4090, a 3090 or a workstation card. A 16GB 4080 does not clear it. An 8GB laptop GPU is not in the conversation.

Run the arithmetic honestly. A team with ten developers on 16GB laptops is not evaluating a software feature; it is evaluating a hardware refresh with a software feature attached. Against a modest API bill, a $2,000 GPU is a payback measured in decades — a statement about the arithmetic, not about the technology. Against high-volume bulk agentic work, or against a compliance requirement that makes cloud inference impossible at any price, the same purchase is trivially justified.

This is the same shape of constraint that gated Perplexity’s Hybrid Compute, where the practical floor was Apple silicon and realistically 32GB of unified memory. Two vendors, two months apart, arriving at the same threshold, because the threshold is set by physics rather than by product strategy.

The part nobody is leading with

LocalOpenAIAgentConfig accepts any OpenAI-compatible server.

Nothing in that path requires a Google model. Point the Antigravity SDK at a Qwen release, a DeepSeek distill, a Mistral model or your own fine-tune, and the agent loop is indifferent. Google built local execution into the SDK for its own commercial agent platform and then declined to make Gemma mandatory.

That converts the release from “on-device Gemma demo” into “general-purpose local agent runner that ships with a good default” — a materially different product, and one that is unusually generous by the standards of the category. It is consistent with how Antigravity has been positioned since 2.0, where third-party Claude and GPT-OSS models are selectable on the consumer tiers, though switched off on Enterprise.

The lock-in that remains is one layer up. The SDK, the agent abstractions and the Managed Agents API are Google’s. A team that standardises its orchestration on them carries a migration cost later even if every model it runs is open-weight. Model portability is not platform portability, and the second one is the expensive kind.

Where this lands against the alternatives

Local agentic coding is not new — Ollama, Continue, Aider and a dozen harnesses have offered it for over a year. What is new is a first-party commercial agent SDK treating local execution as a supported configuration rather than a community workaround, with a documented model build, a documented hardware floor and an official import command.

For most teams, this does not displace a cloud coding agent. Claude Code, Cursor and Antigravity’s own cloud tier are still better at hard work, and the gap is largest exactly where agents earn their keep — novel architecture, subtle debugging, large unfamiliar codebases. The Claude Code vs Antigravity comparison covers where each currently sits, and the best AI coding tools roundup covers the wider field.

Where it does displace something is the boring high-volume tier: bulk refactors, test scaffolding, docstring generation, codemod application, log triage. Work that is voluminous, mechanical and adequately served by a 3.8B-active model — and therefore the work where a per-token meter is most annoying relative to the value delivered. It also lands well against agent fleets, where best AI agents tools covers orchestration options and running many cheap executors in parallel is the point.

And there is a security dimension that rarely makes the pitch. A local agent with no network egress in its inference path removes an entire category of exposure — the one that made the Beltdown sandbox-escape cluster a cross-vendor problem this month. It does not remove agent-level risk; a local model can still be prompt-injected into running a destructive command. It removes the data-exfiltration half, which is the half that ends up in a breach notification.

What to do

If you have the hardware already: install it this week against a real bulk task, not a demo. Measure wall-clock time per completed task, not tokens — local inference trades money for latency, and whether that trade is good depends entirely on whether a developer is blocked while it runs.

If you are under a data-residency or client-contract constraint: this is the release to evaluate seriously, and you want LiteRTAgentConfig specifically. Verify the no-egress claim yourself with a packet capture rather than accepting it from a blog post. Architect-Builder does not satisfy your requirement.

If you are cost-motivated: compute your actual monthly agent spend first. Most teams discover the number is smaller than the GPU. That is a good outcome — it means you should stay on the meter and stop thinking about this.

If you are building agent infrastructure: the model-agnostic path is the durable part. Treat LocalOpenAIAgentConfig as the interface that matters and keep your orchestration layer thin enough that Google’s SDK is replaceable, because the platform layer is where the next lock-in argument will happen.

Teams making the broader stack decision will find the developers guide and the Gemini review useful for the cloud side of the same choice. The short version: Google just made it cheaper to not pay Google, and then kept the planning step on its own meter.

Questions or corrections? Email Pick Right. Want the full list? See all news.