Google Antigravity 101

Google Antigravity is Google’s agent-first development platform. It launched in public preview on November 18, 2025 alongside Gemini 3, and just six months later (May 19, 2026, at Google I/O) Google shipped Antigravity 2.0 as a full agentic development suite: a desktop IDE, a CLI, an SDK, Managed Agents inside the Gemini API, and an enterprise platform. The shift Antigravity represents is not "AI completion bolted onto an editor." It is a deliberate bet that the next era of developer tooling is task-oriented rather than line-oriented, and that autonomous coding agents need their own surface to plan, execute, and verify work in rather than a sidebar to chat in.

This post is a foundational 101 for Google Antigravity: what it is, the two ways you interact with it, how its Artifacts model lets you trust the agent’s output, what models it ships with, how to install it, what’s new in the 2.0 release, and where it fits in the broader agentic coding landscape. It is not a tutorial. Each section points toward deeper coverage we plan to publish as the series fills out.

What Google Antigravity actually is

Antigravity is an AI-powered integrated development environment built around the idea that coding agents should be first-class collaborators rather than chat assistants. The platform is a heavily modified fork of Visual Studio Code with substantial additions to support autonomous agent workflows. Google has not publicly detailed the codebase lineage in its own announcement materials. There has been public debate (covered by Visual Studio Magazine and others) over whether Antigravity descends directly from VS Code or from Windsurf, the AI editor whose technology Google licensed in a roughly $2.4 billion deal in July 2025. Windsurf itself is a VS Code fork, which complicates the question rather than resolving it. The honest summary is that the exact lineage is unconfirmed by Google.

The underlying premise is that agents work better when they have direct access to the same tools a developer uses: the editor, the terminal, and a browser. In Antigravity, agents have all three by default. An agent can write code, run a build, launch the application, open it in an integrated browser, click through the flows, take screenshots, and verify that what it built actually works, all without human intervention at each step. The platform also treats learning as a core primitive: agents can save useful context and code snippets to a per-workspace knowledge base so future tasks benefit from past work.

Antigravity is currently a free public preview for individuals, with generous rate limits on Google’s frontier models. Paid tiers exist for higher usage, and enterprise customers get a separate managed path through the Gemini Enterprise Agent Platform.

The two views: Editor and Manager

Antigravity exposes two primary surfaces, and the difference between them is the cleanest way to understand the product.

The Editor view is a state-of-the-art AI IDE in the lineage of VS Code, Cursor, and Windsurf. You get the file explorer, syntax highlighting, extensions, an integrated terminal, tab completions, and inline commands. An agent sidebar lives to the right; you can send highlighted code, terminal output, or error messages directly to the agent. If you have used Cursor or GitHub Copilot, the Editor view feels immediately familiar. This is where you go when you want to be hands-on.

The Manager view (also called the Manager surface in Google’s announcement) is the new idea. It is a control center for orchestrating multiple agents working in parallel across different workspaces, asynchronously. You can spawn up to five agents at once, each working on a different task in a separate workspace, observe their progress, leave feedback on what they produce, and pick up the next one when one finishes. The Manager view is where you go when you want to delegate. The product’s deeper claim is that the Manager surface, not the Editor view, is where the workflow actually shifts. You stop reading every line the agent writes and start reviewing finished work the way a tech lead reviews a pull request.

Artifacts: how you verify the agent’s work

Delegating to an autonomous agent requires trust, and trust requires verification. Scrolling through raw tool calls to confirm an agent did what it said is tedious and doesn’t scale. Antigravity’s answer is Artifacts: tangible deliverables the agent produces as it works, designed to be reviewed at a glance rather than parsed line by line.

The Artifact types ship in roughly four flavors. Task lists are structured plans showing the sequence of steps the agent intends to execute, so you can validate the approach before it starts. Implementation plans are technical architecture documents covering the design decisions the agent is making. Code diffs are line-by-line change views you can review the way you’d review a pull request. Walkthroughs are post-completion summaries that include screenshots, browser recordings, and testing results. When the agent finishes building a feature, the walkthrough Artifact is essentially the agent saying, "Here is what I built, here is the application running, here is me clicking through it, here is what passed."

