How to use Google Antigravity, the new agent-first coding IDE powered by Gemini 3

Most AI coding tools still ask you to babysit them. You type a prompt, you get a code block, you copy it, you paste it, you run it, you report back the error, you repeat. Google just shipped something that skips most of that loop entirely — an IDE where the agent plans the work, opens a terminal, writes the code, spins up a browser to test what it built, and only comes back to you when it actually needs a decision.

That's Google Antigravity, and if you've been coding with Gemini, Claude, or GPT models bolted onto your editor, this is a genuinely different way of working.

What is Google Antigravity?

Google Antigravity is Google's new agentic development platform, built around Gemini 3 and designed so AI agents can operate across your editor, terminal, and browser instead of being confined to a chat sidebar. Using Gemini 3's advanced reasoning, tool use and agentic coding capabilities, Google Antigravity transforms AI assistance from a tool in a developer's toolkit into an active partner, and while the core of Google Antigravity is a familiar AI IDE experience, its agents have been elevated to a dedicated surface and given direct access to the editor, terminal and browser.

The official product site is antigravity.google, and Google's documentation hub covers everything from installation to agent rules and Artifacts in detail.

What makes it different from something like GitHub Copilot or a typical AI chat panel is the level of autonomy. Google says that Antigravity, which supports multiple agents and gives them direct access to the editor, terminal, and browser, is designed for an "agent-first future." Instead of suggesting a line of code as you type, or handing you a snippet to manually paste, the agent in Antigravity goes off, plans a sequence of steps, executes them, checks its own work, and reports back with evidence.

It's also not locked to a single model. The platform supports Gemini 3, Claude Sonnet, and GPT-OSS models natively, offering more flexible AI assistance than single-model IDEs like Cursor. So you can let Gemini 3 drive most of the agentic work while still calling on Claude for a specific task if you prefer its style of reasoning.

How do you install and set up Google Antigravity?

Head to the Antigravity download page — this is the primary place to grab the app, and it's also where you'll find the CLI installer and IDE extensions if you'd rather stay inside VS Code or JetBrains.

Here's the setup flow based on Google's own Getting Started documentation:

1. Pick your platform. Visit antigravity.google/download to download Google Antigravity 2.0, and select your operating system from the download table. It supports macOS (Monterey or later, Apple Silicon or Intel), Windows 10+, and Linux distributions with a modern glibc.
2. Choose desktop client vs. standalone IDE vs. extension. Google ships it as several separate downloads — a free agent-first development platform that ships as five separate downloads: desktop client, standalone IDE, IDE extensions for VS Code and JetBrains, a CLI, and a Python SDK, all available from antigravity.google/download. If you're not sure which to pick, the standalone desktop client is the simplest starting point.
3. Run the installer and sign in. Run the installer, log in with the same Google Account, and go ahead with the installation — going with defaults for every step ranging from IDE, Default Actions, Plugins, and more.
4. Set up project-level rules (optional but useful). You can store global preferences in a Markdown file so every agent session respects your conventions. Rules and workflows govern how Antigravity behaves, with global rules stored at ~/.gemini/GEMINI.md useful for setting preferences for specific languages, documentation standards, or ethical guidelines like never generating hardcoded API keys. Workspace rules are specific to the current project and can override or supplement those global rules.

It's currently free to use. Antigravity became available for free in public preview for Mac, Windows and Linux as of November 18th, 2025, with what Google calls "generous rate limits" for Gemini 3 Pro usage.

What are the three core surfaces in Antigravity?

This is the part that actually changes how you work. Antigravity isn't just an editor with a chat window bolted on — it's built around three connected surfaces.

How does the Editor surface work?

The Editor is the familiar part. Google Antigravity's Editor view offers tab autocompletion, natural language code commands, and a configurable, context-aware agent. If you've used any AI-assisted code editor before, this will feel immediately familiar — you can still type code manually, accept inline suggestions, and ask for quick edits in natural language.

What does the Agent Manager actually do?

