How to use Google Antigravity: a hands-on guide to the new agentic IDE

Google Antigravity dropped in late November 2025 and immediately stole half the attention from Cursor and Claude Code. It's Google's bet on what an agentic IDE should look like — not a chat sidecar bolted onto VS Code, but an editor designed from the ground up around agents that plan, edit, run and verify their own work. Six months in, the tooling has stabilised enough to write a serious how-to. This is the guide we wish we'd had on day one.

1. What Antigravity actually is

Antigravity is a fork of VS Code (like Cursor and Windsurf), but with three things that are genuinely different:

• Agent Manager — a first-class panel for spawning, watching and steering multiple parallel agents, each on its own task
• Inspector / Artifacts — every agent produces a verifiable artifact (screenshots, test output, browser recordings) you can review before accepting changes
• Gemini-native — tuned for the Gemini 3 family, with deep integration of long context and tool use, plus optional Claude and GPT routing

┌──────────────────────────────────────────────────────────────┐
│  Antigravity IDE                                             │
│                                                              │
│  ┌──────────┐   ┌─────────────────────┐   ┌──────────────┐   │
│  │ Editor   │   │  Agent Manager      │   │  Inspector   │   │
│  │ (VS Code │   │  ┌───────────────┐  │   │  ┌────────┐  │   │
│  │  base)   │   │  │ Agent #1: ... │  │   │  │ Diff   │  │   │
│  │          │◄──┤  │ Agent #2: ... │  ├──►│  │ Tests  │  │   │
│  │          │   │  │ Agent #3: ... │  │   │  │ Shots  │  │   │
│  └──────────┘   │  └───────────────┘  │   │  └────────┘  │   │
│                 └──────────┬──────────┘   └──────────────┘   │
│                            │                                 │
│                ┌───────────▼───────────┐                     │
│                │  Models: Gemini /     │                     │
│                │  Claude / GPT (route) │                     │
│                └───────────┬───────────┘                     │
│                            │                                 │
│                ┌───────────▼───────────┐                     │
│                │  Tools / MCP servers  │                     │
│                └───────────────────────┘                     │
└──────────────────────────────────────────────────────────────┘

2. Install Antigravity (macOS, Windows, Linux)

Antigravity ships as a standalone download. Don't try to install it as a VS Code extension — it isn't one. Grab the installer from antigravity.google (the official domain Google uses) and run it like any other desktop app.

# Homebrew cask (community tap, mirrors official releases)
brew install --cask google-antigravity

# Or download the .dmg directly from antigravity.google
# Drag Antigravity.app into /Applications
# First launch will ask for Google sign-in

# Add Google's signing key + repo
curl -fsSL https://antigravity.google/keys/apt.gpg | sudo gpg --dearmor \
  -o /usr/share/keyrings/antigravity.gpg

echo "deb [signed-by=/usr/share/keyrings/antigravity.gpg] \
  https://antigravity.google/apt stable main" | \
  sudo tee /etc/apt/sources.list.d/antigravity.list

sudo apt update && sudo apt install antigravity

On first launch you'll be asked to sign in with Google. Use the same account you want to bill the Gemini usage against. The free tier is generous enough to evaluate (~50 agent runs/day on Gemini 3 Pro at the time of writing); the paid plan unlocks longer contexts and parallel agents.

3. Open your first project and run your first agent

Open any existing repo with File → Open Folder… or from the terminal:

# From your project root
antigravity .

