Antigravity features — the full capability list

Most developer tools solve one problem well. An AI-native browser has to solve several simultaneously: run a real Chromium rendering engine, host a coding agent, coordinate multiple browser windows under a single task plan, record every action for review, and expose a programmable surface for teams that want to extend or automate the whole setup. The Antigravity features list is the full account of how the product meets that brief. This page covers each Antigravity capability in enough depth for you to decide which ones are relevant to your workflow, with jump links below to the dedicated deep-dives.

Agentic browsing

The central Antigravity capability is agentic browsing: the ability to describe a multi-step task in plain language and watch the tool carry it out across real web pages. Unlike a chatbot that describes what you should do, the agent surface inside Antigravity actually drives the browser — it clicks links, fills forms, reads page content, waits for network responses, and adjusts its plan if the page does not match what it expected.

The planning step is explicit. Before the first click, the Antigravity agent produces a numbered task plan listing every URL it intends to visit, every file it will touch, and every command it will run. You review the plan and either approve it, edit individual steps, or reject it and describe a different approach. Nothing executes before approval. Once execution begins, you watch a live output stream showing the agent's current reasoning, and a watch-mode sidebar lets you interject at any point with a correction or a clarification.

The agent handles common patterns natively: OAuth flows, paginated data, search-then-click, form validation loops, file downloads, and multi-site comparisons. For unusual patterns you can drop into manual control at any checkpoint and hand back to the agent once the tricky step is done. See the Antigravity AI agent deep-dive for the full plan-execute-review loop description.

Code intelligence

The Antigravity side-pane editor opens alongside the browsing surface and indexes the current repository on first load. Completions are Gemini-backed and context-aware at the whole-file and whole-repo level — not just the visible lines. The editor handles the full quick-fix loop: it suggests a patch, you approve it, the relevant tests run automatically, and if they pass the patch is staged. If the tests fail, the editor presents the failure output and proposes a revised patch without leaving the side pane.

Language support covers every language Gemini handles, which at the time of writing includes Python, TypeScript, JavaScript, Go, Rust, Java, Kotlin, Swift, C, C++, and Ruby. The Antigravity repo index is incremental, so adding a new file or pulling a branch updates it within seconds rather than triggering a full rescan. See Antigravity code intelligence for the editor surface in detail.

Multi-window orchestration

Antigravity multi-window orchestration is the feature that distinguishes the product most sharply from a chat-based coding assistant. You describe a task — "compare the error rate in this dashboard with the last three commits in this repo" — and the Antigravity agent opens up to four coordinated windows, each pointed at a relevant surface. The agent holds context across all four simultaneously; data it reads in window two informs what it does in window three.

You control the layout. Windows can be arranged as a quad grid, a 60/40 split, or a single focus with three background agents. You can pin any window so the agent cannot close it, resize individual panes, and promote a background window to focus without interrupting the task. The layout persists across restarts, so a grid you set up for on-call triage is ready again when you reopen Antigravity the next morning.

Artifacts runtime

Every agent run produces an artifact: a structured replay bundle that captures the complete execution history. The bundle includes every HTTP request and response, every file the agent wrote or read, every screenshot taken at decision points, every console log emitted during test runs, and a timeline of agent reasoning steps with the inputs and outputs for each step.

Artifacts are reviewable like pull requests. You scrub the timeline, annotate individual steps, flag decisions you want the agent to handle differently next time, and share the full bundle with a colleague or a reviewer. Teams that operate in regulated environments have used artifacts to satisfy audit requirements for AI-assisted changes — the trail is complete by construction, not assembled after the fact. The NIST AI guidance covers policy-level considerations for agentic-tool audit trails.

Open API and SDK

The programmable surface covers three integration points. The REST API exposes run management (start, stop, inspect, replay), artifact retrieval, quota and billing status, and workspace configuration. The SDK lets you register custom tool servers that the agent can call at planning or execution time — structured like MCP-style servers, they appear alongside built-in capabilities and can reach internal services the browser cannot open directly. The CLI wraps the REST API for scripting: you can kick off a full agent run from a terminal, stream the output, and pull the artifact when the run completes.

Custom tools are useful for connecting to internal APIs, private databases, proprietary testing frameworks, and deployment pipelines. Because the tool server runs as a separate process, it can be written in any language that speaks HTTP. The Antigravity API reference has the full endpoint catalogue and tool registration protocol.

Security and isolation

Each agent run executes in a sandboxed browser profile with explicit permissions granted at the start of the run. Cookies and credentials from one run do not leak into another. The offline-first mode restricts network access to a declared allowlist, suitable for runs that touch production credentials or sensitive internal systems. Credential scoping lets you attach a named credential set to a run without exposing the raw secret to the agent's reasoning output.

The sandbox model is per-run rather than per-session, which means the agent cannot carry state from a previous run unless you explicitly share an artifact. Teams that have multiple agents running in parallel — a triage agent, a coding agent, a deployment agent — can be confident the runs cannot interfere with each other at the credential or cookie level. The security model page has the full credential scope reference.

Capability overview

Capability	What it does	Tier availability
Agentic browsing	Plans and executes multi-step tasks across real web pages with human-in-the-loop checkpoints	Free & Paid
Code intelligence editor	Side-pane editor with Gemini autocompletion, whole-repo indexing, and test-aware quick-fix loop	Free & Paid
Multi-window orchestration	Coordinates up to four browser windows under a single agent task context	Free (2 windows) / Paid (4 windows)
Artifacts runtime	Captures full run history as a replay bundle — HTTP, files, screenshots, logs, timeline	Free (7-day retention) / Paid (unlimited)
Open SDK & REST API	Custom tool servers, CLI scripting, run management, artifact retrieval via REST	Free & Paid
Sandboxed security model	Per-run credential isolation, offline-first mode, explicit permission scoping	Free & Paid
Team workspace sharing	Share layouts, artifacts, and agent plans with colleagues; per-team cost attribution	Paid only
Increased agent-run quota	Higher per-day run count, larger context windows, longer run timeouts	Paid only