The interaction model on Artifacts is the other half of the design. You can leave feedback directly on an Artifact, comment-on-a-Google-Doc style, and the agent will incorporate your input without stopping its execution flow. The effect is that the human role shifts from "watch the agent type" to "review the agent’s work product." For long-running tasks especially, that is a meaningful productivity change.

What an agent can actually do

Three workflow patterns capture what Antigravity agents are designed for.

The first is end-to-end software tasks. Give the agent a feature description, and it can write the code, use the terminal to launch the application, use the integrated browser to test the result, and verify behavior, all without you switching contexts. The agent owns the loop from design to verification.

The second is task-oriented UI work. Ask for a UI change in plain language, and the agent modifies the codebase, then communicates progress and results back through Artifacts (screenshots, walkthroughs) that give you enough context to validate the work without re-implementing it in your head. The premise is that UI changes are exactly the kind of work where reviewing the rendered result is faster than reading the diff.

The third is long-running maintenance and bug fixes through the Manager surface. You dispatch agents in the background to reproduce an issue, generate a test case, and implement a fix, while you continue with your primary work and check in on the result when the agent reports back. This is the workflow that the Manager view is purpose-built for: many tasks running asynchronously, with you supervising rather than driving each one.

For background on what AI agents are in general and how the broader category works, our AI agents pillar covers the foundations, and our breakdown of AI agent frameworks compared covers how the open-source frameworks (LangGraph, CrewAI, AutoGen) approach the same orchestration problem from the framework side.

Model choice: Gemini, Claude, GPT-OSS

Antigravity is multi-model from day one. As of May 2026, the public preview ships with multiple model options across three families. Google’s own family is represented by Gemini 3 Pro and Gemini 3 Flash. Anthropic’s family is represented by Claude Sonnet 4.6 and Claude Opus 4.6 (both with explicit Thinking variants alongside the standard releases). OpenAI’s open-source GPT-OSS 120B rounds out the list.

The defaults are tuned for Gemini, which is what Google subsidizes most heavily in the free preview. Anthropic’s and OpenAI’s open model are available because the platform is positioned as model-agnostic at the routing layer. For Claude specifically, you have two access paths: route through Google’s infrastructure using your Google account (no Anthropic billing surface, no separate key to manage) or bring your own Anthropic API key from Antigravity’s settings and bill Anthropic directly. The model mix will keep changing as Google’s own model lineup updates (Gemini 3 Flash arrived in December 2025, Gemini 3.5 Flash was announced at I/O 2026); expect the in-product model list to reflect those shifts on a rolling basis.

For context on where Google’s frontier models stand today, our coverage of Gemini 3.5 Flash for AI coding covers the most recent generation, and our Claude Code vs OpenAI Codex comparison covers two of the alternative coding-agent products Antigravity competes with most directly.

Pricing and how to install

Google Antigravity is free for individuals in public preview. You go to antigravity.google/download, choose your platform (macOS, Windows, or Linux), run the installer, and sign in with your Google account. No credit card and no waitlist; you only need to bring your own API key if you specifically want to bill Claude usage to Anthropic instead of going through Google’s infrastructure. Cross-platform support covers macOS Monterey 12 or later, 64-bit Windows 10 or later, and 64-bit Linux with glibc 2.28 or later.

Paid tiers exist for users who exceed the free preview’s rate limits. The base Pro tier is included with existing Google AI Pro subscriptions. At I/O 2026, Google introduced a new AI Ultra tier at $100 per month with five times the AI Pro usage limits in Antigravity. The top-tier AI Ultra plan was simultaneously repriced from $250 to $200 per month and offers twenty times the Pro limits. Enterprise customers get a separate path through the Gemini Enterprise Agent Platform.

The "free preview" framing matters operationally. As long as Antigravity is in preview, pricing and rate limits can change, and the product itself is being iterated on at the cadence of a v1.x application (1.11.2 at launch in November 2025; 1.22.2 in early April 2026). It is fine to build real workflows on it, but plan for the preview status to end on Google’s timeline rather than yours.

What’s new in Google Antigravity 2.0

The 2.0 release on May 19, 2026 expanded Antigravity from a single desktop application into a multi-surface platform. There are five pieces.

The desktop app got a substantial revamp around multi-agent orchestration. You can design custom subagent workflows (agents that spawn and supervise other agents), schedule tasks to run automatically in the background, and treat the Manager view as a genuine fleet console rather than a side panel for parallel chats.