This is the surface that sets Antigravity apart. Rather than embedding agents within existing surfaces, Antigravity introduces an agent-first Manager surface that flips the paradigm — instead of agents being embedded within surfaces, the surfaces are embedded into the agent. Practically, that means you can hand off a task, close the laptop lid, and come back to a plan, a set of diffs, and test results waiting for your review.

Google frames this as a deliberate shift. Unlike traditional IDEs focused on synchronous editing, it enables AI agents to run tasks in the background, like debugging or testing, without blocking user input. You can run multiple agents on multiple tasks simultaneously — one fixing a bug, another scaffolding a new feature — and check in on each independently.

Why does Antigravity include a Browser surface?

The third surface is a real, controllable browser the agent can use to test what it builds. This matters most for front-end work, scraping, or anything that needs visual verification rather than just a passing test suite. When this capability is active, the agent can navigate pages, click through flows, and record what it sees so it can debug issues it couldn't catch from code alone — which is a meaningfully different approach from text-only agents that have to guess whether a UI actually renders correctly.

How do you give the agent a task and review its plan?

The workflow generally goes: write a task description, let the agent draft a plan, review that plan (or let it proceed), and then check the resulting Artifact once the work is done.

A few things make a real difference in the quality of what comes back:

• Be specific about location and scope. Mentioning the exact file or folder you want touched — for example, pointing the agent at your data/ folder — gives it the context to understand precisely what you're trying to achieve instead of guessing at your project structure.
• Name your stack explicitly. If you want Tailwind CSS or SQLite used, say so. Calling out specific tools up front means the agent builds with the stack you actually want instead of defaulting to whatever it thinks is standard.
• Pick the right autonomy level for the task. Antigravity lets you control how much it checks in. You can set it to always proceed if you're comfortable letting it run freely and just want to see what it comes up with, or set it to request review before each change if you want a checkpoint before anything gets written — which is the safer default when you're working in a real codebase you care about.

How do Artifacts work for reviewing changes?

Artifacts are Antigravity's answer to "trust but verify." Instead of just trusting that the agent did what it said, every completed task produces a reviewable Artifact — a way for you to provide feedback across every surface and Artifact to steer the agent toward your desired outcomes. That typically includes the plan the agent followed, the diffs it produced, and rich, visual feedback and artifact review right in your editor — including screenshots or recordings from browser testing when relevant.

This is the piece that makes autonomous agent work feel less like a leap of faith. You're not just reading a changelog; you're seeing evidence that the agent actually ran the thing and it worked, with a trail you can audit before you merge.

How does Google Antigravity compare to Cursor and Claude Code?

If you're already using Cursor or Claude Code, here's the honest comparison.

Cursor is still primarily an editor-first experience — phenomenal inline completion and chat-driven editing, with agent mode layered on top. Antigravity flips that priority, putting the Agent Manager on equal footing with the editor rather than treating it as an add-on. Model-wise, Cursor supports multiple providers too, but Antigravity natively supports Gemini 3, Claude Sonnet, and GPT-OSS models, offering more flexible AI assistance than single-model IDEs.

Claude Code is terminal-native and excellent at long, autonomous coding sessions, but it doesn't give you a built-in visual browser surface or a dedicated Artifact review system out of the box — you're largely reading terminal output and diffs. Antigravity's browser control and recorded sessions are specifically built for cases where you need visual confirmation, not just a green test suite.

None of this makes one tool strictly better — they solve overlapping but distinct problems. Antigravity's pitch is orchestration across three surfaces at once; Cursor's pitch is editor speed and polish; Claude Code's pitch is terminal-native autonomy. If you're doing a lot of front-end or browser-testing work, Antigravity's browser surface is a genuine differentiator worth trying.

Where should you start?

Download it from antigravity.google/download, point it at a small side project first, and give the agent a task with real constraints — a specific folder, a named stack, a request-review setting instead of full autonomy. Watch what it plans before it touches anything. That one habit, reviewing the plan before the code, is the difference between an agent that saves you hours and one that quietly rewrites half your app while you weren't looking.