Building Agentic Workflows With Google Antigravity
Google Antigravity is an agent-first IDE, a fork of VS Code that Google shipped on November 18, 2025 alongside Gemini 3. Instead of autocompleting your next line, it lets you hand an autonomous agent a goal and watch it plan, write, run, and verify the work across your editor, terminal, and browser. This guide walks you through setting up Antigravity, dispatching your first agent from Mission Control, picking a model, and wiring in the guardrails you need before you trust an agent with shell access. Antigravity is free during its public preview, so the only cost of following along is your time.
What Antigravity Actually Is
If you have used Copilot or a chat sidebar, the mental model is wrong here. Antigravity is not a smarter autocomplete. It is a fork of VS Code rebuilt around the idea that an agent should have its own workspace and the authority to act in it. You describe a goal at the level you would give a junior engineer, and the agent breaks it into subtasks, writes the code, runs the tests, and checks its own output before handing it back.
Google calls this an "agent-first" experience. In practice your role shifts from typing every function to reviewing what an agent produced and deciding whether to accept it. That shift is the whole point, and it is also where the risk lives, which is why a chunk of this guide is about guardrails rather than features.
One thing to be clear about up front: Antigravity is a public preview. The feature set, usage limits, and pricing model are all still moving. Everything below was verified against vendor and independent documentation on June 9, 2026, but expect details to change between now and general availability.
The agent works across three surfaces at once: your editor (to read and write files), your terminal (to install dependencies and run builds), and a browser (to open Chrome and verify that the UI it just built actually works). That browser loop is the part that genuinely separates it from older assistants. The agent does not just claim the code compiles. It opens the page, clicks through it, and brings back screenshots as evidence.
Prerequisites
Nothing here is exotic. The one item people skip is the isolated workspace, and that is exactly the one you should not skip given how much access these agents get.
-
RequiredA supported OSmacOS, Windows, or a supported Linux distribution. Download page
-
RequiredA personal Google accountUsed for authentication during the preview.
-
Required8GB RAM (16GB recommended)Agents running tests and a browser at once are not light.
-
RequiredAn isolated workspaceA throwaway repo in a container or VM. Not the folder holding your only copy of anything.
-
RecommendedChrome for browser verificationBrowser subagents drive Chrome through a required extension.
-
RecommendedVersion control with frequent commitsA real undo path. Commit before you let an agent run.
Build Your First Agentic Workflow
Here is the end-to-end path from a fresh install to a verified agent run. Check each step off as you go. The progress bar persists in your browser, so you can close the tab and come back.
-
1
Install and sign inDownload the preview build from antigravity.google, install it, and sign in with your personal Google account. Verify: the app opens to an empty workspace with both Editor and Manager views available.
-
2
Open a sandbox projectOpen a disposable repo, ideally inside a container or VM. Verify: git status is clean and you have a commit to roll back to before any agent runs.
-
3
Pick your modelFrom the model selector, choose Gemini 3 Pro for default work, or switch to Claude Sonnet 4.5, Opus 4.5, or an OpenAI open-source variant. Verify: the selected model name shows in the agent panel.
-
4
Dispatch an agent from Mission ControlIn Manager View, write a goal in plain language, for example "add a /health endpoint with a passing unit test." Dispatch it. Verify: the agent produces a Task List breaking the goal into steps.
-
5
Review the Artifacts, not the logsRead the agent's Implementation Plan and Walkthrough rather than scrolling raw tool-call output. Verify: the Task List shows every item complete and the test it wrote actually passes.
-
6
Save the workflow as a reusable ruleCapture the pattern (for example a generate-unit-tests workflow) so the next agent run follows the same conventions. Verify: re-running the rule on a different file produces consistent structure.
Do not skip step 2. An agent with terminal access in your home directory is a much bigger blast radius than one in a container. The setup is the safety control.
Editor View vs Mission Control
Antigravity splits into two views, and knowing when to use which is most of the workflow. Editor View is for the work you want your hands on. Manager View is for work you want to delegate and supervise in parallel.
- You want hands-on control of a specific file
- You need inline commands and tab completion
- You are taking over a task an agent started
- The change has a judgment call you do not want to delegate
- You want to dispatch several agents at once
- You are running parallel tasks across a codebase
- You want to monitor progress from one dashboard
- You are reviewing Artifacts before accepting work
The honest framing is that this feels less like a new way to code and more like a workflow upgrade. You keep your editing habits, but you gain a real surface for handing off and reviewing delegated work. Most practitioners settle into a rhythm of dispatching a couple of agents in Mission Control, then dropping into Editor View whenever an agent hits something that needs a human decision.
What the Agents Can Do
These are the capabilities that change how you actually work. The first three are why delegation is possible at all. The fourth, Artifacts, is what makes delegation reviewable instead of a leap of faith.
The term Google uses for the front end of this is "vibe coding," which is just shorthand for describing intent at a high level ("build a dashboard that responds smoothly") rather than spelling out every function signature. It works well for greenfield UI and scaffolding. It works less well when the requirement is precise and unforgiving, which is where you still want Editor View and a tight prompt.
Choosing a Model
Antigravity is optimized for Gemini 3 Pro, but it is model-flexible. You can switch the underlying model per agent, which matters more than it sounds: different models behave differently on long agentic chains, and being able to swap one in without leaving the IDE is a real advantage.
- RoleDefault agent
- API preview (in)$2.00 / 1M
- API preview (out)$12.00 / 1M
- RoleAlt model
- ProviderAnthropic
- RoleAlt model
- ProviderAnthropic
- RoleAlt model
- ProviderOpenAI (open)
On the API price tags above: the $2 / $12 figures are the Gemini 3 Pro API preview list price per 1M tokens. They are not what you pay inside Antigravity, which is free during the preview. They are here so you can reason about cost if you later move the same workload to the raw Gemini API.
Practical default: start every project on Gemini 3 Pro because that is what the IDE is tuned around. Reach for Claude Opus 4.5 only when an agent keeps losing the thread on a complex, multi-file change, and benchmark before you commit. Switching models is cheap; rewriting a confused agent's output is not.
Guardrails Before You Trust It
This is the section most tutorials skip and the one that will save you. An agent with terminal access is exactly as dangerous as a script you did not read. One reported incident had an Antigravity agent, running in a high-autonomy mode, wipe an entire drive after being asked to clear a project cache, then apologize. Treat early agent autonomy the way you would treat handing root to your most junior hire.
Set these before your second agent run, not after your first incident:
- Start conservative on terminal autonomy. Avoid unattended "turbo" command chaining until you trust the agent on this codebase. Prefer modes that require review for risky operations.
- Use least privilege and isolation. Run the agent against a repo inside a dedicated workspace, ideally a container or VM, never on a drive holding irreplaceable data and never with elevated permissions.
- Make destructive commands opt-in. Block or require manual approval for recursive deletes, disk utilities, and anything targeting root paths.
- Lock down browser access. If you let agents browse, use URL allowlists and a secure mode to reduce accidental data exposure and prompt-injection-style attacks.
- Assume secrets are reachable. Broad autonomy plus terminal access can reach sensitive files. Fence off credentials and never run an agent in an environment where exfiltration would matter.
- Keep undo real. Commit early and often, and keep snapshots for any environment where an agent can mutate the filesystem.
None of this is hypothetical caution. It is the direct consequence of giving software the ability to act, and it is the price of the productivity. If you are deploying agentic tooling across a team, our pre-deployment safety checklist and the broader AI governance practices are worth a pass before you scale this beyond one developer.
Pricing and Usage Limits
Antigravity is free for individual developers during the public preview. That is the headline and it is true today. What is changing is how usage gets metered once you push past casual use.
| Plan | Price | What it means for Antigravity |
|---|---|---|
| Public Preview | Free | Full access for individual developers during the preview period. |
| Google AI Pro | $19.99/mo | Higher usage limits and priority access to new agentic features. |
| Google AI Ultra | $100/mo | 5x the usage limit of the Pro plan in Antigravity and the Gemini app. |
| Google AI Ultra | $200/mo | 20x the usage limit of the Pro plan (reduced from the earlier $250 price). |
Two things to understand about how limits work. First, Google is moving from daily prompt caps to a "compute-used" model: a complex coding or video prompt consumes more than a simple text prompt, and your limit refreshes every five hours up to a weekly cap. Second, if you hit your cap on the biggest models, you get shifted to faster smaller models rather than cut off. Pro and Ultra subscribers can also buy pay-as-you-go top-up credits specifically for Antigravity to keep using their chosen model.
Pricing is not final. The per-credit cost of Antigravity top-ups and the exact post-preview pricing have not been fully announced. Anything you read about specific Antigravity credit prices, including here, should be re-checked against Google's plans page before you budget around it.
Limitations and Honest Caveats
- It is a public preview. Features, model availability, and pricing will move. Do not build a team's core workflow on preview behavior you cannot pin.
- Not built for enterprise teams yet. Antigravity is optimized for the individual developer. Team collaboration features, organizational controls, and centralized enterprise security are slated for future updates, not shipped today.
- Autonomy is a real risk surface. Deep terminal and filesystem access means a misfiring agent can do real damage. The guardrails section is not optional reading.
- Agents still produce plausible-wrong work. The Artifacts make review faster, but they do not make the underlying model infallible. You still own the verification.
- Language coverage is broad but not the point. It supports the major languages (Python, JavaScript, TypeScript, Java, C++, C#, Go, Rust, and more); the constraint is autonomy maturity, not syntax support.
Troubleshooting
Cause: The required Chrome extension is not installed or not granted permission, so browser subagents cannot drive the page.
Fix: Install the Antigravity Chrome extension and confirm it has permission to control the browser, then re-run the verification step. Check the official docs for the current extension setup.
Cause: The agent is in a high-autonomy or unattended mode that chains commands without review.
Fix: Drop terminal autonomy back to a review-required mode, require manual approval for destructive operations, and run only inside an isolated workspace. Use your version control snapshot to roll back any damage.
Cause: Compute-used limits refresh every five hours up to a weekly cap. A heavy coding session can exhaust the window.
Fix: You are shifted to faster smaller models automatically, or you can buy pay-as-you-go top-up credits (AI Pro and Ultra), or wait for the five-hour refresh. Higher Ultra tiers raise the cap.
Cause: The goal was too abstract, or the model is losing context on a long multi-file change.
Fix: Watch the Task List for scope drift early and correct it there. Tighten the goal, break it into smaller dispatches, or switch to a stronger reasoning model like Claude Opus 4.5 for that task.
Cause: Antigravity is currently built for individual developers, not teams.
Fix: There is no full team workflow yet. Organizational controls, shared collaboration, and enterprise security are planned for future updates. For now, standardize via reusable rules each developer imports, and govern usage with your own policy.
Where to Go From Here
Once your first agent run is verified and your guardrails are set, the next move is to build a small library of reusable rules for the patterns you repeat: test generation, endpoint scaffolding, dependency upgrades. That is what turns Antigravity from a novelty into something that compounds. If you want the engine underneath, the same Gemini models are available directly through the API, which is where you go when you need agentic behavior outside the IDE.
Google, Gemini, Google Antigravity, Google AI Studio, and Vertex AI are trademarks of Google LLC. Claude is a trademark of Anthropic. This article is not affiliated with, sponsored by, or endorsed by Google LLC.