Most AI coding tools follow the same pattern: one model, one conversation, one context window. You talk to an assistant, it generates code, you copy-paste it, and you deal with whatever breaks. Google thinks that model is already outdated. At I/O 2026, the company launched Google Antigravity 2.0 — not just another coding assistant, but a full agent-first development platform designed around the idea that software gets built better when multiple specialised agents collaborate on the same task.
The timing is deliberate. Google’s previous command-line tool, Gemini CLI, reaches end of life on 18 June 2026. Antigravity is not a rebrand. It is a ground-up replacement built on a fundamentally different architecture, and understanding what that architecture does — and does not — change is worth the few minutes it takes.
What Is Google Antigravity
At its core, Antigravity is a development environment where AI agents do the heavy lifting of writing, reviewing, testing and deploying code. Rather than offering a single chat interface that generates snippets on demand, Antigravity treats the entire development lifecycle as something agents can participate in — from scaffolding a new project to running CI pipelines and suggesting infrastructure changes.
The platform ships in three forms: a desktop application for those who prefer a visual interface, a command-line tool called “agy” written in Go for terminal-native developers, and a software development kit for teams that want to embed agent capabilities into their own workflows. All three share the same underlying engine and can be used interchangeably on the same projects.
What makes this different from, say, asking ChatGPT to write a function is scope. Antigravity is not trying to be a better autocomplete. It is trying to be the environment in which your project lives, with agents that understand the full codebase, track dependencies, and coordinate changes across multiple files simultaneously. Whether it actually delivers on that ambition in practice is something the developer community is still stress-testing, but the intent is clear.
The Multi-Agent Bet
The architectural decision that sets Antigravity apart from most competitors is multi-agent orchestration. Instead of routing every request to a single large language model, the platform can spin up multiple specialised subagents — each handling a different aspect of the same task — and coordinate their outputs into a coherent result.
In practical terms, this means you can define a workflow where one agent writes the implementation, another writes unit tests for it, a third reviews both for security issues, and a fourth updates the documentation. These agents run in parallel where possible, and the orchestration layer resolves conflicts between their outputs before presenting you with a unified changeset.
The system supports custom subagent workflows, which means teams can design their own agent pipelines tailored to their development practices. A backend team might set up a workflow that includes a database migration agent; a frontend team might include an accessibility linting agent. The agents are composable, and Google provides templates to get started without having to design everything from scratch.
What is genuinely interesting here is the multi-model support. Antigravity does not lock you into Google’s own models. The default model is Gemini 3.5 Flash, which handles the majority of everyday coding tasks with good speed and reasonable cost. But you can also route specific agents to Gemini 3 Pro for tasks requiring deeper reasoning, to Claude Sonnet 4.5 for its strength in nuanced language tasks, or even to GPT-OSS if your team has preferences or compliance requirements that favour it. Each agent in a workflow can use a different model, which means you are not forced to choose one model for everything — you can match the model to the task.
This is a meaningful departure from the single-model approach. Most coding assistants today are built around one provider’s models, and switching means switching tools. Antigravity treats models as interchangeable components, which gives teams more flexibility but also introduces a layer of complexity in configuration that simpler tools avoid.
Desktop, CLI And SDK
The three entry points into Antigravity serve different audiences, but they are not different products. They share the same backend, the same agent engine, and the same project configuration.
The desktop app is the most approachable. It provides a visual interface for managing agents, viewing changelogs, and reviewing the diffs that agents produce before accepting them. For developers who are accustomed to IDE-style workflows, this is the most familiar starting point.
The agy CLI is where terminal-oriented developers will spend their time. Built in Go for performance and cross-platform compatibility, it supports everything the desktop app does but through commands and flags. Scripting agent workflows, integrating Antigravity into existing CI/CD pipelines, or running agents in headless mode on remote servers — all of that lives here. For teams already using Gemini CLI, migration is straightforward: Google provides a command that reads existing Gemini CLI configurations and converts them into Antigravity equivalents.
The SDK is the most powerful and the least accessible. It provides programmatic access to the full agent engine and is designed for teams that want to run agents in isolated Linux environments — sandboxed containers where agents can execute code, install dependencies, and run tests without touching the host system. This is particularly relevant for enterprise teams with strict security requirements, where letting an AI agent run arbitrary code on a developer’s machine is not acceptable.
The SDK also enables what Google calls “ambient agents” — long-running agents that monitor a repository and perform routine tasks automatically. Think of a bot that watches for new pull requests and runs a security review agent on every one, or an agent that detects when a dependency has a known vulnerability and opens a fix automatically. These are not hypothetical features in a roadmap; they work today, though how reliably in complex real-world codebases remains an open question.
The Google Cloud integration deserves a mention. Antigravity connects natively to Cloud Build, Cloud Run, Artifact Registry and other Google Cloud services. For teams already in that ecosystem, the friction of going from local development to deployment is significantly reduced. For teams that are not, this integration is less relevant but not a requirement — Antigravity works with any infrastructure.
Pricing And Models
Google has structured Antigravity’s pricing around its existing Google One AI tiers. The free tier provides access to the platform with usage limits that are generous enough for individual developers experimenting with the tool, but insufficient for sustained professional use.
AI Pro, included in Google One AI subscriptions, removes the most restrictive limits and provides reasonable throughput for daily development work. For teams that need more, AI Ultra at $100 per month offers roughly five times the capacity, and AI Ultra 20x at $200 per month pushes that to twenty times — aimed at organisations running agents continuously across multiple repositories.
The pricing is aggressive compared to the market. Most competing platforms with comparable agent capabilities charge significantly more, or gate advanced features behind enterprise contracts with opaque pricing. Google’s willingness to publish clear tiers with explicit multipliers is a competitive move that pressures the rest of the market to be more transparent.
Whether the value justifies the cost depends entirely on how much of the multi-agent orchestration a team actually uses. For a solo developer who primarily needs code generation and review, the free or Pro tier is likely sufficient. For a team running automated agent pipelines across a large codebase, the Ultra tiers start to make economic sense — especially when compared to the engineering hours those agents replace.
It is still early to know whether agent-first development will become the norm or remain a power-user pattern. What is clear is that the direction of travel — from single-model assistants to coordinated multi-agent systems — represents a structural shift in how AI tools for developers are being designed. Antigravity is Google’s bet that developers will eventually want their AI to do more than answer questions, and that the right architecture for that is one where specialised agents collaborate rather than one general agent tries to do everything. The interesting question is not whether this approach works in demos. It is whether it holds up at the scale and messiness of real projects, with real deadlines and real legacy code. That answer will take months, not days.
