Antigravity - full guide to Google's AI agent IDE

May 2026

When Google announced its own code editor built around AI agents in November 2025, the developer community reacted with curiosity and cautious skepticism. We already had Cursor, Windsurf, GitHub Copilot – why did we need another one? It turns out Antigravity is something fundamentally different. It is not "VS Code with a chatbot." It is an attempt to redefine what the relationship between a developer and AI looks like – a shift from an assistant that suggests code to an autonomous team of agents carrying tasks from idea to deployment.

This article is a detailed overview of Antigravity: what it is, how it works, what sets it apart, and how to configure it for optimal results.

Philosophy: Agent-First

Antigravity was designed from the ground up as an "agent-first" environment – AI is not an auxiliary tool, it is a full participant in the software development process. Google's stated mission for the platform is simple:

Enable anyone with an idea to experience a startup and build that idea into reality.

This translates into four core principles visible in every aspect of the interface:

Trust

The agent does not just write code – it delivers verifiable artifacts: an implementation plan, a task list, screenshots of the running application, and browser test recordings. You do not have to blindly trust the agent – you have evidence of its work.

Autonomy

Agents operate simultaneously across all environments: they write code in the editor, execute commands in the terminal, and navigate pages in the browser. They do not wait for confirmation at every step – they behave like an independent developer.

Feedback

You can leave an asynchronous comment on any artifact – text, code, screenshot – just like in Google Docs. The agent incorporates that feedback in subsequent iterations.

Self-Improvement

Antigravity builds a project knowledge base: agents remember code patterns, architectural decisions, snippets, and schemas of completed tasks. With each session, the agent better understands the project and your preferences.

Interface Architecture: Two Worlds

Antigravity has a unique dual-window architecture you will not find in any other IDE.

Editor View – A Familiar Editor, Powered by AI

The editor view looks like VS Code – because it technically is (a modified fork). You will find a file explorer, a syntax-highlighted code editor, an integrated terminal, and an agent panel on the side. You can use VS Code keybindings, and many extensions work too.

Key features of the editor view:

• Tab Completion – intelligent code completion that takes the full project context into account.
• Inline Commands – describe a change in natural language directly in the editor, and the agent applies it.
• Agent Panel – chat with an agent pinned to the context of the currently open file.
• @-context – add context via @fileName; the agent focuses on specific resources.

Manager Surface – Agent Mission Control

This is what truly sets Antigravity apart. Manager Surface is a separate agent management window – your mission control.

Inbox – a list of all active tasks. You see what agents are working on, which artifacts they have generated, and which tasks need your response.

Workspaces – project management. Each workspace is a separate folder with its own set of agents and work history.

Playground – a space to test prompts, experiment with different models and approaches before launching an agent on a real task.

Browser – an integrated browser where you can watch the Browser Sub-Agent navigate pages, click buttons, fill out forms, and take screenshots.

Switching between Manager Surface and Editor View is done with Cmd+E (or Ctrl+E on Linux/Windows).

AI Models Available in Antigravity

Antigravity offers a choice of models – match computing power to the task:

Gemini 3.1 Pro achieves 76.2% on SWE-bench Verified – a benchmark measuring the ability to solve real GitHub Issues. The context window is 1 million tokens, enabling work with very large codebases.

Work Modes: Planning vs Fast

Antigravity does not have a single agent mode – you can choose how much time and resources the agent dedicates to planning before acting.

Planning Mode

The agent first builds a detailed implementation plan – it breaks the task into subtasks, determines the order, and anticipates dependencies. Only after you approve the plan does it begin coding.

When to use:
- New project or large module.
- Complex business logic with many dependencies.
- Architectural decisions that will be hard to undo later.
- When you want full control over the approach.

Characteristics: longer execution time, lower error rate, higher AI credit consumption.

Fast Mode

The agent acts immediately, without a planning phase. It focuses on fast execution.

When to use:
- Simple, well-defined tasks.
- Iterations and minor fixes on existing code.
- Chatbots and interactions requiring low latency.
- Routine operations (formatting, documentation, refactoring).

Characteristics: low response time, optimized for repetitive tasks, efficient credit usage.

Artifact System – Evidence of the Agent's Work

This is one of Antigravity's most interesting innovations. Instead of raw tool calls and terminal logs, the agent generates artifacts – structured, verifiable evidence of its work.

