Complete Guide to Google Antigravity (2026)

Google Antigravity now has two related surfaces: an agentic IDE for direct editing and Antigravity 2.0, a standalone desktop command centre for running and monitoring agents. Google documents agents that can work across the editor, terminal, and browser, with artifacts for reviewing the result.

Rob has no documented firsthand Antigravity workflow, so this is not a personal review. It explains what Google documents and what to test in a small project before giving an agent a larger codebase.

What Antigravity Actually Is

In a traditional IDE you type code and occasionally ask an assistant for help. In Cursor you sit somewhere in the middle, with AI deeply integrated but you still driving. Antigravity pushes the dial further toward delegation: you describe what you want, and agents go build it, often several of them working in parallel across different parts of your project. You become the architect and the reviewer, the person who decides what gets built and signs off on the result, rather than the one writing every line.

Google's current documentation separates the IDE from Antigravity 2.0, its standalone desktop command centre. The product family also includes a CLI and SDK. Start by deciding whether you need an editor assistant or a place to coordinate several longer-running tasks.

Getting Started

Setup is quick and gets you to a first agent fast. Download the desktop app from Google's Antigravity site, create an account, and open it on Mac, Windows, or Linux. Point it at an existing small project rather than something brand new, so you can tell when the agents are genuinely useful and when they're filling in gaps. Give it a minute or two to index the codebase (Antigravity reads your files so the agents understand your whole project structure, including files you have closed) and then create your first agent, naming it for the job: "backend-refactor", "ui-polish", something that scopes the work. Hand it a task in plain language, something like "add a dashboard view showing recent activity." The agent proposes an approach first, and you green-light it or ask for changes before it writes anything. From there you switch to Manager View to watch progress, review the artifacts it produces, and make the high-level calls. You're reviewing plans and outcomes instead of commenting on every line, which is a genuine change in how you spend your attention.

