Google Antigravity 2.0: The Agentic Development Platform That Wants to Replace Your IDE

The story of developer tools over the past three years has been one of steady incremental addition: a Copilot here, an autocomplete there, a chat panel bolted to the side of an editor that developers already know and trust. The tools got better, but the underlying model — human in the driver’s seat, AI offering suggestions — remained intact.

Google’s Antigravity 2.0, announced at I/O 2026 on May 19, is a more radical proposition. It does not try to add agentic capabilities to an existing editor. It starts from the premise that agents should be the primary interface for development, and builds a platform around that assumption from scratch.

The result is a standalone desktop application — available on macOS, Windows, and Linux — paired with a command-line interface, a developer SDK, and a managed execution environment in the Gemini API, all organized around the idea that developers should be operating at the level of tasks and goals, not individual file edits and command executions.

The Core Architecture: Tasks Over Files

Traditional IDEs are file-centric. You open a project, navigate to files, edit lines, run tests, commit changes. AI coding assistants have layered onto this model, offering completions and refactors within the file paradigm. Antigravity 2.0 inverts this: the primary unit of work is a task, and the agent figures out which files need to be opened, modified, and verified to complete it.

The key architectural primitives in 2.0 are subagents, hooks, and asynchronous task management. Subagents allow a primary agent to spawn parallel workers for independent subtasks — one investigating failing tests, another checking API documentation, a third generating a draft implementation — with their results synthesized into a coherent output. Hooks enable developers to define triggers: when the agent encounters a specific condition, what should happen automatically. Asynchronous task management means the developer can submit a task, step away, and receive a notification when the work is complete, rather than supervising every step.

These three primitives together enable a workflow that is qualitatively different from anything available in current AI coding tools. A developer can describe a feature — “implement user authentication with OAuth 2.0 support, write unit tests, and update the API documentation” — and Antigravity’s agent will plan the work, distribute it across subagents, execute across the editor, terminal, and browser, verify the results, and present the finished work for review. The developer’s role shifts from executor to reviewer.

The Knowledge Base: Agents That Learn

One detail of Antigravity 2.0 that has attracted attention from developers is its knowledge base primitive. Unlike stateless coding assistants that treat each session as a blank slate, Antigravity agents can persistently store context, code snippets, documentation notes, and architectural decisions in a knowledge base that persists across sessions.

This is significant for long-running projects. A developer who explains that the project uses a custom event-bus pattern, prefers functional over object-oriented style, or has specific conventions around error handling — that information becomes part of the agent’s persistent context. Future tasks inherit those constraints automatically, without the developer needing to re-establish them in every conversation.

The knowledge base can also be populated programmatically through the Antigravity SDK, enabling teams to pre-load project-specific documentation, internal API references, and style guides before agents begin work. For enterprise use cases, this transforms the platform from a general-purpose coding assistant into something closer to an onboarded team member with institutional knowledge.

Model Optionality and Cross-Provider Support

One of the more surprising aspects of Antigravity 2.0 is its explicit support for models from competing providers. The platform ships with generous rate limits on Gemini 3.5 Flash and Gemini 3 Pro as the primary models, but also supports Anthropic’s Claude Sonnet 4.5 and OpenAI’s GPT-OSS in the same interface. Developers can configure which model to use per task, or let the platform select based on task type.

This is a deliberate strategy. Google’s bet is that the platform — the tooling, the workflow, the deployment infrastructure — is the sticky layer, not the model. By supporting competitive models, Antigravity reduces the switching cost for developers who already use Claude or GPT in other contexts, while keeping Google’s models in the default position that most users will never change.

The move mirrors how Amazon Bedrock handles model choice on the AWS side: the cloud and tooling infrastructure is the moat, and model portability is a feature rather than a threat.

The CLI and SDK: Headless and Embeddable

For developers who prefer not to work in a GUI, Antigravity ships a first-class CLI that provides full access to the platform’s agent orchestration capabilities from the terminal. The CLI is designed to integrate with existing CI/CD pipelines — a task can be triggered by a merge request, a failing test suite, or a scheduled cron job, with results committed back to a branch and a pull request created automatically.

The Antigravity SDK gives developers programmatic control over agent behavior, allowing custom tools, data connectors, and execution environments to be registered and made available to agents within the platform. The SDK integrates with Google AI Studio for model configuration, Firebase for state persistence and real-time updates, and Cloud Run for serverless deployment of agent-managed services.

The Android extension is a notable addition. A stable Android CLI enables Antigravity agents to interact directly with Android Studio and perform tasks like downloading the Android SDK, configuring emulators, and running apps on connected devices. For mobile developers, this means that the same task-oriented workflow available for backend and web development can now extend to native Android work.

Enterprise Deployment and Security

Antigravity 2.0 ships with enterprise support through the Gemini Enterprise Agent Platform, which provides the compliance and security features required for production deployment in regulated environments. This includes audit logging of agent actions, role-based access control for knowledge base contents, and configurable policy enforcement for which tools and external services agents are permitted to invoke.

For Google’s enterprise customers, the Gemini Enterprise Agent Platform integration connects Antigravity to the broader Google Workspace ecosystem. Agents can read and write to Google Drive and Docs, interact with Google Sheets as a data source, and trigger Google Cloud workflows — capabilities that significantly extend the range of work an agent can complete without requiring the developer to manually bridge between the development environment and the collaboration layer.

Availability and Pricing

Antigravity 2.0 is available in public preview starting at the I/O launch date. Individual access is free with generous model usage limits. Enterprise pricing is available through Google Cloud and the Gemini Enterprise Agent Platform.

The public preview framing is important: Google has explicitly invited developer feedback on the new primitives, particularly the subagent orchestration behavior and the knowledge base feature. Given that Antigravity competes directly with tools like Anthropic’s Claude Code, Cursor, and GitHub Copilot Workspace — all of which have significant developer adoption — Google’s ability to iterate quickly based on early user feedback will be a key factor in determining whether the platform achieves mainstream traction.

The Competitive Picture

The announcement lands in a market where the agentic IDE category is actively being contested. Claude Code, which Anthropic ships as a CLI-first agentic coding tool, has achieved strong adoption among professional developers. Cursor’s AI-first editor has attracted a large user base among developers who want AI deeper in the editing loop. GitHub Copilot Workspace and Devin have taken different approaches to agent-based software development at the task level.

Antigravity 2.0 is Google’s most direct attempt to compete in this space with a first-party, fully integrated platform. Its advantages are integration depth — particularly with Android development and Google Cloud deployment — and the ability to leverage Google’s model infrastructure at scale. Its challenge is the same one Google faces in developer tools generally: trust. Developers are conservative about their tooling, and persuading them to adopt a new primary development environment requires demonstrated reliability, not just impressive demos at a keynote.

The platform’s support for Anthropic and OpenAI models is, in this light, a smart concession: it lowers the adoption bar by allowing developers to continue using familiar models in a new context, while betting that the platform experience will prove compelling enough to keep them engaged long after the initial switch.