Google Antigravity

Google Antigravity is an agentic platform for assigning work to AI agents, monitoring their progress, reviewing what they produce, and controlling what they may do.

It began as an agent-first coding IDE. The current product family is broader:

Antigravity 2.0 is a standalone desktop application for managing agents across projects.
Antigravity IDE is the code-focused editor.
Antigravity CLI brings the same agent harness to a terminal interface.
Antigravity SDK exposes the harness as a Python library.
Managed agents make the Antigravity agent available through the Gemini API.

What A Beginner Should Understand

A normal chatbot waits for a message and returns text.

An agent can work through a longer loop:

understand a goal
inspect files and other information
propose or update a plan
call tools
edit files or operate applications
run checks
inspect the results
ask for approval when required
continue until it reaches a stopping condition

Antigravity provides an agent harness and product environment around one or more models, including models outside the Gemini family.

The harness supplies:

project and conversation management
file, shell, browser, web, and MCP tools
permissions and approval prompts
context and artifact storage
subagent orchestration
hooks and scheduled tasks
interfaces for reviewing plans, diffs, images, and recordings

The selected model still matters, but the harness determines how that model is connected to the computer and supervised.

The Current Product Family

flowchart TB
    U["User"] --> D["Antigravity 2.0<br/>visual agent command center"]
    U --> I["Antigravity IDE<br/>code-focused editor"]
    U --> C["Antigravity CLI<br/>terminal interface"]
    B["Application developer"] --> S["Antigravity SDK<br/>Python library"]
    B --> A["Gemini API<br/>managed Antigravity agent"]

    D --> H["Shared Antigravity agent harness"]
    I --> H
    C --> H
    S --> H

    H --> T["Files, shell, browser,<br/>MCP, skills, and subagents"]
    H --> R["Artifacts, permissions,<br/>hooks, and execution state"]
    A --> E["Remote ephemeral<br/>Linux environment"]

These surfaces solve different problems.

Surface	Best for	Execution model
Antigravity 2.0	Supervising several agent conversations, projects, and scheduled work	Local desktop application with synchronous and asynchronous agents
Antigravity IDE	Interactive coding, code navigation, visual diffs, and browser-assisted development	Local agentic IDE
Antigravity CLI	Terminal-first work, SSH sessions, and low-overhead interaction	Local terminal UI using the shared harness
Antigravity SDK	Building a custom agent application in Python	Programmatic local runtime with tools, policies, hooks, and sessions
Managed Antigravity agent	Calling a hosted agent from an application	Remote agent provisioned through the Gemini API

What changed after the original launch

The November 2025 launch described one IDE with three tightly connected surfaces:

editor
browser
Agent Manager

That description is useful for understanding the original design, but it is no longer the complete product map.

Google introduced Antigravity 2.0 in May 2026 as a separate desktop application that does not require an IDE. The Antigravity IDE remains available for developers, while the CLI and SDK expose the same general harness through different interfaces.

The window arrangement has changed, while the underlying separation remains useful:

supervising work at the project or agent level
editing code directly
operating and verifying behavior through external tools

Why An Agent Manager Exists

Traditional development tools center the file currently open in an editor. That works well when a human is making one change at a time.

Long-running agents introduce different questions:

Which tasks are still running?
Which agent needs permission?
Which plan is waiting for review?
Which agents are modifying the same repository?
What evidence did each agent produce?
Which result needs human attention now?

An agent-manager interface treats conversations, projects, approvals, artifacts, and notifications as first-class objects. The human moves from watching every step to reviewing important milestones.

This does not eliminate the editor. When a change needs direct inspection or manual correction, the developer should still open the files, inspect the diff, and use the project’s normal tools.

Artifacts Are The Review Interface

Antigravity defines an artifact as a structured deliverable created by an agent to complete work or communicate with a human.

Examples include:

implementation plans
task lists
code diffs
architecture diagrams
generated images
screenshots
browser recordings
final walkthroughs

flowchart LR
    G["User goal"] --> P["Implementation plan"]
    P --> Q{"Questions or approval?"}
    Q -->|"Clarify"| U["Human feedback"]
    U --> P
    Q -->|"Approved"| W["Agent executes work"]
    W --> D["Diff and test results"]
    W --> B["Screenshots or<br/>browser recording"]
    D --> R["Human review"]
    B --> R

Why artifacts help

A raw agent transcript may contain hundreds of tool calls, repeated explanations, and abandoned approaches. Reading it from beginning to end is usually a poor way to review work.

Artifacts compress that activity into reviewable questions:

Does the plan match the requirement?
Does the diff implement the approved plan?
Does the diagram represent the actual architecture?
Does the recording demonstrate the expected user flow?
Do the tests cover the important failure cases?

Antigravity supports inline feedback on artifacts. A reviewer can comment on a plan or other output and let the agent incorporate the feedback before continuing.

