Google Antigravity Is Free, Multi-Agent, and Gunning for Cursor's Throne

Google just gave every developer a free agentic IDE that can run multiple AI agents simultaneously across your editor, terminal, and browser — and it's already beating Cursor on benchmarks. Antigravity, announced alongside Gemini 3 in November 2025 and now in public preview, isn't another autocomplete wrapper on VS Code. It's a fundamentally different development model where you manage AI agents like a team lead manages engineers.

The numbers tell the story. On Terminal-Bench 2.0, Antigravity scores 54.2% — seven points ahead of GPT-5.1. It scaffolds a Next.js + Supabase app in 42 seconds versus Cursor's 68. And it navigates large codebases 40% faster than Cursor 2.0. All of this, currently, at zero cost.

Google Antigravity: What Makes It Different

Every AI coding tool claims to be "agentic." Antigravity actually ships it. The platform has two distinct interfaces that represent two ways of working with AI.

The Editor View looks familiar — it's essentially a modified VS Code fork with AI-powered tab completions and inline commands. If you use Cursor today, you'll feel at home. This is where you write code alongside an AI copilot in the traditional sense.

The Manager Surface is where things get interesting. Think of it as mission control for AI agents. You spawn multiple agents, each working on different tasks across separate workspaces — one refactoring your auth module, another writing tests for your API, a third debugging a CSS layout issue in the browser. Each agent runs asynchronously, producing "Artifacts" (implementation plans, screenshots, browser recordings, annotated diffs) that you review like pull requests.

This isn't theoretical. You can dispatch a background agent to run a migration, switch to the editor for manual work, and come back to find the agent finished with a full implementation plan and verification screenshots. The agents operate across editor, terminal, and browser simultaneously — they can spin up dev servers, run end-to-end tests, spot UI issues in the browser, and fix them without asking permission at every step.

Antigravity Benchmarks vs Cursor and Claude Code

Here's where the data gets uncomfortable for Cursor fans:

SWE-bench Verified: Antigravity scores 76.2%, just 1 point behind Claude Sonnet 4.5's standalone score. For context, this is the gold-standard benchmark for automated software engineering — solving real GitHub issues from popular open-source projects.

Terminal-Bench 2.0: 54.2% versus GPT-5.1's 47.6%. This benchmark measures the ability to complete complex terminal-based development tasks, and Antigravity's 6.6-point lead is significant.

Feature completion speed: A Next.js + Supabase scaffolding task takes 42 seconds on Antigravity versus 68 seconds on Cursor — a 38% speed advantage.

Refactoring accuracy: 94% versus Cursor's 78%. When rewriting code across multiple files, Antigravity preserves intent and correctness more reliably.

The important caveat: these benchmarks measure the platform's default model (Gemini 3 Pro) in agentic mode. Cursor users who configure Claude Opus or GPT-5 may see different results on reasoning-heavy tasks. But out of the box, Antigravity wins on speed and agentic execution.

How Antigravity Gets Multi-Model Right

One of Antigravity's strongest design choices: you're not locked into Gemini. The platform supports three model families out of the box:

• Gemini 3.1 Pro — 1 million token context window, multimodal processing, Deep Think reasoning mode. This is the default and what powers most of the benchmark results.
• Claude Sonnet 4.5 — Anthropic's flagship coding model, known for strong instruction following and nuanced reasoning.
• GPT-OSS 120B — OpenAI's open-weight model, useful for specific tasks and local deployment scenarios.

You can switch models mid-session and even assign different models to different agents. Your refactoring agent might use Gemini 3 Pro for its massive context window while your code review agent uses Claude Sonnet for its stronger reasoning. This per-task model selection is something neither Cursor nor Windsurf handles as cleanly.

The Windsurf Acquisition Story

Antigravity didn't appear from nowhere. In July 2025, Google acquired Windsurf's leadership team — roughly 40 engineers — for $2.4 billion. That's not a typo. Google paid billions for the talent behind one of the most promising AI IDE startups, then shipped Antigravity four months later.

The Windsurf DNA shows. Antigravity's architecture borrows heavily from Windsurf's agent-first philosophy, but combines it with Google's infrastructure advantages: Gemini 3 Pro's million-token context window, Google's compute resources for running multiple agents in parallel, and deep integration with Google Cloud services.

For Windsurf users who felt abandoned after the acquisition, Antigravity is essentially Windsurf 2.0 — rebuilt from scratch with Google's resources behind it.

Google Antigravity Development Modes

The platform offers four configurable autonomy levels, which is a smart approach to the trust problem that plagues AI coding tools:

Agent-Driven: Full autonomy. Point the agent at a task and walk away. Best for scaffolding, boilerplate, and well-defined tasks where the cost of a mistake is low.

Agent-Assisted (recommended): Agents work autonomously but pause at verification checkpoints. You provide tactical guidance at decision points. This is the sweet spot for most development work.

Review-Driven: Strict human approval for every meaningful step. Useful for production-critical code where you can't afford agent mistakes.

Custom: Mix modes per task based on risk levels. Your test-writing agent runs in Agent-Driven mode while your database migration agent requires Review-Driven approval.

The Knowledge Base: Agents That Learn Your Style

Antigravity treats learning as a core feature. Agents maintain a persistent knowledge base that tracks your preferred code patterns, naming conventions, file structures, and technical decisions. After a few sessions, agents start anticipating your style without explicit instruction.

This is different from Cursor's rules files or Claude Code's CLAUDE.md approach. Instead of you writing explicit instructions, the agents observe and adapt. In practice, this means less time correcting AI-generated code to match your team's conventions.

What's Still Broken

Antigravity is impressive, but it's a public preview for a reason. Developers have reported several pain points:

Cloud-only processing: All code gets sent to Google's servers. Organizations with strict data residency requirements or air-gapped environments can't use it. This is the single biggest blocker for enterprise adoption.

Stability issues: Reports of file corruption and infinite loop bugs during complex multi-agent workflows. These are preview-level issues that Google will likely fix, but they make Antigravity risky for production codebases today.

Legacy codebase struggles: Agents stumble on custom homegrown patterns that weren't in their training data. If your codebase has unusual conventions or proprietary frameworks, expect more agent corrections.

Unannounced pricing: Free during preview is great, but Google hasn't revealed what it'll cost when it goes GA (expected mid-2026). Given the compute costs of running multiple Gemini 3 Pro agents in parallel, the pricing could be substantial.

Who Should Use Antigravity Right Now

The emerging consensus among developers who've tried all three major options: use the right tool for the right job.

Antigravity excels at greenfield projects, large-scale scaffolding, and architectural migrations where its multi-agent orchestration delivers dramatic speed improvements. If you're starting a new project from scratch, it's the fastest path from idea to running code.

Cursor remains the best choice for daily "in-the-trenches" coding — familiar VS Code workflows, surgical edits, and a mature extension ecosystem. It's local-first, which matters for data-sensitive work.

Claude Code dominates for deep codebase reasoning, complex debugging, and architectural review. Its terminal-first approach and strong instruction following make it the most reliable option for production-critical work. Tools like Aider and frameworks like CrewAI complement Claude's capabilities for specific workflows.

The smartest developers in 2026 aren't picking one — they're using a hybrid stack. Antigravity for scaffolding, Cursor for daily work, Claude Code for the hard problems.