Google Antigravity: The Complete Guide to Google's Agent-First IDE (2026)

Short answer: Google Antigravity is a free, agent-first IDE built on VS Code that runs multiple autonomous AI agents in parallel — each plans, writes code, runs terminal commands, and browses the web to verify its own work. It is fundamentally different from Cursor and Claude Code, which are single-threaded chat assistants. This is the complete guide: installation, the two core views, artifacts, the browser agent, rules, workflows, skills, MCP, security, and when Antigravity beats the alternatives.

If you want the broader landscape first, our Claude Code vs Cursor vs Windsurf comparison covers the full field. This guide is the deep dive on Antigravity specifically.

---

What Is Google Antigravity?

Google Antigravity is Google's free, agent-first IDE — and it's fundamentally different from every coding tool you've used before. While Cursor and Claude Code give you a single AI assistant in a chat panel, Antigravity gives you a Mission Control for autonomous agents.

The core idea: instead of asking one AI to do one thing at a time, you dispatch multiple agents to work on multiple tasks in parallel — and each agent can plan, write code, run terminal commands, and even browse the web to verify its own work.

It's built on the VS Code foundation (so your muscle memory transfers), but the entire experience is reorganised around agent orchestration rather than text editing. The result feels less like a chat-enhanced IDE and more like being an engineering manager who delegates work to a team of capable AI developers.

Antigravity is currently in free preview for personal Gmail accounts. Download it from antigravity.google/download.

---

How Antigravity Differs from Cursor and Claude Code

Before diving in, it helps to understand what's actually different — not just the marketing.

Every other AI coding tool today is synchronous and linear. You type a prompt, the AI responds, you review, you type again. Even "agentic" features like Cursor's Composer or Claude Code's sub-agents work in a single thread per main task. You wait for one thing before asking for the next.

Antigravity is asynchronous and parallel. You dispatch five agents to work on five different tasks simultaneously. While Agent 1 is refactoring your auth module, Agent 2 is generating test cases for the billing API, and Agent 3 is checking the docs for a library question. You come back, review the artifacts each produced, give feedback, and move on.

The other key differentiator is the built-in browser agent. When an Antigravity agent builds a web app, it doesn't just write the code and hand it back to you. It spins up the server, opens Chrome, navigates the app, clicks through the flows, takes screenshots and video recordings, and produces a verification walkthrough — all autonomously. You watch the video to confirm it worked rather than running it yourself.

This is exactly the kind of capability that pushes us up the 5 Levels of AI Coding Agents ladder — Antigravity sits at Level 3-4 by default, where most other tools are stuck at Level 2.

---

Installation

Antigravity is available for Mac, Windows, and select Linux distributions. You need a personal Gmail account — no paid subscription required during preview.

1. Download the installer for your OS from the official download page (linked above)
2. Run the installer and launch Antigravity
3. On the setup screen, choose your agent autonomy level (more on this below)
4. Import your VS Code or Cursor settings if you want — or start fresh
5. Sign in with your personal Gmail account

The autonomy level you set during setup is important. There are four modes:

• Secure Mode — Agent asks permission for almost everything. Slowest, safest.
• Review-driven development (recommended) — Agent asks for approval at key decision points: before executing terminal commands, before finalising implementation plans. Good balance.
• Agent-driven development — Agent proceeds autonomously with minimal checkpoints. Fastest, but higher risk of unwanted changes.
• Custom — You configure terminal, review, and browser JavaScript policies individually.

Start with Review-driven development. You can always loosen the controls once you trust how the agent behaves in your codebase. New to agent-first IDEs? Our Claude Code tutorial for beginners walks through the same mental model from a different angle and is a useful primer.

---

The Two Core Views

Antigravity has two primary interfaces, and understanding when to use each is key.

Agent Manager: Mission Control

This is what you see on launch. Think of it as your engineering management dashboard. You define high-level objectives and dispatch agents:

• "Refactor the authentication module to use refresh tokens"
• "Generate a complete test suite for the billing API"
• "Build a conference schedule website with Flask and dummy data"

Each task spawns a dedicated agent instance. The Manager view shows all your active agents, their status, the artifacts they've produced, and any pending approvals waiting on you. You can run five tasks in parallel and check on them whenever you're ready — the agents keep working while you're doing something else.

Editor: Familiar but Agent-Aware