An artifact is not automatically proof

Artifacts are generated by the same system performing the work. They can be incomplete or misleading.

Artifact	What it can show	What it cannot prove alone
Plan	Intended scope and sequence	That the design matches the real codebase
Diff	Files and lines changed	That unchanged paths still behave correctly
Screenshot	One visual state	Accessibility, responsive behavior, or hidden interactions
Browser recording	Actions performed and visible responses	Internal correctness or complete test coverage
Walkthrough	Agent’s explanation of its work	That the explanation matches the implementation

Use artifacts to make review efficient, then ground them with independent evidence:

repository inspection
deterministic tests
build and lint commands
browser assertions
runtime logs
deployment checks

Browser-In-The-Loop Development

Software behavior is not limited to source files. Requirements, dashboards, documentation, administration consoles, and the running application may all live in a browser.

Antigravity’s browser agent can:

read documentation and web content
interact with development websites
click, type, and navigate through user flows
capture screenshots
save recordings of browser actions as artifacts

This supports two different jobs.

Browser as a context source

The agent can gather information that is not in the repository, such as:

current API documentation
issue or pull-request context
application dashboards
externally hosted specifications

Access should still be scoped. Giving an agent a browser does not mean it should receive every authenticated session or unrestricted access to every domain.

Browser as a verification surface

After changing a user-facing application, the agent can open the built application and exercise the relevant workflow.

For example:

start the application
open the login page
submit an invalid credential
confirm that the correct error appears
submit a valid credential
confirm the expected redirect
save screenshots or a recording

The recording gives a reviewer useful evidence. A reliable workflow should also use programmatic assertions where possible, because a video does not automatically detect subtle errors.

The browser profile is isolated

The source video described browser access using the same authentication as the user’s normal Chrome session. Current Antigravity documentation describes a different security model.

The browser agent runs in a separate Chrome profile:

normal-profile cookies and sign-ins are not automatically shared
accounts can be signed into inside the isolated profile
those isolated-profile sign-ins may persist for future Antigravity sessions
browser tools can be disabled
URL reading and browser actuation can be controlled separately

Treat the isolated profile as a privileged automation environment. Do not sign it into sensitive systems unless the task requires that access and the permission boundaries are appropriate.

Projects, Conversations, And Workspaces

Antigravity 2.0 groups work into projects rather than assuming one conversation equals one repository.

A project can define:

one or more folders
agent behavior
model preferences
permissions
custom skills, plugins, and MCP servers
local-folder or Git-worktree execution

This is useful when one goal spans several repositories or supporting folders.

Broader access also increases risk. A project should include only the folders and services needed for its work.

Local folder versus worktree

An agent can work in the existing local folder or in an isolated Git worktree.

Use the existing folder when:

one agent owns the task
immediate changes in the current checkout are expected
other processes depend on that working directory

Use a worktree when:

several agents may edit in parallel
the current checkout must remain stable
changes need independent review before integration

A worktree isolates files and branches. It does not automatically resolve architectural conflicts between changes.

Subagents And Background Work

A subagent is a separate agent context assigned a focused part of a larger task.

Antigravity currently supports:

built-in research and browser subagents
clones of the main agent
reusable custom agents defined in Markdown
transient agents created during a task
parallel background execution

The main agent can delegate activities such as:

searching a large codebase
checking current documentation
running a slow build
investigating a separate failure
operating the browser

Subagents start with isolated conversation context. This prevents verbose exploration from automatically filling the parent agent’s context.

They still need a precise contract:

objective
owned files or workspace
allowed tools
required evidence
output format
completion condition

Subagents inherit safety boundaries from their parent. Permission requests can be surfaced to the main interface for human approval.

Parallel execution improves throughput only when tasks are independent. Two agents changing the same interface or schema can create more integration work than they save.

Scheduled Tasks And Hooks

Antigravity 2.0 can schedule prompts to run once or repeatedly.

Possible uses include:

checking a repository for dependency updates
preparing a periodic status report
running a repeated research task
checking an operational dashboard

Scheduled execution makes permissions and output delivery more important. A task running while nobody is watching should have narrower capabilities than an interactive session unless there is a strong operational reason otherwise.

Hooks

Hooks execute local commands at specific points in the agent loop.

Current hook points include:

before a tool call
after a tool call
before model invocation
after invocation
when the loop tries to stop

Hooks can:

enforce a linter before completion
log tool activity
reject unsafe command arguments
inject required instructions
force another verification step

Hooks receive and return JSON. They are deterministic control points around a probabilistic agent, but a poorly written hook can also block work, leak data, or create an execution loop.

Permissions And Sandboxing

Antigravity represents sensitive operations using resources such as:

