The first real decision Google Antigravity asks you to make during setup isn't a theme or a keybinding. It's a question phrased like a road trip: "Who is driving the car?" You pick between agent-driven, review-driven, and agent-assisted development. That framing tells you more about where AI IDEs are heading than any benchmark chart. The tool has stopped assuming you're the one typing.
Google shipped Antigravity in public preview in November 2025, alongside its Gemini 3 Pro model, and called it "agent-first." That phrase gets thrown around loosely, so it's worth pinning down what actually changed — because it isn't the autocomplete.
The editor got demoted
Antigravity is built on a fork of Visual Studio Code, and much of it feels familiar: tab completions, inline commands, a normal editor. Google acquired the Windsurf team, and that agentic pedigree shows. But the structural move is that the editor is no longer the center of the application. There are two surfaces, and the one that matters is the new one.
The Editor View is the IDE you already know — you sit in a file and write code with AI assistance. The Manager Surface (the Agent Manager) is a dedicated interface where you "spawn, orchestrate, and observe multiple agents working asynchronously across different workspaces." Each agent gets direct access to the editor, the terminal, and the browser, and is expected to plan and execute an end-to-end task on its own, then validate its own work.
In practice, that means you can point one agent at adding dark mode to a site while another builds an unrelated feature in a separate workspace, and watch both progress from a single board. The text buffer becomes one panel among several, not the thing the whole app is organized around. That is the actual content of "agent-first": the primary object of the UI is a fleet of running tasks, not a file.
The real artifact is the plan, not the code
Here's the part I find genuinely interesting. When an agent works, Antigravity emits what it calls Artifacts: task lists, implementation plans, screenshots, and browser recordings. These aren't decoration. They're the surface you review and comment on, and you can leave comments directly on an implementation plan while the agent is still working, the way you'd comment on a pull request or a shared doc. The agent folds your notes back in as it goes.
That reframes the developer's job. If an autonomous agent can write a few hundred lines and run the app itself, the bottleneck is no longer producing code — it's deciding whether to trust what was produced. A browser recording that shows the feature actually working is a verification artifact. A step-by-step plan you approved before any code was written is a verification artifact. Antigravity is, quietly, an admission that you cannot merge what you cannot check, and that autonomy without an audit trail is just a faster way to generate work you don't understand.
The trust model is explicit, and roughly maps to a few knobs:
# Antigravity's autonomy settings, conceptually
autonomy: agent-assisted # or: agent-driven | review-driven
terminal_policy: auto # or: agent-decides (agent asks when unsure)
# The receipts an agent leaves behind for you to check:
artifacts:
- implementation_plan # you approve the plan before code lands
- browser_recording # the agent proves the UI actually runs
- screenshots
- task_list
You also get a knowledge base: agents can save useful context and code snippets to reuse on later tasks, so the setup you explained once doesn't have to be re-explained every session.
Model optionality is part of the pitch
Notably, Antigravity isn't locked to Google's own model. Gemini 3 Pro is the default and gets the most generous rate limits, but the platform also supports Anthropic's Claude Sonnet 4.5 and OpenAI's GPT-OSS. For a first-party tool, offering a competitor's model as a first-class option is a deliberate signal: the differentiator is meant to be the orchestration layer — the manager, the artifacts, the browser control — not the model behind it. It's free for individuals during the preview, on macOS, Windows, and Linux.
Where the shine comes off
I'd temper the enthusiasm with what early hands-on reports have hit. The preview shows latency and occasional unresponsiveness after heavy use, and the generous rate limits are still limits you'll run into if you keep several agents busy. Those are preview problems and will probably soften.
The structural concern is more durable. Running four agents in parallel sounds like a four-times speedup right up until you remember that a human still has to review four implementation plans, four diffs, and four browser recordings. Parallel generation doesn't parallelize your attention. The failure mode of an agent-first IDE isn't the agent writing bad code — it's the agent writing plausible code faster than you can honestly verify it, and the artifacts becoming a checkbox you click through instead of a thing you read.
The tools that win here won't be the ones that generate the most autonomously. They'll be the ones that make verification cheap enough that trusting an agent is a decision you can actually afford to make.
What to actually watch
If you're evaluating one of these tools, ignore the autocomplete demo — every IDE has good autocomplete now. Judge it on the manager and the artifacts. Can you review an agent's plan before it acts? Does it prove its work ran, or just tell you it did? How fast can you say "no, do it this way" and have that stick? Those are the load-bearing features of an agent-first IDE. The editor is now the part you fall back to when the agent gets it wrong — and how gracefully it lets you do that is the real test.
Sources: Google Antigravity · Build with Google Antigravity (Google Developers Blog) · A developer's guide to Antigravity and Gemini 3 (LogRocket)