Switch to the Editor with Cmd+E and you're in a VS Code-style interface. File explorer, syntax highlighting, extensions — all there. The difference is an agent side panel on the right (Cmd+L to toggle) where you can give inline instructions, highlight problematic code and ask for explanations, or send terminal errors directly to the agent.

The inline commands are particularly useful. Highlight any code, press Cmd+I, and describe what you want. The agent makes the change in-place, shows you a diff, and you accept or reject.

---

Artifacts: How Antigravity Proves Its Work

This is one of Antigravity's best ideas. Rather than just producing code and hoping you trust it, every agent creates a paper trail of artifacts:

• Task List — The agent's structured plan before it writes a single line of code. You can review and redirect before any work starts.
• Implementation Plan — Technical architecture: which files change, what the approach is, how it fits your codebase. This is the main review checkpoint where you give Google Docs-style comments.
• Code Diffs — Standard diff view, file by file, showing exactly what's changing.
• Walkthrough — Post-completion summary of what was done and how to verify it.
• Screenshots and Browser Recordings — For web tasks, the agent captures its own testing session as video. Watch a 30-second clip instead of running the app yourself.

The Google Docs-style comments on artifacts are the feedback loop. You don't need to re-prompt from scratch — you annotate the plan directly ("use FastAPI instead of Flask here", "add error handling for this case") and the agent ingests your comments and iterates.

---

The Browser Agent

The browser capability is what separates Antigravity from everything else. When you ask Antigravity to build a web app, the agent doesn't stop at writing code — it:

1. Starts your local dev server
2. Opens Antigravity's managed Chrome browser (via a Chrome extension)
3. Navigates through the app, clicks buttons, fills forms, waits for spinners
4. Records a video of the full interaction
5. Takes screenshots before and after changes
6. Reports results in the Walkthrough artifact

To set up the browser: start any conversation and give a task like "go to antigravity.google". When the agent needs browser access, it will prompt you to install the Chrome extension. Install it, grant permission once, and the browser is available for all future tasks.

The JavaScript execution policy in settings controls how much the browser agent can do. "Request review" is safest — the agent asks before running JavaScript. "Always proceed" gives maximum autonomy but increases exposure to prompt injection on external sites.

---

Building Your First App with Antigravity

Here's a real example to make this concrete. Let's build a simple web app end-to-end.

Open Agent Manager, select a workspace folder, and enter Planning mode. Then give this prompt:

Create a todo list web app.
- Backend: Python with FastAPI
- Frontend: HTML, CSS, vanilla JavaScript
- Features: add, edit, complete, delete todos
- Launch the app and verify all features work with browser testing
- Generate a README with setup instructions

What happens next:

1. The agent generates an Implementation Plan — you can comment "use SQLite for persistence" if you want, then approve
2. It creates a Task List — discrete steps like "create requirements.txt", "create main.py", "create index.html", "verify application"
3. It writes all the code and shows you diffs
4. It starts the FastAPI server, opens the browser, adds a few todos, edits one, marks one complete, deletes one, records the whole session as video
5. It delivers a Walkthrough with the video and a screenshot of the final state

If you want to change something — say the styling is wrong — comment directly on the screenshot in the Walkthrough: "Change the blue theme to orange." The agent makes the change, re-verifies in the browser, and updates the walkthrough.

---

Rules and Workflows: Codifying Your Standards

Once you're past basic use, you'll want Antigravity to follow your project's standards automatically — without repeating yourself in every prompt. This is the same mental model as the CLAUDE.md configuration pattern, just with different file paths.

Rules (Always-on guidelines)

Rules are passive instructions the agent always follows. Two scopes:

• Global rules (~/.gemini/GEMINI.md) — Apply to every project. Good for personal coding style: "always use TypeScript", "never hardcode API keys", "always write docstrings".
• Workspace rules (your-workspace/.agents/rules/) — Apply to this project only. Good for project-specific standards: "use the Repository pattern for DB access", "use Tailwind CSS", "modular file structure with one feature per file".

Example workspace rule (.agents/rules/code-style.md):

- All Python code follows PEP 8
- Every function must have a docstring
- No magic numbers — use named constants
- New features go in separate files, not in main.py

Workflows (On-demand saved prompts)

Workflows are saved prompts you trigger with / in the agent panel. Example: you create a generate-unit-tests workflow. Whenever you finish a feature, you type /generate-unit-tests and the agent writes and runs tests — no re-explaining what "unit tests" means in your project.

