Google Antigravity Guide: Setup, Rules and Automated Testing With Playwright
Google Antigravity is an agent-first IDE built around Gemini 3 Pro. This guide covers setting it up, building larger multi-file apps with it, how its rules compare to AGENTS.md, and how to let the agent verify its own work in a real browser with Playwright.
Google Antigravity is an agent-first development platform where autonomous agents, rather than the text editor, sit at the center of how you work. This guide explains what Antigravity is, how it compares to Cursor and plain VS Code, and then walks you through setting it up with Gemini 3 Pro, from installation to your first agentic task and the guardrails that keep autonomy safe.
Table of Contents
What Google Antigravity is
Antigravity is Google’s agentic development platform, launched in late 2025 alongside Gemini 3. As described on its official site, it combines an IDE, a command-line interface and a software development kit for orchestrating autonomous agents. Rather than being an editor with AI bolted on, it is designed from the start around agents that generate, run and test code. The agents are the product, and the editor supports them.
Built on a familiar VS Code foundation
Despite the fresh concept, Antigravity is built on familiar bones. As its overview notes, it is an agent-first IDE built on VS Code, so the underlying editing experience will feel recognizable to anyone who has used that editor. You get a new agent-centric layer over a known foundation, which lowers the learning curve.
Antigravity vs VS Code
Plain VS Code is a general editor that becomes AI-capable through extensions like Copilot or Codex, so the AI is an optional add-on you choose. Antigravity inverts that, making agents the core experience. VS Code is an editor you can add AI to, while Antigravity is an agent platform that happens to include an editor. The two sit at different points on the spectrum of AI coding surfaces.
Antigravity vs Cursor
Cursor is closer, since it too is an AI-native editor built on VS Code, but the emphasis differs. Cursor keeps a strong editor-centric feel with a powerful agent mode, while Antigravity pushes further toward the agent being the primary interface, with an agent manager coordinating the work. Both are AI-first, but Antigravity leans harder into orchestration and autonomy, so the comparison is a matter of degree in the same direction, much like weighing different agentic tools: Cursor centers the editor with agents, Antigravity centers the agents with an editor.
Features that set Antigravity apart
The agent manager
The heart of Antigravity is directing agents rather than typing code, and the agent manager is where you assign tasks to autonomous agents that plan, write, run and test, so your role shifts toward orchestrating and reviewing rather than authoring line by line. It puts coding agents front and center, and working in it feels more like running a team of agents than editing a file.
Model choice beyond Gemini
Although Google built it around Gemini 3, Antigravity is not locked to a single model. It offers model choice, including Gemini 3 Pro and support for other frontier models from other labs, so you can match the model to the task, compare results or follow the current best without a Google-only lock-in. Being open on models is a notable and welcome design choice.
Built-in testing and verification
Because agents can run and test the code they write, the platform builds checking into the workflow rather than leaving verification entirely to you. This reflects the idea that autonomy is only safe when paired with verification. An agent that tests its own output is more trustworthy than one that only writes. Baking checking into the flow is a sign of a serious agent platform.
How to set up Antigravity with Gemini 3 Pro
Getting set up is straightforward, and understanding how the IDE, the model and the agent workflow fit together is what lets you use it well. The steps below take you from a fresh download to a configured, agent-first setup ready for real work.
Download and install Antigravity
Antigravity is available for the major operating systems. Download it from the official site and install it like any desktop application. At launch it was offered in public preview at no cost for individuals. Because it is built on a familiar editor foundation, the install and first-run experience feel recognizable, and within a few minutes the platform is ready to configure.
Sign in with your Google account
Next, sign in with a Google account to link the platform to your access and unlock the agent capabilities and model options. This usually quick, one-time authorization is what turns the installed IDE into a working agent platform, so complete it before you start. From here, the agents and models are available to you.
Select Gemini 3 Pro as your model
Set Gemini 3 Pro as your model in the configuration. It is Google’s most capable model and posted strong results on agentic and terminal-based coding benchmarks, which makes it well suited to the multi-step tasks Antigravity is built for. You can switch to another frontier model later, but Gemini 3 Pro is a strong default. A capable model is the engine the whole platform runs on.
Give the agents project context
Like any agentic tool, Antigravity works better when the agents know your project. A context file with your conventions and commands, in the spirit of an agents.md file, helps them follow your patterns and make fewer mistakes. Without it, they build in their own default style rather than yours.
Running your first agentic task
With the model and context set, describe a goal to an agent in the agent manager, let it plan and execute across files while you watch, and review the result. That is the basic rhythm of an agentic workflow. Pick a small but genuine task from your own work rather than a toy example, since it exercises the model, the context file and the review loop together. Keep it modest so you can follow every step, then grow into larger tasks as your confidence builds.
Configuring Antigravity for safe autonomy
Because Antigravity leans into autonomy, guardrails belong in the setup. Work in version control, start with tasks where you review the output, and use the platform’s built-in testing to verify results.
This reflects the mature idea that autonomy and verification go together. An agent that plans, writes and runs code across many files can do a lot before you look, so structure your setup to check what the agents produce. Configuring for safe autonomy is what lets you trust a hands-off run later. Set the guardrails before you loosen the reins.
Who Antigravity suits and where it fits
Antigravity fits developers who want to lean fully into agent-driven development, directing autonomous agents and reviewing their work rather than writing most of the code themselves. If you prefer to stay hands-on in a traditional editor, Cursor or VS Code with extensions may feel more comfortable. The more you want to orchestrate rather than type, the better it fits.
It does not have to be your only tool to be a useful one. Its agent-first approach suits heavier, orchestration-style work, so you might use it for that while keeping other tools for hands-on editing, the same way you would choose any workflow by the task at hand.
An early platform worth learning now
As a new platform launched in preview, Antigravity is evolving quickly, and its features, stability and workflows will shift as it matures. What is true today may change soon, so keep that in mind before committing deeply. Trying it to understand the agent-first approach is worthwhile, while treating it as a settled tool is premature.
Antigravity is worth understanding even if you do not adopt it, because it embodies a bet about where coding is going. If the future of development is orchestrating agents rather than typing code, a platform built around that idea previews the tools many developers may end up using. Whether or not this specific product wins, the agent-first concept it champions is spreading across the field. Watching how Antigravity handles agent management and verification shows you the shape of things to come.
Can You Build Complex Apps in Minutes Using Antigravity AI and Its Built-in Agent Features?
Antigravity’s central promise is bold: describe a complex app and let its autonomous agents build it while you direct and review, rather than writing the code yourself. It is an agent-first platform, so the real question is whether that agent-driven approach actually produces complex apps quickly. The honest answer is that it can build a great deal fast, with the familiar caveats about clarity and verification. Seeing what building in Antigravity really looks like separates the promise from the reality.
The agent-first way of building
Building in Antigravity means directing agents rather than typing. You describe what you want, and its agent features plan the work, create files, write code, run it, and iterate, with you overseeing rather than authoring. This shifts your effort from writing to specifying and reviewing, which is the core of agent-driven development. It genuinely feels different from a traditional editor, more like managing a build than performing it. The agents do the typing, and you do the steering.
Powered by Gemini 3
The capability behind the building comes largely from the model. With Gemini 3 driving the agents, Antigravity has a strong engine for the multi-step reasoning that complex apps require. A more capable model means agents that plan better, handle more of the tricky parts, and derail less often over a long build. This pairing of an agent-first platform with a frontier model is what makes the ambitious promise plausible. The quality of the build tracks the quality of the model underneath.
What it can build fast
For well-defined apps with familiar patterns, Antigravity can build impressively quickly. Standard features, common structures, and clear requirements are exactly what agents handle well, so much of a typical app comes together in a fraction of the usual time. Watching a working application emerge from a description is the platform delivering on its promise. This is the real speed that agent-first building offers on the right kind of work. Clear, conventional apps are where it shines most.
Where it still needs you
The limits are the familiar ones. Ambiguous requirements, subtle behavior, and novel design are where the agents guess, and their guesses are sometimes wrong, so the tricky parts still need your direction and correction. Antigravity does not remove the need for a thoughtful human, it changes what that human does. This is the same boundary that all coding agents run into, regardless of how polished the platform is. The agents build the routine, and you shape the hard and the ambiguous.
Iteration is still part of it
Even on a strong platform, a complex app rarely emerges perfect on the first pass. You run the result, find what is off, and direct the agents to fix specific issues, iterating toward a finished app just as you would elsewhere. Expecting a round or two of refinement is realistic, not a sign the platform failed. This describe, review, refine loop is the everyday rhythm of building with agents. The first build gets you far, and iteration closes the gap.
Speed versus stakes
The impressive speed suits some situations far better than others. For prototypes and internal tools, rapid agent-built apps are ideal, much like vibe coding at a larger scale, while production software still demands careful review of what the agents produced. Matching how much you trust the fast output to the stakes of the app is the key judgment. The platform gives you speed, and you decide where that speed is appropriate. Fast is a gift on low stakes and a risk on high ones.
You still own the result
However much the agents build, the responsibility for the app remains yours. Reviewing the code, testing the behavior, and confirming it does what you intended is essential before you rely on it, since a fast, fluent build can hide subtle problems. This accountability is the same for Antigravity as for any capable tool like Cursor and Claude Code. The platform changes how the app is built, not who is responsible for it. Own what the agents produced, especially the parts you did not watch closely.
How it compares to building elsewhere
Building in Antigravity is faster to start than a traditional editor for the right work, but the fundamental limits are the same everywhere. No agent-first platform escapes the truth that clear specs produce good results and vague ones produce confident mistakes, so the skill of directing agents transfers across tools. What Antigravity adds is a smoother path from description to running app, not a different set of rules for what agents can do. The platform is a better cockpit, and the flying is still yours to learn. Good building habits matter here exactly as much as they do anywhere else.
What Are the Key Differences Between Antigravity IDE’s Rules System and the Standard agents.md Approach?
Every serious agentic tool needs a way to tell its agents how your project works, and Google Antigravity is no exception. It provides its own rules system for guiding agents, which sits alongside the increasingly standard agents.md approach the wider field has adopted. Both solve the same problem, giving agents the durable context they cannot infer, but they differ in ways worth understanding. Knowing the distinction helps you set up Antigravity well and keep your guidance portable.
Both solve the same problem
At heart, Antigravity’s rules and an agents.md file do the same job. Each is a way to give agents the conventions, commands, and constraints they need to work correctly in your project, so they stop guessing and start following your rules. This is fundamentally an act of context engineering, shaping what the agents see regardless of the specific format. The shared purpose is more important than the differences. Both are about handing agents durable, high-value context.
What Antigravity’s rules system is
Antigravity provides its own mechanism for defining rules that steer its agents, integrated into the platform. This lets you specify how agents should behave within Antigravity’s agent-first environment, tailored to its particular workflow and agent manager. Because it is built into the tool, it can integrate tightly with the platform’s features. It is the native way to guide agents when you are working inside Antigravity. The rules live where the agents run.
What the agents.md standard is
The agents.md approach is an open standard for a markdown file that briefs any compatible agent, adopted across many tools. Rather than being specific to one platform, it aims to be a universal format that different agents can all read. This portability is its defining strength, letting one file guide agents across the tools you use. It is the industry’s answer to every tool inventing its own format. One standard, many agents.
The key difference is portability
The most important distinction is how portable your guidance is. A tool-specific rules system works within that tool, so its guidance stays there, while an agents.md file can be read by many tools, so your context travels with the project across your toolset. If you use only Antigravity, its native rules are convenient, but if you use several tools, a standard file avoids maintaining separate guidance for each. Portability is the practical axis on which they differ. Native is convenient, and standard is portable.
Integration versus universality
The trade-off is between tight integration and broad compatibility. A native rules system can hook into a platform’s specific features more deeply, potentially offering capabilities a generic file cannot. A universal standard trades some of that depth for the ability to work everywhere. Which matters more depends on whether you value platform-specific power or cross-tool consistency. Each approach optimizes for a different thing. Depth in one tool, or reach across many.
Maintenance and drift
There is a real cost to maintaining guidance in multiple places. If you keep both a native rules setup and separate files for other tools, they can drift out of sync, leaving your agents with contradictory guidance. Consolidating on one source of truth, wherever possible, avoids this, which is the same reason a clean agents.md file is easier to keep current than scattered rules. One home for your context is far easier to maintain than several. Fewer places to update means fewer chances to drift.
Which to use
For most people, leaning on the open standard where the tool supports it is the wiser default. Using agents.md as your primary source of context keeps your guidance portable and future-proof, so it still works if you change tools, while using a platform’s native rules for anything genuinely specific to it. This mirrors the broader lesson that betting on standards ages better than betting on one vendor’s format. Prefer the portable file, and reach for native rules only when you need their specific power. Standard first, native where necessary.
The direction of the field
The wider trend favors standardization, which is worth weighing. As agents.md spread across many tools, the value of a portable, shared format grew, and platforms increasingly support it alongside their native systems. Understanding this direction, the same convergence that makes context engineering with agents.md so central, helps you choose durably. Investing in the standard is investing in something likely to keep working. The field is converging, and aligning with that convergence is the safe bet. Standards tend to win precisely because everyone has a stake in them working.
Keep your context portable
A practical way to hedge is to treat portability as a feature of your context, not an afterthought. Writing your project guidance in the open format first, and only translating the genuinely platform-specific bits into a tool’s native rules, keeps the bulk of your work reusable across whatever you adopt next. Tools come and go quickly in this space, but a portable context file outlives any single one of them. This is the same reason developers favor open standards over proprietary formats throughout their stack. Portable context is an investment that keeps paying off as your tools change. The small effort of staying portable saves a much larger effort later.
How Does Antigravity’s Automated Testing With Playwright Work During AI-Powered Development?
A recurring problem with AI-generated code is that an agent claims success without truly verifying it, especially for user interfaces where looking right and working right are different things. Antigravity addresses this by letting its agents test their own work automatically, using the browser-automation framework Playwright. This closes the loop between building and verifying inside the platform. Understanding how it works shows why verification-in-the-loop is such a powerful idea for AI-powered development.
What Playwright is
Playwright is a widely used framework for automating a real browser to test web applications. It can open a page, click buttons, fill forms, and check that the result is what it should be, effectively driving an app the way a user would to confirm it behaves correctly. This makes it a natural fit for verifying front-end code, where behavior matters as much as the code itself. It is a proven tool for end-to-end testing. Automating the browser is how you check that an app truly works.
Why testing matters for AI code
Automated testing is especially valuable when an agent writes the code, because agents are optimistic and will declare a feature working without proof. A test that actually exercises the feature turns that claim into something verifiable, catching the gap between what the agent thinks it built and what it actually built. This is the mechanism that makes autonomous building trustworthy rather than hopeful. Verification is what separates a demo from a dependable result. Tests are how you hold agent output to account.
How Antigravity uses it
Antigravity integrates this testing into its agent workflow, as part of the platform. When an agent builds a feature, it can use Playwright to run the app in a browser, perform the actions a user would, and check that the behavior is correct, all as part of the build rather than as a separate step. This means the agent verifies its own work before handing it to you. Baking testing into the loop is what makes the verification automatic. The agent builds and checks in one flow.
The build-and-verify loop
The real power is the loop this creates. An agent writes the code, runs the Playwright test, reads the result, and if the test fails, it can try again, iterating until the feature actually works. This is a feedback loop that catches mistakes before a human ever sees them, which is the essence of reliable agentic building. An agent that can see its own failures can fix them, and this is how it does so for the front end. Building plus testing plus iterating is the recipe for trustworthy autonomy.
Catching what static checks miss
Browser-based testing catches problems other checks cannot. Code can be syntactically perfect and still produce a broken layout, a button that does nothing, or a flow that fails, and only actually running the app reveals these. Playwright exercises the app as a user would, so it catches the behavioral bugs that matter most for real software. This is why end-to-end testing is a stronger guarantee than checking the code alone. Running the app is the only way to know it really works.
It is not a complete guarantee
Automated testing is powerful but not infallible, and it is worth keeping that in perspective. A test only checks what it was written to check, so behavior nobody tested can still be wrong, and a poorly written test can pass on broken code. Playwright verification catches a great deal, but it does not remove the need for a human to review the overall result. The tests are a strong safety net, not a perfect one. Trust the testing, and still confirm the important things yourself.
You still review the outcome
Even with the agent testing its own work, the final judgment stays with you. Reviewing what was built, checking that it matches your intent, and confirming the tests actually cover the important behavior is still your job, as it is with any capable tool like Cursor and Claude Code. The automated testing raises your confidence and reduces your burden, but it does not eliminate your responsibility. Let the tests do the heavy lifting, and keep the final say. Verification helps you, and it does not replace you.
Part of a bigger verification story
Playwright testing is one piece of how Antigravity, described in its overview, tries to make autonomous building trustworthy. The platform’s whole design assumes agents will do a lot of the work, so verification has to be woven throughout rather than left to the end. Browser-based testing is the front-end half of that story, complementing other checks the agents can run on the code itself. Seen this way, the testing is not a bolt-on feature but a core part of the agent-first philosophy. A platform that trusts agents to build must also help them prove their work.
Common questions
What is Google Antigravity?
It is Google’s agent-first development platform, launched in late 2025 with Gemini 3. It combines an IDE, a CLI and an SDK for orchestrating autonomous agents that generate, run and test code, built on a VS Code foundation.
Can Antigravity use models other than Gemini 3 Pro?
Yes. It offers model choice, including Gemini 3 Pro and support for other frontier models, so you are not locked into a single provider.
How is Antigravity different from Cursor?
Both are AI-native editors built on VS Code, but Cursor stays editor-centric with an agent mode, while Antigravity makes the agent the primary interface through its agent manager.
How do you use Antigravity safely?
Work in version control, start with tasks where you review the output, and use the platform’s built-in testing to verify what the agents produce.
Can Antigravity build complex apps quickly?
Yes, for well-defined apps with familiar patterns. Its agents, powered by Gemini 3, plan, write, run, and test code, so much of a typical app comes together in a fraction of the usual time.
What does building in Antigravity feel like?
Like directing agents rather than typing. You describe what you want and oversee the agents as they plan, create files, write code, and iterate, shifting your role from authoring to specifying and reviewing.
Where does Antigravity still need human input?
On ambiguous requirements, subtle behavior, and novel design, where the agents guess and are sometimes wrong. The tricky parts still need your direction and correction, as with any coding agent.
Does Antigravity verify the code it builds?
Yes, verification is part of the flow. Its agents can run and test the code they write, so more mistakes are caught during the build rather than after, making the fast output more trustworthy.
Related Articles
If you enjoyed reading this, then please explore our other articles below:
More Articles
If you enjoyed reading this, then please explore our other articles below:



2019-2026 ©