Implementation Plan

Before writing a single line of code, the agent creates a readable plan: what it will do, in what order, and which tools it will use. You can edit this plan – it is like editing instructions for a developer.

Task List

A numbered list of subtasks with status indicators. Visible in real time – you watch the agent check off each item.

Screenshots and Video

The Browser Sub-Agent automatically takes screenshots and records test sessions. You receive visual proof that the application looks and works as intended.

Code Diffs

A precise, line-by-line comparison of all file changes. Ideal for code review – you know exactly what changed and why.

Test Results

Structured test results with coverage metrics. The agent does not just claim that tests pass – it shows specific numbers and test cases.

Browser Sub-Agent – AI with a Keyboard and Mouse

The Browser Sub-Agent is one of Antigravity's most spectacular features. The agent has access to a real browser (integrated or through a Chrome extension) and can:

• Navigate pages (enter URLs, click links).
• Interact with the interface (fill out forms, click buttons, scroll).
• Read the DOM and page state.
• Take screenshots and record sessions.
• Wait for animations, loading, and state changes.
• Verify that the application works correctly after changes.

A practical scenario: you are building a login form. Instead of writing unit tests, you can tell the agent: "Test login with correct and incorrect credentials, take a screenshot of each case." The Browser Sub-Agent will do this itself and deliver visual confirmation.

Multi-Agent Orchestration – Parallel Agent Work

Antigravity allows you to run multiple agents simultaneously in different workspaces, each focused on a different task.

A typical scenario:
- Agent 1 – writes the main application logic.
- Agent 2 – generates unit and integration tests.
- Agent 3 – writes documentation and README.
- Agent 4 – reviews security and performance.

Instead of waiting for one to finish before starting the next – you get a three-times-faster development cycle.

Manager Surface shows the status of all agents on a single screen. You can leave comments on individual threads, and the agent will incorporate them asynchronously.

AgentKit 2.0 – 16 Specialized Agents

The 2026 update introduced AgentKit 2.0 with a library of 40+ ready-made domain skills and 16 specialized agents, each optimized for a specific area.

Examples of Specialized Agents

40+ Domain Skills (examples)

Data Analysis (12+): business reports, statistical analysis, data visualizations, ETL pipelines.

Text Processing (10+): document generation, translation, summaries, information extraction.

Vision (8+): image classification, OCR, UI/UX analysis, screenshot generation.

Integrations (10+): Slack, Google Workspace, Salesforce, Jira, Linear, Notion.

MCP – Over 1,500 Connectors

Antigravity has native support for the Model Context Protocol with an impressive library of over 1,500 ready-made MCP servers. This is significantly more than any competitor.

MCP configuration in Antigravity is integrated into the GUI – you can browse available servers, install them with a single click, and manage permissions without touching configuration files (though manual editing is also possible).

Popular integrations:
- GitHub – PRs, issues, code review, Actions.
- Google Cloud – deployment, logs, resources.
- Databases – PostgreSQL, MongoDB, Redis (direct queries).
- Project management – Jira, Linear, Notion.
- Communication – Slack, Google Meet.
- Testing – Cypress, Playwright, Selenium.

AGENTS.md – Declarative Agent Configuration

AGENTS.md is a configuration file format introduced in Antigravity v1.20.3 that quickly became an inter-tool standard – it is also supported by Cursor and Claude Code.

You place the file in the root directory of your project and define agent roles, assigned skills, operating modes, and collaboration rules within it.

# AGENTS.md
agents:
  - name: "data-analyzer"
    type: "Data Agent"
    skills:
      - "sql-query"
      - "data-visualization"
      - "statistical-analysis"
    config:
      mode: "planning"

  - name: "report-generator"
    type: "Content Agent"
    skills:
      - "text-generation"
      - "document-formatting"
    config:
      mode: "fast"

Benefits of AGENTS.md:
- Agent configuration is versioned together with the project.
- The entire team uses the same settings.
- The file works across different tools (Antigravity, Cursor, Claude Code) – one standard.
- No code required – readable by all developers.

Agent-to-Agent (A2A) – Remote Agent Calls

A2A is an advanced feature that allows agents in one Antigravity instance to invoke agents from other instances over the network. This enables:

• Geographically distributed processing (e.g., customer data in different regions).
• Cross-organization integrations.
• Microservice architecture for AI agents.
• Load balancing across instances.

This approach is pioneering and signals the direction the entire industry is heading – from individual agents to networks of collaborating agents.

Project Knowledge Base – An Agent That Learns

One of the things you will not find in competing tools is a built-in project knowledge base. Antigravity builds it automatically during work:

• It remembers code patterns and architectural decisions.
• It stores reusable snippets and components.
• It records schemas of completed tasks.
• It learns from your feedback.

In practice, this means agents in the same project get progressively better with each session. An agent that implemented authentication a month ago remembers how it did it and will apply the same pattern again – consistently, without being asked.

Trust Modes and Terminal Policies

Antigravity offers configurable levels of autonomy – you decide how much freedom the agent has:

Development Mode

Agent-Assisted – the agent decides when to ask for review. A good balance of autonomy and oversight, recommended for beginners.

Agent-Driven – turbo mode. The agent operates as independently as possible, asking only for truly critical decisions. For experienced developers who trust the agent.

Terminal Policy

Auto – the agent asks for permission before every terminal command (safer).

Turbo – the agent executes commands without asking (faster).

Review Policy

Agent Decides – the agent itself decides when to show you a result for approval.

Always Review – every change waits for your approval (for critical projects).

Workflows – Automating Repetitive Processes

Antigravity supports defining custom workflows – sequences of steps that the agent executes automatically for repetitive tasks:

• Deployment pipeline (staging → tests → production).
• New module scaffolding (file structure, tests, documentation).
• Code review checklist.
• Weekly progress report.

You can describe a workflow in natural language or in a dedicated format. Antigravity maintains a community library of ready-made workflows – you can import popular patterns instead of building from scratch.

Rules – Project Rules

Like Cursor, Antigravity lets you define rules that guide the agent's work. The community rules library is available at antigravity.codes/rules.

Rules can be defined through the GUI (without editing files) or through configuration files. You specify:

• The project's technology stack.
• Coding standards and conventions.
• Preferred style and patterns.
• Security constraints.
• Testing preferences.

Pricing (May 2026)

During the public preview (ongoing throughout 2026) the free plan is surprisingly generous – Gemini 3.1 Pro for everyone, no credit card required. The credit limit refreshes every 5 hours, and consumption depends on task complexity (simple tasks use fewer credits, complex planning sessions use more).

Installation and First Steps

System Requirements

• macOS, Windows, or Linux.
• 8 GB RAM (16 GB recommended).
• 2+ GB free disk space.
• Internet connection (required).
• Google Chrome (for Browser Sub-Agent).

Installation

1. Download Antigravity from the official website.
2. Install it in the standard way for your operating system.
3. Sign in with a Google account.
4. Open a project folder or clone a repository.
5. Done – Gemini 3.1 Pro is available immediately.

First Task – A Good Recipe for Getting Started

Use Planning Mode for new projects and describe tasks like user stories with acceptance criteria. Instead of:

"Make a login form"

Write:

"Create a login form with email and password fields. Client-side validation. Show an error message on failed login. Redirect to /dashboard on success. Stack: React + Tailwind. Verify both scenarios in the browser and deliver screenshots."

Specific requirements = much better artifacts and fewer iterations.

Best Practices

Build iteratively – do not dump an entire specification into a single prompt. Start with a basic version and expand step by step.

Use Planning Mode for architectural decisions – a bad architectural decision made once can cost weeks of refactoring.

Comment on artifacts – Google Docs-style feedback is far more effective than rewriting the prompt. The agent understands the context of a comment better than an abstract "do it differently."

Use Fast Mode for routine work – formatting, documentation, and simple fixes do not require Planning Mode. You will save credits and time.

Commit often – the agent can make a mistake that is hard to undo. Small, frequent commits are your safety net.

Define AGENTS.md from the start of the project – the earlier you define agent roles and standards, the more consistent the code will be throughout the project's lifecycle.

Comparison: Antigravity vs Cursor

Both tools target a similar audience – professional developers who want more efficient collaboration with AI. But their philosophies are fundamentally different.

Philosophy and Paradigm

Cursor evolved from a code editor – AI gradually became a stronger participant, but the core is still the classic workflow: you write code, AI helps.