A handful of shortcuts cover most of the first week. Because Antigravity is a VS Code fork (an app built on top of VS Code's open-source base), your muscle memory mostly survives: Cmd+P still opens files and Cmd+Shift+P is still the command palette, where typing "antigravity" surfaces the tool-specific commands. The agent-specific bindings are the ones to learn: Cmd+L toggles the Gemini agent panel, Cmd+I fires an inline AI command, and a pause shortcut stops a running agent mid-task, which I've needed more often than I expected when an agent heads somewhere I didn't intend. Inside the agent panel, @ adds context like files or MCP servers (external tools and data sources, covered below) and / reaches workflows and skills. On Windows, swap Cmd for Ctrl throughout. Most of the rest of Antigravity is mouse-driven, built around scanning the board and clicking into agents, so if you live entirely in keyboard navigation the interface can feel less satisfying than a code-first editor.

Manager View

This is the part that genuinely separates Antigravity from the editors around it. Most AI coding tools give you a single conversation thread: you ask, it answers, you iterate, one agent working through one task. Even Cursor's agent mode mostly works that way. Antigravity's Manager View is a separate interface that behaves like a dashboard for a small dev team. You can see every active agent, what each is working on, and how far along it is.

Parallel work helps only when the tasks do not overlap. A database migration and a UI polish pass may be separate; two agents rewriting the same component are not. Keep each task in a separate scope, review the artifacts and diff, then run the project's own checks. More autonomy means more output to inspect, not less responsibility.

The Models You Can Run

Google's model page listed six selectable reasoning backends on July 27, 2026: Gemini 3.6 Flash, Gemini 3.5 Flash, Gemini 3.1 Pro, Claude Sonnet 4.6 (thinking), Claude Opus 4.6 (thinking), and GPT-OSS-120B. The picker exposes Low, Medium, and High effort for the Flash models, while Gemini 3.1 Pro has Low and High variants. Switching happens in the dropdown under the conversation prompt, and the choice stays with the current turn if you change it while an agent is running.

Google's documentation currently contradicts itself on third-party access. The models page marks Claude and GPT-OSS as available on Free, AI Plus, AI Pro, and AI Ultra, while the plans page says third-party models are an AI Ultra benefit. The same plans page says Antigravity does not support bring-your-own-key or bring-your-own-endpoint for extra limits. Check the picker on your own account before paying for a plan around Claude access; the live account is more useful than pretending those two official tables agree.

The model menu is useful only when it changes a result you can review. Run the same representative task through the models available to your account, then record elapsed time, output quality, and usage. Do not pick a plan from a model name alone.

Skills and Rules

The first time I let Antigravity's agent loose on a real task, I asked it to add a loading state to a button and it restructured my entire component folder instead. It moved files, renamed things, and introduced a folder layout I never asked for. The code worked, the architecture was arguably better, and it was still nowhere near what I'd actually requested. That's the core problem with agents that have judgment but no guardrails: their preferences are reasonable, they're just not necessarily yours.

Rules are how you fix that, and Google and the community describe Antigravity's whole customization story through a framework called RAPS:

• Rules: the guardrails, your agent's operating constraints around frameworks, conventions, and the things to avoid, and this is where most of your day-to-day tuning happens.
• Armoury: MCP (Model Context Protocol) integration, which gives agents hands to reach external tools, databases, APIs, and web services beyond editing files.
• Parallel Agents: the Manager View capability I covered above.
• Serverless Running: deploying straight out of Antigravity to platforms like Modal or Vercel.

The first two are the ones you actually configure once and benefit from on every task; the last two are workflow features more than config.

Rules live in a markdown file at the root of your workspace. Antigravity looks for .antigravity/rules.md, and you can also set rules through the settings UI. A useful starter spells out your stack and a couple of hard constraints:

# Project Rules

## Framework Preferences
- Use React for UI components
- Use Tailwind CSS for styling (no CSS-in-JS)
- Use Zod for validation

## Constraints
- Do not add new dependencies without asking first
- Do not restructure existing folder organization
- Do not create abstraction layers unless explicitly requested

The headings aren't fixed; agents parse the content as context, and the more specific you are, the more consistently they follow it. A few patterns earn their keep in daily use. Framework consistency stops the worst mid-project surprises, the agent reaching for styled-components in one file and Tailwind in the next. Guardrails against over-engineering matter more than people expect, which I think of as the black coffee principle: if I ask for coffee, don't assume I want milk, sugar, and sprinkles, so "start simple" and "don't add abstractions without asking" pull real weight. File-organization rules head off the restructuring mess I described above.

Both extremes cause real problems in practice. A rule like "write good code" constrains nothing; micromanaging rules that try to script every decision leave the agent no room to operate. "Use early returns instead of nested conditionals" gives an agent something concrete to act on.

Skills are the newer layer, introduced in 2026, and they sit between rules and active workflows. The thing to understand is that skills are agent-triggered: you don't load them by hand. The agent detects what you're working on and pulls in relevant skills automatically. React skills activate in a React project, testing skills when you start writing tests. The docs call this progressive disclosure, and the point is to keep your context clean by letting skills stay dormant until they're relevant. You can browse what's available through the command palette, and there's a shared ecosystem where many skills work across Claude Code, Cursor, and other tools too. The clean way to hold the distinction: rules tell agents what to do and avoid, skills give agents specialized capability for a specific framework or task.

If you're coming from another tool, the rules concept ports over with light cleanup. Cursor uses .cursorrules, Claude Code uses CLAUDE.md, and Antigravity uses .antigravity/rules.md plus the skills system. The markdown formats are close enough that a well-written rules file works in any of them with minor adjustments, so maintaining one canonical file and adapting it per tool saves real time.

One caution is worth flagging on the Armoury side. The more MCP connections you wire up, the more your agents can reach, and that surface is genuinely powerful. Shortly after launch there was a reported persistent code-execution vulnerability involving malicious workspace rules that abused this access. I treat MCP permissions the way I treat any other credential: connect what a task needs and nothing I can't account for.

Google AI Ecosystem

Antigravity doesn't exist on its own in Google's lineup. Google has shipped a confusing pile of AI developer tools in a short span, and knowing where Antigravity sits saves you from picking the wrong one. The short version: Antigravity is the desktop, agent-first surface, and the others occupy different lanes.

Gemini Code Assist is the plugin model, dropping completions and an Agent Mode into VS Code, JetBrains, and Android Studio rather than asking you to switch editors. It's Google's enterprise-facing answer to Copilot, it has consumer and enterprise tiers, and it's the safest choice if you want Gemini inside the IDE you already use. Gemini CLI brings Gemini to the terminal with natural-language commands and MCP support, and it's the obvious fit if you live on the command line. Jules is the asynchronous one: it connects to GitHub, clones your repo into a secure Google Cloud VM, works in the background while you close the browser, and hands back a pull request when it's done, with tiered limits that scale across Google's AI plans. Firebase Studio is the cloud-IDE lane for Firebase-centric prototyping, and it has carried preview caveats, so I'd keep a backup plan before standardizing on it.

The overlap is real, and Google hasn't always explained when to choose which. My practical read: if you want Gemini in your current editor, use Gemini Code Assist; if you want background tasks delivered as PRs, use Jules; if you want to supervise several agents from a dashboard and you're curious about the agent-first workflow, that's Antigravity. All of these run Gemini underneath, which is the throughline, and it's also why Google can afford to keep several of them alive at once.

What It Costs

Antigravity's pricing is tied to Google's broader AI subscriptions instead of a standalone fee. Google's May 19 plan update set the current individual tiers below, while the live plans page explains how their quotas refresh. Check both before committing a budget because model access and capacity language have already moved since launch.

Plan	Price	Usage limit
Free	$0	Rate-limited; quota refreshes weekly
AI Pro	$20/month	Higher weekly limit; quota refreshes every five hours until the weekly cap
AI Ultra 5x	$100/month	Five times the Pro token allowance
AI Ultra 20x	$200/month	Twenty times the Pro token allowance

AI Pro and Ultra users can enable purchased AI credits after the baseline quota runs out. Google consumes those credits at Gemini Enterprise Agent Platform pricing, and the setting can wait for the next refresh or allow overages automatically. Third-party models use a separate fixed quota where available; Antigravity's plans page explicitly says there is no bring-your-own-key route for extra limits. Team and enterprise access runs through Google's Gemini Enterprise Agent Platform.

Set against Cursor at a flat $20/month for Pro, the comparison isn't apples to apples. Cursor sells you a predictable IDE subscription with a clear model of what you get each month. Antigravity folds into a Google AI plan whose limits you have to track and whose structure has shifted twice in less than a year. If your concern is a stable, knowable monthly bill, Cursor is the easier thing to reason about. If you already pay for a Google AI tier and want to extract Gemini agent work from usage you're sitting on anyway, Antigravity is close to free at the margin.

My take: the AI Pro tier at $20/month is the right starting point if you're evaluating seriously. The free tier has short enough quotas that it's more frustrating than useful for a real project, and the Ultra tiers only make sense once you've already validated that the agent-first workflow saves you meaningful time.

Limits and Fit

I like the idea and I keep it installed, which is exactly why the limits are worth saying plainly. The product churns at a pace that's hard to track: features, limits, and pricing can change between when I write this and when you read it, so anything I peg too precisely will drift. The extension ecosystem is smaller than Cursor's; VS Code compatibility is partial, and every extension you depend on needs a real test. Google's enterprise route now runs through Gemini Enterprise Agent Platform, while the individual plans still use capacity-based limits and changing model availability. For a company evaluation, I would keep an established editor available and treat Antigravity as a measured pilot until its exact integrations and controls pass your requirements.

There's also the Google factor to weigh. Antigravity is one of several AI developer products Google maintains at once, and Google has a long history of sunsetting tools, even popular ones, when interest moves elsewhere. The talent and the technology behind Antigravity are real, but whether Google commits to it for the long haul is genuinely unknown, including, I'd guess, to Google.

So the shape of my recommendation: if you're a solo developer happy in Cursor, you don't need to switch, and Antigravity probably won't feel like a compelling primary tool. If you're coordinating a larger project with several distinct work streams, or you want heavy Gemini access tied to limits instead of API spend, spend a weekend with it and see whether the agent-team model solves a problem you didn't realize you had. Just keep your rules files portable and don't build anything irreversible on top of it yet.

Compare Google Antigravity

• Cursor vs Google Antigravity: file-by-file editing against the agent-first, dashboard-driven model, and the most common comparison for developers already in Cursor

The full set of AI coding tools comparisons covers the rest of the field, and the best AI coding tools hub lists every tool we cover.

Verdict

Antigravity is worth a contained pilot when managing parallel agent tasks is the problem you need to solve. Start with one Project, a reversible task, and a review step that you already trust. Keep your existing editor when direct file work and one active task are the better fit. Compare it with Cursor vs Google Antigravity before turning it into a team standard.