Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Google’s Antigravity SDK can now run agent work with local models, reducing cloud-token use while keeping source code on a developer’s machine. Announced on September 23, 2026, the initial documented path uses Gemma 4 26B A4B through Google AI Edge’s LiteRT runtime. The SDK can also connect to OpenAI-compatible local servers, including Ollama, LM Studio and vLLM.
What Google added to Antigravity
Antigravity is a Python library for building autonomous agents. Its scope includes tool execution, context management, safety policies, stateful multi-turn sessions, MCP connectivity, subagents, structured output, lifecycle hooks and streaming. It is a developer SDK, not Google’s managed cloud REST or gRPC API.
As an Amazon Associate I earn from qualifying purchases.
The new local-model support gives developers two routes:
- LiteRT: Antigravity manages a local Gemma 4 26B A4B model through Google AI Edge’s LiteRT runtime.
- OpenAI-compatible server: Antigravity sends requests to a local endpoint operated by software such as Ollama, LM Studio or vLLM.
Google says local agents can avoid cloud API charges and rate limits, continue working without an internet connection, and keep code and requests on the workstation. A hybrid design can still use a cloud model when broader reasoning or orchestration is valuable.
How to run a local Antigravity agent
The documented LiteRT workflow requires a Python environment, the google-antigravity and litert-lm packages, and a downloaded Gemma 4 26B A4B checkpoint. A typical environment setup is:
- Create and activate a Python virtual environment for the project.
- Install the
google-antigravityandlitert-lmpackages in that environment. - Download the Gemma 4 26B A4B checkpoint using the distribution process specified by Google’s local-model documentation.
- Configure Antigravity with
LiteRTAgentConfig, pointing it to the checkpoint and selecting the available execution backend. - Run the agent locally and verify that its tools, files and model requests resolve on the machine before processing sensitive code.
LiteRTAgentConfig supports GPU, NPU and CPU backends. GPU is the default in Google’s documented configuration, but the suitable backend depends on the hardware and the installed LiteRT support.
For an external server, install and start the local OpenAI-compatible service separately, load a model in that service, then configure Antigravity with LocalOpenAIAgentConfig and the server’s local endpoint. The external-server route gives more control over model serving, but the developer must maintain the endpoint, model files and compatibility settings.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Hardware requirements for Gemma 4 26B A4B
Google recommends more than 24GB of VRAM or unified memory for the documented local workflow. That recommendation is not a complete GPU compatibility list and does not guarantee a particular speed. A machine with less memory may require different model settings or may not run the documented configuration reliably.
| Execution route | Model and runtime | Memory guidance | Operational responsibility |
|---|---|---|---|
| LiteRT local | Gemma 4 26B A4B with Google AI Edge LiteRT | More than 24GB of VRAM or unified memory recommended | Antigravity manages the LiteRT integration; you provide the model checkpoint and hardware |
| Local OpenAI-compatible server | A model served by Ollama, LM Studio or vLLM | Depends on the selected model and server configuration; not stated by Google for every model | You install, configure and maintain the local server and endpoint |
| Cloud agent | Cloud-hosted model | No local model memory requirement | Internet access and the relevant cloud service are required |
The Architect-Builder hybrid pattern
Google highlights an Architect-Builder arrangement for teams that want cloud-level planning without sending source code to a cloud model. A cloud planner decomposes the job, while local agents perform the token-intensive inspection and patch cycle.
- The planner receives filenames and task descriptions rather than source files.
- It creates an audit plan and assigns work to local agents.
- Local workers inspect the repository, reproduce vulnerabilities, propose fixes and critique candidate patches.
- Local validation agents run regression tests and report results to the orchestrator.
This division lets a team use cloud reasoning for coordination while the implementation loop remains on the workstation. It is not automatically private: any additional tool, MCP server, telemetry component or cloud step can create a separate data path that must be reviewed.
How much cloud-token usage can fall?
In Google’s recorded hybrid security-audit demonstration, 3,322 of 3,417 total tokens ran locally and offline. The cloud planner used 95 tokens, which Google reports as 97.2% of the total running locally.
Recommended Free Tools
| Part of demonstration | Tokens | Where they ran |
|---|---|---|
| Local agents | 3,322 | On-device and offline |
| Cloud planner | 95 | Cloud |
| Total | 3,417 | Combined |
These figures come from Google’s recorded demonstration, not an independent benchmark. They show what is possible for that security-audit workflow, not a guaranteed percentage for every repository, model, prompt or agent design. Local execution can eliminate cloud calls for the local portion, but the hardware, electricity and setup effort remain costs.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.What “private” means in this setup
Google describes a configuration in which Gemini plans from filenames and task descriptions while local Gemma agents inspect and modify the source. In that arrangement, source code is not uploaded during planning. The privacy boundary depends on preserving that division in the actual implementation.
- Check every agent tool and MCP server for outbound network access.
- Review cloud planning prompts so they contain no source excerpts, secrets or sensitive identifiers.
- Inspect logs, traces and error-reporting settings for accidental code capture.
- Restrict local agents to the repositories and commands they need.
- Test the workflow with network monitoring if compliance requirements are strict.
Local inference improves control, but it does not make an entire application private by default. A developer can still upload data through a tool, dependency, telemetry feature or manually added cloud step.
Local-only, cloud-only or hybrid?
| Decision factor | Local-only | Cloud-only | Hybrid |
|---|---|---|---|
| Privacy boundary | Source and requests can remain on the machine if tools are local | Requests and supplied context go to the cloud service | Source can stay local while planning metadata goes to the cloud |
| Token and API cost | No cloud API calls for local work | Cloud usage applies to the workflow | Cloud cost is limited to planning or selected tasks |
| Connectivity | Can operate offline after setup | Internet access is required | Local work can continue offline, but cloud planning needs connectivity |
| Capability and scale | Constrained by the local model and hardware | Can use larger or more capable hosted models | Uses cloud reasoning where it adds value and local workers for execution |
| Hardware and maintenance | Highest local hardware burden | Minimal model hardware locally | Local hardware plus cloud-service configuration |
| Operational control | Maximum control after setup | Provider controls serving infrastructure | Control is split between local workers and the cloud planner |
Important limits before deployment
Google has not published a full compatibility matrix for every GPU, a guaranteed speed improvement or an independent validation of the 97.2% token figure in the cited announcement and documentation. Teams should benchmark their own repositories, prompts and test suites before making performance or cost commitments.
The local-server option also shifts responsibility to the developer. Endpoint authentication, model loading, process supervision, updates and data retention policies must be handled alongside the Antigravity configuration. LiteRT reduces that integration work, but it still requires a suitable accelerator or sufficient CPU resources and the model checkpoint on disk.
For organizations with strict data rules, the most defensible rollout is to start with a local-only task, audit all tools and network paths, then add a cloud planner only for metadata that policy permits to leave the workstation.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
