Google Antigravity combines an Agent Manager, plan review, and browser control in an IDE for AI-Driven Development.

Note (August 2026): The native browser integration described below as a unique feature is no longer unique – other agents now drive a browser on their own as well. See my hands-on comparison Claude Code vs. Codex vs. Cursor for details.

Introduction

Google positions Antigravity as an “Agentic Development Platform”. AI is not just a feature here, but the foundation of the entire development process. A similar approach could already be seen in Amazon Kiro (see also my blog post about Kiro). Major players in the market are increasingly reacting to the realization that AI-Driven Development is more than AI-powered code completion. It is about rethinking and redesigning software development as a whole.

Antigravity goes one step further than other AI development tools. As we will see below, Antigravity offers a separate “Agent Manager” where multiple agents can be started, monitored, and coordinated at the same time. In addition, Antigravity agents can work with the editor, the terminal, and especially the browser out of the box.

Technically, Antigravity is based on a fork of Visual Studio Code. By default, Antigravity uses the Open VSX marketplace for extensions. You can manually reconfigure this, for example to use extensions from Microsoft’s Visual Studio Code Marketplace. However, some extensions do not work in that setup, including some from Microsoft itself, such as the C# Dev Kit extension. For .NET developers, Antigravity is therefore currently probably not a real alternative to Visual Studio Code despite its interesting AI-Driven Development features.

Antigravity was officially introduced in November 2025 and is currently available as a free public preview. It runs on Windows, macOS, and Linux and requires Chrome as the browser (if you want to use the very cool browser integration, see below). At least for the preview, a Google account is also required. As expected, Gemini 3 Pro is available, and Anthropic models and GPT-OSS are optionally supported as well. There are rate limits that vary by plan. I could not find exact numbers, though. For the free plan, the docs only state: “Meaningful quota, refreshed weekly. Weekly rate limit”. Other plans, such as “Google AI Pro”, offer more (“High, generous quota, refreshed every five hours”). It is fair to assume that the subscription model will change again after the preview phase. For now, free access to Gemini 3 Pro is clearly a plus. In the IDE itself, I did not immediately find any indicator showing how much quota had already been used or how long it would take until the next reset. From my perspective, this is a clear downside because it creates the risk of hitting the limit in the middle of an important task.

Modes and Interface

The Antigravity editor interface is similar to a classic VS Code editor with an AI chat on the side. In the editor itself, the usual code completion features are supported. The claim of being an “Agentic Development Platform” becomes clearly visible for the first time as soon as you open the Agent Manager.

In Antigravity, multiple agents can work in parallel across different workspaces. The Agent Manager provides an overview of all active agents, their current tasks, progress, and the ability to interact with them directly. At the top of the screenshot, you can see the “Inbox”, where developers are informed about new results or follow-up questions from agents. Agents can also perform tasks across multiple workspaces, which in my opinion is almost a must in all non-trivial projects (for example, to have agents consistently verify a planned API extension across backend and frontend workspaces). Until now, I had only seen this feature in OpenAI Codex (see also my comparison of OpenAI Codex and GitHub Copilot).

To start a new task, you use the chat shown at the bottom of the Agent Manager, as usual. Here, you can also set the so-called “Conversation Mode”. The options are “Planning” and “Fast”. In “Planning” mode, the agent first creates a detailed plan that breaks a task down into smaller steps. In “Fast” mode, the agent skips planning and executes instructions immediately. I especially liked this native support for implementation plans, since I consider this approach a prerequisite for successfully applying AI-Driven Development.

As soon as an agent has created an implementation plan in “Planning” mode, it is displayed directly in the Agent Manager. The review functionality is well designed: developers can leave comments directly in the plan, which the agent then takes into account in further work (see screenshot). Antigravity is quite “intelligent” in this review process: smaller comments are integrated directly into the plan, and implementation starts right away. Review comments that cause larger or truly relevant plan changes are recognized by the agent and trigger another plan review round before implementation begins.

Once the review is complete, implementation can be started directly from the plan via the “Proceed” button. The agent then starts task planning and execution. The screenshot below shows, for example, the output of an agent during execution of a complex task. The task here was to implement a first feature in a sample application, a React SPA for managing and running online surveys. The agent recognized that the workspace was still completely empty (except for architecture and feature documentation, which served as the basis for implementation). It then split the work on its own accordingly, starting with project initialization and followed by the individual implementation steps. Also impressive is how long the agents can work autonomously on a task without, so to speak, losing focus. During the whole execution, the individual steps are documented in the task list so developers can always understand what the agent is currently doing or has already done.

Implementation plans, task lists, and so-called walkthroughs (documentation of executed tasks) are supported by Antigravity out of the box as artifacts of an AI-Driven Development process. In addition, Antigravity also knows screenshots, browser recordings, and knowledge items. All artifacts are automatically generated by the IDE at the “right” points in the development process and can be viewed and commented on at any time by developers. One major downside is that these artifacts currently cannot be stored or versioned as separate files. See also my notes in the “Weaknesses and Risks” section.

Browser Integration

Another unique feature of Antigravity is native support for browser interactions by agents. This means agents can not only work with the code editor and terminal, but can also independently test implemented features in a browser. The prerequisite is using Chrome. In practice, this means agents can, for example, automatically start the React SPA they are currently developing and then run tests on their own to validate functionality. Agents can not only operate the app, but also create screenshots and browser recordings and read the DOM. Especially for web application development, this native browser integration is a real game changer. In other AI-Driven Development tools I have tried so far, I always had to rely on screenshots to fix layout issues, creating them manually and then providing them to agents as context. In Antigravity, agents can directly access the application and collect the required information on their own, which makes the development process significantly more efficient.

Weaknesses and Risks

The biggest weakness of Antigravity that I noticed during my tests is also one of its strengths: the most important artifacts of an AI-Driven Development process, such as implementation plans and walkthroughs, are supported natively and automatically. The UI support is excellent, as can be seen in the very thoughtfully implemented review functionality. However, these artifacts are not stored as separate files in the workspace (at least not in an obvious way). This does not match what I consider the expected standard for an AI-Driven Development workflow, where all artifacts should be versioned and stored in a traceable manner.

Another downside is the lack of transparency regarding quota and rate limits. There is no way to see current usage or the remaining time until the next reset. This was also similar in other AI development tools, such as Codex, in the beginning and was then delivered relatively quickly. Google will probably react here in the short term as well.

The high autonomy level of agents, as in other tools, also comes with risks. This is not an Antigravity-specific issue, but a general challenge in AI-Driven Development. There is a risk that agents perform unforeseen actions or make unwanted changes. Antigravity does provide various configuration options to control and limit agent autonomy. For example, developers can define that agents need confirmation before executing certain actions, or that they are only allowed to run specific terminal commands.

Whether the limited extension ecosystem of Antigravity is a problem depends on individual requirements and the specific project. For developers who strongly depend on specific extensions, however, this may be an obstacle.

Conclusion

Antigravity is, in my view, a very promising tool for AI-Driven Development. I am especially impressed by the native support for implementation plans, including inline reviews, and by the browser integration. The Agent Manager and the option to let multiple agents work in parallel across multiple workspaces are also very well implemented.

From my perspective, the current market phase for AI-Driven Development tools is very exciting because increasingly innovative solutions are being released. To convince as many developers as possible, vendors are offering free downloads and generous quotas even for their most capable models. I can only recommend using this phase actively and building a broad view of the market. Right now, nobody can afford to declare one of the currently available solutions as “the best” too early and lock into it. My clear recommendation for at least the next 12 months is: regularly try new tools, observe developments, and react dynamically to market changes.