read_file(path)
write_file(path)
read_url(domain)
execute_url(domain)
command(prefix)
unsandboxed(prefix)
mcp(server/tool)

Rules can place a resource into one of three lists:

Decision	Result
`deny`	Block the operation
`ask`	Pause for human approval
`allow`	Execute without another prompt

Current documentation specifies the precedence:

deny > ask > allow

That means a broad ask rule can still require approval even when a narrower allow rule also matches.

Current defaults

As of July 28, 2026, official documentation says:

file reads and writes inside active project folders are normally allowed
web reading and browser actuation default to asking
commands, MCP calls, browser actions, and non-project files generally ask when not otherwise configured
terminal sandboxing is available in preview on macOS and Linux, with Windows support still described as forthcoming

Verify these defaults in the installed version before relying on them.

Prefer narrow grants

Safer permissions look like:

read_file(src/)
write_file(src/components/)
command(npm run test)
read_url(developers.google.com)
mcp(issue-tracker/read)

Riskier grants look like:

read_file(*)
write_file(*)
command(*)
execute_url(*)
mcp(*)

Approval fatigue is not solved by allowing everything. Improve the policy so routine low-risk operations are scoped precisely while destructive, external, or credential-bearing actions remain blocked or reviewed.

Telemetry And Enterprise Data Boundaries

The individual application includes an Enable Telemetry setting. Current documentation says that when it is enabled, interactions may be collected to evaluate and improve Antigravity and its supporting models.

Check this setting before using proprietary code, customer data, credentials, or regulated information.

Google also offers Antigravity through Gemini Enterprise Agent Platform. The enterprise route uses a Google Cloud project, Google Cloud terms, consumption-based billing, and enterprise controls such as supported deployment regions and VPC Service Controls.

The individual subscription and enterprise Google Cloud offerings should not be assumed to have identical data-handling terms.

Install And Start The CLI

The desktop application and IDE are available from the official download page.

For macOS or Linux, current CLI documentation uses:

curl -fsSL https://antigravity.google/cli/install.sh | bash

For Windows PowerShell:

irm https://antigravity.google/cli/install.ps1 | iex

The installed terminal command is currently:

agy

Run it inside the intended repository:

cd path/to/repository
agy

Then give it an outcome, boundaries, and verification target:

Fix the expired-session redirect.

Preserve behavior for active sessions.
Do not change dependencies or deployment configuration.
Add a regression test.
Run the focused test suite and production build.
Use the browser to verify the visible login flow.
Ask before accessing any domain other than localhost.

Installation commands and binary names can change. Check the current CLI installation documentation before scripting them into machine provisioning.

Build With The Python SDK

The Antigravity SDK provides programmatic access to the same general runtime used by the desktop and CLI surfaces.

Install the current Python package:

pip install google-antigravity

A minimal agent currently looks like:

import asyncio

from google.antigravity import Agent, LocalAgentConfig


async def main():
    config = LocalAgentConfig()

    async with Agent(config) as agent:
        response = await agent.chat(
            "Inspect this repository and list its verification commands."
        )
        print(await response.text())


if __name__ == "__main__":
    asyncio.run(main())

The SDK adds capabilities such as:

built-in file, code-editing, search, and shell tools
custom Python tools
MCP connections
skills
declarative safety policies
lifecycle hooks
stateful conversations
structured outputs
human questions during execution
multimodal attachments
subagents
token-usage metadata

The official SDK repository is Apache 2.0 licensed. The package also depends on a compiled platform-specific runtime, so cloning the repository alone is not equivalent to installing the published wheel.

Local SDK Versus Managed Agent API

The SDK and Gemini API route are not interchangeable.

Question	Local Antigravity SDK	Managed Antigravity agent
Where does it run?	Local runtime on the application host	Remote environment provisioned by Google
How is it invoked?	Python library	Gemini API request
Environment	Local files and tools under configured policy	Isolated ephemeral Linux environment
Best for	Custom local tools, workstation automation, embedded agents	Server-side applications that need a managed execution environment
Main operational concern	Local permissions and process isolation	API billing, data handling, remote state, and service limits

Choose based on execution location, data governance, operational control, and application requirements. The shorter interface is not necessarily the appropriate one.

Current Models

As of July 28, 2026, Google’s model documentation lists these selectable reasoning models for individual plans:

Gemini 3.6 Flash
Gemini 3.5 Flash
Gemini 3.1 Pro
Claude Sonnet 4.6
Claude Opus 4.6
GPT-OSS-120B

The documented enterprise selection is narrower and currently centers on Gemini models. Antigravity also uses additional task-specific models, such as an image-generation model, behind some tools.

The source video discussed Gemini 3 Pro and Nano Banana Pro during the original launch. Those names should not be treated as the current product lineup.

Model availability can vary by plan, capacity, account, and region. Check the current model table.