Antigravity indexes the codebase in the background (you'll see a small progress indicator in the status bar). Wait for it to finish — agent quality drops sharply if you fire a task before indexing completes. Once it's done, open the Agent Manager with Cmd+Shift+A (or Ctrl+Shift+A on Linux/Windows).

Type the task in the Agent Manager input, hit Enter. Antigravity will draft a plan first (files to touch, commands to run, verification steps), wait for you to approve or edit, then execute.

4. The Inspector — the part everyone misses at first

When the agent finishes, do NOT click Accept yet. Open the Inspector tab. For every run, Antigravity produces:

• A diff of every file changed
• Command output from anything the agent ran (test runs, builds, curls)
• Browser screenshots if the agent touched UI (it actually opens a headless browser to verify)
• A natural-language summary of what was attempted and what evidence supports success

Reviewing the Inspector before accepting is the entire skill. Anyone can fire prompts. The good Antigravity users read the evidence, push back when verification is thin, and re-run with sharper instructions.

5. Wire up MCP servers (where the real power lives)

Antigravity ships with native [[mcp-explained-2026|MCP]] support. You can connect any MCP server — your Postgres, GitHub, Linear, internal docs — and the agent will discover and use them in its plans automatically.

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres",
               "postgresql://localhost/mydb"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "ghp_xxx" }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem",
               "/Users/you/Documents/notes"]
    }
  }
}

Restart Antigravity after editing the file. You'll see the new servers in Settings → MCP with a status dot. Tools become visible to agents on their next run — no further configuration.

6. The three workflow patterns that pay off

Pattern A: Single-task spike

One agent, one tightly-scoped task, watch and accept. Ideal for adding a route, fixing a small bug, generating a migration. This is where Antigravity feels like Cursor + extra evidence.

Pattern B: Parallel exploration

Spawn three agents with three different approaches to the same problem ("implement rate limiting using Redis", "… using Cloudflare", "… in-memory with a token bucket"). Compare diffs and test output in the Inspector, pick the winner, kill the rest. This is the headline feature of the IDE and the move that justifies switching.

Pattern C: Long-running background worker

Hand the agent a longer task ("add tests until coverage hits 80% in /src/billing"), let it iterate while you do other work. The Agent Manager keeps the run state and notifies you when it's done or blocked. Pair this with the Inspector and you've got a genuine async dev loop.

7. Settings worth changing on day one

1. 1

   Model routing

   set Gemini 3 Pro as default, Claude Opus as fallback for complex reasoning, Gemini Flash for trivial edits. Saves ~40% on token spend with no quality drop

2. 2

   Auto-accept threshold

   turn this OFF for the first week. You want to see the Inspector for every run until you trust it

3. 3

   Workspace rules

   create .antigravity/rules.md in your repo and codify your conventions there (test framework, code style, what NOT to touch)

4. 4

   Telemetry

   opt out under Settings → Privacy if you're on a client codebase. The default sends prompt and code snippets to Google for product improvement

8. Common gotchas

• Index drift on huge monorepos — re-index manually (Cmd+Shift+P → Reindex Workspace) after large branch switches
• The agent loves to add tests it can pass — pin acceptance criteria in your prompt, or it'll write tautological tests to declare victory
• MCP servers using stdio sometimes hang — restart the IDE; a fix is in the Q3 roadmap
• Voice input on macOS — Antigravity captures Cmd+Shift+Space; disable in Settings if you use Spotlight on the same shortcut

9. Antigravity vs Cursor vs Claude Code — when to use which

• Antigravity: best for parallel exploration, evidence-driven review, and long-running background work. Strongest "agentic IDE" experience right now
• Cursor: best for tab completion + tight in-editor flow with quick chats. Still the most polished typing experience
• Claude Code: best for terminal-native agentic work, especially on remote machines, CI, and headless servers

For a deeper comparison see our [[ai-coding-assistant-comparison-2026|2026 coding-assistant comparison]] post.

TL;DR

• Antigravity = agentic IDE forked from VS Code, built around Agent Manager + Inspector
• Install from antigravity.google; sign in with Google; index your repo
• Start small (one tiny task), open the Inspector before accepting, learn the evidence loop
• Wire MCP servers via ~/.antigravity/mcp.json to give agents real tools
• Parallel agents on the same problem is the headline workflow — use it
• Codify project conventions in .antigravity/rules.md before scaling up

Trying Antigravity on a client project and wondering if it's the right fit? Send us a paragraph about your stack and we'll send back a candid take — including whether you'd actually be better off staying on Cursor.

Frequently asked questions