The last few years of AI-assisted development have followed a predictable arc: autocomplete gets smarter, context windows grow, the chat panel gets better at reading your whole repo. The mental model, though, barely changed. You still drive. The AI is a very fast copilot who never gets tired.
Google Antigravity is a bet that this model has a ceiling — and that the next meaningful step is handing the wheel over entirely for well-scoped tasks.
Whether that bet pays off is a genuinely open question. But it is worth understanding what Google is actually shipping, and how it compares to the tools most developers already use.
What Google Antigravity Actually Is
Antigravity launched in November 2025, alongside Gemini 3, as Google's answer to the question: what does an IDE look like if you design it around autonomous agents from the start, rather than bolting them on?
The short answer is that it looks less like an editor and more like a task orchestration layer that happens to include an editor.
The platform ships with two distinct surfaces:
Editor View is the familiar territory — a full IDE with tab completions, inline commands, and an agent available in a side panel. If you've used Cursor or GitHub Copilot in VS Code, the cognitive overhead is low.
Manager Surface is the novel part. It's a dedicated interface for spawning multiple agents and letting them run asynchronously across different workspaces. You can have one agent implementing a feature while another reproduces and patches a bug — neither blocking the other, neither blocking you.
The practical implication: you describe a goal in natural language, the agent plans the execution steps, writes code, runs terminal commands, and opens a browser to verify the result. It returns Artifacts — screenshots, task logs, session recordings — so you can review what happened rather than watch it happen in real time.
At Google I/O on May 19, 2026, Google shipped Antigravity 2.0, adding:
- Browser Subagent: a real Chromium instance that the agent controls to navigate, click, and test your app while it's being built
- A new CLI written in Go (lighter, faster, replaces the older Gemini CLI)
- An SDK for defining custom agent behaviors and hosting them on your own infrastructure
- Managed Agents on the Gemini API, for teams that want to run agent workflows without managing infrastructure
The default model is Gemini 3.5 Flash (updated from Gemini 3 at launch — faster, Google says it outperforms Gemini 3.1 Pro on most benchmarks). The platform also supports Claude (Anthropic, including Sonnet and Opus tiers) and GPT-OSS (OpenAI open-source models). That multi-model flexibility is a deliberate positioning choice: Antigravity presents itself as a platform, not a locked-in Google product.
How It Compares to Cursor, VS Code, and Claude Code
Before the table, a framing note: these tools are not really competing for the same job. Antigravity is optimized for task delegation. Cursor and VS Code with Copilot are optimized for assisted writing. Claude Code sits somewhere between the two — terminal-first, agent-capable, but without the GUI orchestration layer.
| Google Antigravity | Cursor | VS Code + Copilot | Claude Code | |
|---|---|---|---|---|
| Mental model | Delegate tasks to agents | AI-assisted writing | AI-assisted writing | Agent in your terminal |
| Terminal/browser execution | Native — runs commands, tests in browser | Limited (suggestions only) | Via extensions | Native terminal control |
| Parallel agents | Yes (Manager Surface) | No | No | No (single session) |
| Model choice | Gemini (default), Claude, GPT-OSS | Configurable | GitHub models via Copilot | Claude only |
| Free tier | Yes — all models, rate-limited | Yes — limited completions | Copilot: paid (~$10/mo) | CLI: free, API costs apply |
| Review/audit trail | Artifacts (screenshots, logs, recordings) | Minimal | Minimal | Terminal output |
| Maturity | Public preview (Nov 2025) | Mature, production-grade | Mature, large ecosystem | Mature, CLI-focused |
| Best for | Greenfield, prototyping, parallel work | Daily production work | Teams on VS Code | Terminal-heavy, API-centric |
The honest summary: if you are shipping production code in a monorepo where every diff matters, Cursor or VS Code still makes more sense. The agent trust model in Antigravity requires a review step — if you are not checking Artifacts carefully, you are accumulating unreviewed changes. That is a workflow discipline problem, not just a tool problem.
What Works — and What to Watch
The case for trying it
Multi-agent parallelism is genuinely new. Nothing in the Cursor/VS Code ecosystem lets you orchestrate several agents on separate workspaces from a single interface. For teams running multiple features in parallel or doing background maintenance (dependency updates, documentation generation, audit passes), the Manager Surface addresses a real coordination overhead.
The Browser Subagent changes the feedback loop for frontend work. Instead of manually spinning up a dev server and clicking through a UI to verify changes, the agent does it. Artifacts bring the evidence back to you. This compresses a tedious part of the iteration cycle.
Multi-model support reduces lock-in anxiety. Being able to swap to Claude Sonnet or GPT-OSS without leaving the environment is not a headline feature, but it matters for teams with model preference policies or cost constraints.
The free tier is a real entry point. At the time of writing, individual developers can access all supported models (including Gemini 3.5 Flash) at no cost, subject to rate limits that refresh periodically. Paid tiers start at around US$20/month (AI Pro). Google has adjusted limits and plan names several times since launch, so treat exact numbers as directional — check antigravity.google/pricing for current figures.
The caveats
It is still in public preview. Antigravity has been available since November 2025, but "preview" here means the API surface, pricing, and rate limits have all shifted since launch. Teams building internal tooling on the SDK should plan for breaking changes.
Autonomous agents create a review burden. The platform's value proposition — agents that execute end-to-end without constant supervision — is also its risk. Unreviewed agent output in a production codebase is a liability. You need to build the habit of auditing Artifacts before merging, especially for tasks that touch data models or external APIs.
The Browser Subagent is still early. Real-browser testing via an agent-controlled Chromium is a compelling idea, but reliability on complex UI interactions (third-party embeds, OAuth flows, WebGL) is not yet comparable to a mature testing framework like Playwright or Cypress. Use it for rapid iteration, not as a replacement for your test suite.
Gemini 3.5 Flash as the default is a trade-off. Flash is fast and cheap, which is why it is the default. For nuanced reasoning tasks — architecture decisions, complex refactors — you may want to explicitly route to a heavier model. That model-routing discipline is not automatic.
Should You Try It?
Yes, with limited scope. The fastest way to form an honest opinion about Antigravity is to use the Manager Surface for one greenfield task — a new API endpoint, a standalone script, a UI component — and audit the Artifacts carefully. That reveals both the ceiling (what it gets right autonomously) and the floor (where you still need to intervene).
If your team already has a productive Cursor workflow for production code, Antigravity does not replace that today. It is additive: the Manager Surface handles the parallel, lower-stakes workloads that would otherwise require context-switching or back-of-queue scheduling.
For developers evaluating the agentic coding space broadly, Antigravity is the clearest expression of what "agent-first IDE" means in practice in mid-2026. Whether that is where the industry lands long-term is still an open bet — but it is a bet worth understanding firsthand.
Originally published in Portuguese — with a full setup walkthrough and pricing details — on our blog at neuroniosartificiais.com.br.