Current Individual Pricing

Google’s May 19, 2026 plan announcement published the following US prices:

Plan	Published monthly price	Positioning
Individual	`$0`	Basic weekly limits and access to core features
Google AI Pro	`$20`	Higher limits for experimentation and regular use
Google AI Ultra	`$100`	Lighter but regular development usage
Google AI Ultra	`$200`	Highest published individual quota tier

The current quota design uses a shared pool for Gemini models, with consumption weighted using relative API pricing. Non-Gemini models may have separate capacity limits. Optional AI credits can be used as overage after included quota is exhausted.

Do not calculate a fixed number of tasks from these plan names. Agent consumption varies with:

selected model
prompt and repository context
reasoning effort
tool calls
generated output
retries and failed attempts

Prices, taxes, currencies, promotions, available tiers, and quotas vary by location and can change. Verify the current pricing page before purchasing.

Enterprise use is billed through Google Cloud using consumption-based pricing rather than these individual subscription tiers.

Antigravity Compared With Other Coding Agents

Tool	Main interface	Distinguishing focus
Gemini CLI	Terminal	Open-source Gemini-oriented terminal agent and extension ecosystem
Claude Code	Terminal, IDE, web, and SDK surfaces	Anthropic’s coding-agent harness with project instructions, skills, hooks, and subagents
Amp	CLI, web, mobile, IDE connections, and remote execution	Multi-model persistent threads, review workflows, and local or managed execution
Antigravity	Standalone desktop, IDE, CLI, SDK, and managed API	Visual multi-agent supervision, rich artifacts, browser recordings, and a shared Google agent harness

Antigravity CLI versus Gemini CLI

Gemini CLI and Antigravity CLI are separate Google terminal products with different architectures and roles.

Gemini CLI has been an open-source, terminal-centered assistant with its own extension ecosystem. Antigravity CLI is part of the wider Antigravity platform and shares its agent harness, permissions, projects, artifacts, and agent-management concepts.

Google currently provides migration guidance from Gemini CLI to Antigravity CLI. Existing skills and MCP configurations should still be reviewed rather than assumed to transfer without changes.

A Practical Antigravity Workflow

For a user-facing bug:

Create a project containing only the required repository folders.
Choose local-folder or worktree execution based on isolation needs.
Configure file, command, URL, browser, and MCP permissions.
Ask the agent to research the existing behavior.
Review the implementation-plan artifact.
Answer open questions and correct scope before approving edits.
Let the agent implement and run deterministic checks.
Use the browser agent against the built application.
Review the diff, test output, screenshots, and recording.
Inspect the important code directly before committing.

flowchart TD
    S["Scope project and permissions"] --> R["Research current behavior"]
    R --> P["Review implementation plan"]
    P --> A{"Approve?"}
    A -->|"No"| F["Provide artifact feedback"]
    F --> P
    A -->|"Yes"| I["Implement in local folder or worktree"]
    I --> T["Run tests, lint, and build"]
    T --> B["Verify visible behavior in browser"]
    B --> H["Human reviews diff and evidence"]
    H --> C["Commit or request corrections"]

Tradeoffs And Failure Modes

Failure mode	Why it matters	Safer response
Treat every artifact as true	The artifact may repeat the agent’s mistaken assumption	Verify important claims against code and runtime evidence
Give browser access to sensitive accounts	The isolated profile can retain its own authenticated sessions	Use narrow accounts, domain permissions, and task-specific access
Run several agents in one checkout	Edits and commands can interfere	Use worktrees and explicit ownership
Allow every command to avoid prompts	A mistake gains broad machine access	Allow narrow routine commands and ask or deny the rest
Schedule a task with interactive assumptions	Nobody may be present to clarify or approve	Define bounded permissions, failure handling, and output delivery
Load every skill and MCP server	Tool choice and context become noisy	Enable only relevant extensions
Depend on a current model name	Models and quotas change quickly	Record the date and recheck official documentation
Use a recording as the only test	Visual evidence may miss hidden failures	Combine recordings with assertions and logs
Assume the video shows the current product	Antigravity was reorganized after launch	Use the video for design ideas and current docs for product facts

Key Takeaways

Antigravity is a platform around models, not one model.
The current family includes a standalone desktop application, IDE, CLI, SDK, and managed API route.
Artifacts turn long agent activity into plans, diffs, diagrams, images, and recordings that humans can review.
Browser automation adds useful context and verification, but it also adds authentication and permission risk.
Subagents and worktrees help isolate parallel work; they do not remove integration and review costs.
Hooks, schedules, and broad permissions increase autonomy and therefore require stronger guardrails.
The repository, deterministic checks, and observed runtime behavior remain more authoritative than an agent’s explanation.
Product details age quickly. Check official documentation when commands, pricing, quotas, models, or security behavior matter.