Antigravity was designed from scratch around agents – tasks, not files, are the basic unit of work. Instead of asking "how do I write this function?", you ask "implement this function and prove it works."

Interface

Agent Configuration

Cursor emphasizes configuration depth: rules (.cursor/rules/), skills (~/.cursor/skills/), hooks (.cursor/hooks.json), CLI status line. You can precisely control agent behavior in every scenario. It is an environment for someone who wants maximum control and understands how the model thinks.

Antigravity emphasizes accessibility and declarativeness: AGENTS.md, a library of ready-made rules and workflows via GUI, 40+ ready-made domain skills. Less flexible, but faster to configure and more friendly to less advanced users.

AI Models

Cursor is more flexible in model selection – you can use any of the supported models as the primary. Antigravity relies on Gemini by default but also supports Claude and GPT.

Multi-Agent and Parallelism

Cursor supports subagents (types: explore, generalPurpose, shell, best-of-n-runner), but managing them happens in a single chat window. Subagents are an internal tool of the agent, not a separate UI layer.

Antigravity is designed around multi-agent from the ground up. Manager Surface is a dedicated interface for observing and coordinating multiple agents. The 16 specialized agents from AgentKit 2.0 and A2A remote calls represent a qualitatively different level of orchestration.

Verification and Evidence of Work

Cursor has no formal artifact system – the agent completes a task, and you can review file changes and terminal logs.

Antigravity delivers structured artifacts: plan, task list, screenshots, test video, code diff. This is a significant advantage when auditability and trust in the result matter.

Automation and Hooks

Cursor has an advanced hook system – the ability to run custom scripts or prompts at dozens of different events (beforeShellExecution, afterFileEdit, subagentStop, etc.). This is a tool for developers who want to precisely program agent behavior.

Antigravity offers Workflows and terminal policies, but has no equivalent of the hook system. Less flexible, but also less complex to configure.

Browser Automation

Cursor has no built-in browser control – it requires extensions or external tools.

Antigravity has a native Browser Sub-Agent as a first-class feature – autonomous E2E testing without additional configuration.

Pricing

Antigravity is more attractive at the free tier – access to Gemini 3.1 Pro without a monthly limit (only credits refreshing every 5 hours). Cursor on the free plan limits you to 200 requests per month.

MCP and Integrations

Cursor supports MCP; the ecosystem is growing. Configuration via JSON files.

Antigravity claims over 1,500 native MCP connectors with a GUI for managing them. For projects that rely heavily on external tools, this is a serious advantage.

Who Should Use What?

Comparison Summary

Cursor and Antigravity do not so much compete as represent two different approaches to AI in programming.

Cursor is a tool for developers who want full control – deep configuration, precise rules, hooks, flexible model selection. It requires more time to configure, but rewards that investment with excellent results for someone who understands how to use it.

Antigravity is a tool for those who want to delegate tasks – describe the goal, not every step. Stronger in multitasking, verification, and for people who do not want to deeply configure the tooling. Easier to get started with, with built-in proof of work.

In 2026, more and more developers use both tools simultaneously: Antigravity for design and prototyping (Planning Mode, multi-agent), Cursor for everyday coding (tab completion, precise hooks, code intelligence). It is not either-or – it is a question of which tool best fits the specific task.

Article written in May 2026. Antigravity is actively developed – version 1.20.5 is current at the time of publication. Both features and pricing are subject to change.

Sources and Further Reading

1. Google Antigravity – official website – platform description, agent-first philosophy, Gemini 3.1 Pro benchmarks, quick start.
   googleantigravity.org

2. Complete Guide to Google Antigravity (2026) – comprehensive tutorial: installation, interface, artifacts, Browser Sub-Agent, multi-agent, MCP.
   antigravity.codes/tutorial

3. Antigravity 2026 Latest Features Update Explained – detailed description of AgentKit 2.0, 16 specialized agents, 40+ domain skills, AGENTS.md, A2A.
   antigravitylab.net – Features Update 2026

4. The Complete AI IDE Comparison Guide 2026 – comparison of Antigravity, Cursor, Windsurf, and GitHub Copilot: use cases, pricing, agent capabilities.
   antigravitylab.net – AI IDE Comparison 2026

5. Download Antigravity – current version (v1.20.5) for macOS, Windows, and Linux.
   antigravity.codes/download