Create a workflow at .agents/workflows/generate-unit-tests.md:

- Generate unit tests for each method in the current file
- Use pytest with mock objects for external dependencies
- Name test files with test_ prefix
- Run tests and confirm they pass

---

Skills: Specialised Knowledge Packages

Skills are the most powerful customisation in Antigravity. A Skill is a directory-based package of specialised knowledge the agent loads only when relevant — preventing the "tool bloat" problem of loading everything into context all the time.

A skill has this structure:

my-skill/
├── SKILL.md       # Required: metadata + instructions
├── scripts/       # Optional: Python/Bash scripts
├── references/    # Optional: docs, templates, examples
└── assets/        # Optional: images

The SKILL.md frontmatter tells the agent when to load it:

---
name: code-review
description: Reviews code changes for bugs, style issues, and best practices. Use when reviewing PRs or checking code quality.
---

## Review checklist
1. Correctness: Does the code do what it's supposed to?
2. Edge cases: Are error conditions handled?
3. Style: Does it follow project conventions?
4. Performance: Are there obvious inefficiencies?

Save this to ~/.gemini/antigravity/skills/code-review/SKILL.md for a global skill, or to .agents/skills/code-review/SKILL.md for a workspace skill.

Now when you ask the agent to "review this file", it automatically finds and loads the code-review skill — and follows your checklist exactly.

---

MCP Servers: Connecting to External Tools

Antigravity has a built-in MCP store with one-click installs for Firebase, GitHub, databases, and dozens of other services. In Editor mode: ... menu → MCP Servers.

To add a custom MCP server manually, edit ~/.gemini/antigravity/mcp_config.json:

{
  "mcpServers": {
    "your-tool": {
      "command": "npx",
      "args": ["-y", "@your-org/mcp-server"],
      "env": {
        "API_KEY": "your-key"
      }
    }
  }
}

Any MCP server that works with Claude Code or Cursor works with Antigravity — same standard, same config format.

---

Security: Controlling What the Agent Can Do

Giving an agent terminal and browser access is powerful — and risky if unconfigured. Antigravity has a layered permission system:

• Allow list — Commands that auto-execute without prompting. Start narrow: add command(ls), command(git status), command(npm run dev) as you build confidence.
• Deny list — Commands that are always blocked. At minimum add command(rm -rf), command(curl | sh).
• Browser URL allowlist — Restrict which URLs the browser agent can visit to prevent prompt injection from malicious external pages.

Access permissions in Settings → Agent → Permissions. Use the format command(prefix) to match by prefix — command(git) allows all git commands.

---

Antigravity vs Claude Code vs Cursor: When to Use Which

These tools aren't fully interchangeable — they're optimised for different workflows.

• Antigravity — Best for large, multi-step tasks: "build this feature end-to-end", "refactor this module", "write and run tests for this whole service". Shines when you want the agent to run autonomously and come back with proof it worked. The browser verification is unmatched.
• Claude Code — Best for experienced developers who want a powerful terminal-native agent with fine-grained control. Strongest on complex, multi-file reasoning tasks. Best-in-class SWE-bench scores.
• Cursor — Best for developers who want AI deeply integrated into their everyday editing flow. Autocomplete, Tab completion, and inline edits are the smoothest in the category. Better for quick back-and-forth than long autonomous runs.

Many developers use all three. Antigravity for big autonomous tasks, Cursor for daily editing, Claude Code for complex reasoning problems.

We covered the full three-way comparison with specific test cases in Claude Code vs Cursor vs Windsurf, and the broader market context in the best AI coding agent in 2026. For solo developers picking just one, our Claude Code vs Cursor 2026 guide is the focused decision aid.

---

Getting Started Today

Antigravity is free during preview with a personal Gmail. No credit card, no waitlist.

1. Download from antigravity.google/download
2. Set up in Review-driven mode
3. Install the Chrome extension when prompted (first browser task)
4. Try the todo app example above — you'll see the full artifact flow in 10 minutes
5. Add one workspace rule that encodes your coding standards

With Google I/O on May 19, expect significant updates to Antigravity's model access and features. The timing to learn it now — before the I/O wave — is ideal.

Want to go deeper on AI-powered development workflows? We cover Antigravity, Claude Code, Cursor, sub-agents, MCP, and the whole AI builder stack at AI Builder Club — $37/mo for unlimited access to every course and 1,500+ builders shipping with these tools daily.