The Antigravity CLI is brand new, built in Go for performance, and replaces the prior Gemini CLI. (Google announced that Gemini CLI and the Gemini Code Assist IDE extensions will stop serving requests for Google AI Pro and AI Ultra users, as well as those using Gemini Code Assist for individuals free of charge, on June 18, 2026. The Antigravity CLI is the migration target. Organizations on Gemini Code Assist Standard or Enterprise licenses, and Gemini Code Assist for GitHub via Google Cloud, are explicitly carved out of the sunset and continue to have access to Gemini CLI with the latest models.)

The Antigravity SDK lets you host agents on your own infrastructure. Where the desktop app and CLI run agents in Google’s environment, the SDK gives you the building blocks to build and run agents inside your own systems, including against your own data and your own deployment targets.

Managed Agents in the Gemini API is the conceptual jump. Google has made agentic workflows callable through the Gemini API the same way you currently call a chat completion. You hand off a task; the managed agent plans, executes, verifies, and returns a result. This puts the agent loop on the API side rather than requiring the caller to run it.

The Gemini Enterprise Agent Platform is the enterprise deployment story: managed execution, governance, identity integration, and the operational controls that companies need before agents get production access to real systems.

Taken together, 2.0 turns Antigravity from "an IDE with agents in it" into "a platform for building, running, and operating agentic workflows," with the desktop IDE as the most visible surface but no longer the only one.

Where Antigravity fits in the agentic coding landscape

Antigravity is one of several agent-first products that have shipped in the last twelve months. Anthropic’s Claude Code (CLI plus VS Code extension plus desktop and web apps) and OpenAI’s Codex (newly shipped to mobile in 2026) cover similar ground from different starting points, and our Claude Code vs OpenAI Codex mid-2026 comparison covers how those two stack up. The open-source agent frameworks (LangGraph, CrewAI, AutoGen) represent the build-it-yourself path, where you orchestrate the loop in your own code rather than buying a product that already runs it.

A practical way to read the field: Claude Code and Codex are agentic CLIs first and IDE extensions second; Antigravity is an agentic IDE first and a CLI/SDK second. They will continue to converge on each other (Antigravity now has its own CLI; Claude Code has a desktop app; Codex now runs on mobile), but the orientation differences still show through in how each product is set up out of the box.

The shared infrastructure story underneath all of these is the standardization of how agents talk to external systems. The Model Context Protocol (MCP) is the most visible piece of that, and Antigravity, Claude Code, and Codex all support MCP for connecting to tools, data sources, and external services. Picking an agentic IDE in 2026 is less about model lock-in than it has been in past years; the model layer is increasingly portable and the differentiation has moved to orchestration, verification (Artifacts in Antigravity’s case), and the surrounding workflow.

What this means for development teams

For an individual developer evaluating Antigravity right now, the immediate practical impact falls into a few buckets:

• If most of your coding day is hands-on writing with assistance, the Editor view is a competent member of the Cursor/Windsurf/Copilot category and is free to try. The bar to switch is largely about whether the agent integration in the right panel is a better fit than what you use today.
• If you have multi-step or long-running tasks you’d genuinely delegate (refactors, bug reproductions, feature scaffolds, test generation), the Manager view is the part of the product that changes the workflow. Spawn a few agents on background tasks and review the Artifacts when they finish.
• If you build with Gemini already, the free preview’s rate limits on Gemini 3 Pro are generous, and the model integration is the most polished. If you’re a Claude-first developer, the Anthropic models are present (via Google’s infrastructure or your own Anthropic key) but Claude Code is still likely the path of least resistance.
• If you maintain a CLI-driven workflow and were on Gemini CLI, the Antigravity CLI is the migration target before the June 18, 2026 cutoff. Plan that migration on a real timeline rather than a “I’ll get to it” timeline.
• If you’re an enterprise that needs governance, identity integration, and managed execution, the Gemini Enterprise Agent Platform (and the Managed Agents API) is where the procurement conversation actually lives, not the free desktop app.

The deeper question Antigravity asks is whether your team is ready to operate at the task level rather than the line level. The Editor view is a competent assistant in either mode. The Manager view only pays off if you have work that genuinely benefits from being delegated and verified, rather than written and reviewed. For teams whose work matches that shape, Antigravity is one of the first products built around that workflow from the ground up.

Frequently Asked Questions