Google Antigravity is a Google software development platform built around AI agents that can carry out programming tasks across a code editor, terminal, and browser. Introduced in public preview on 18 November 2025 alongside Gemini 3, it combines a conventional integrated development environment with interfaces for delegating work to agents and reviewing their results. Its central distinction is the treatment of agents as participants in a development workflow rather than solely as sources of code suggestions.
Development and design
Antigravity emerged from the expansion of generative AI tools from code completion into multi-step software engineering tasks. Whereas a completion tool proposes text at the cursor, an agent-oriented environment can interpret a task, inspect a project, modify multiple files, run commands, and examine the resulting application.
The editor is based on Visual Studio Code, retaining the familiar structure of a file explorer, editing panes, and development tools. At its public-preview launch, Antigravity was offered for macOS, Microsoft Windows, and Linux.
Antigravity is an application environment, not a standalone large language model. The language model supplies capabilities such as interpreting instructions and generating code; the environment supplies project context, tools, permissions, and interfaces through which model-generated actions can affect a software project.
Editor and agent management
Antigravity provides two complementary ways of working:
- Editor view: a code-focused interface in which a developer can inspect and change source code directly while interacting with an agent.
- Manager surface: an interface for assigning and monitoring agent tasks, including work involving multiple agents or workspaces.
This separation supports both close interaction with an individual coding task and the delegation of longer-running activities. A developer might edit one part of an application while an agent investigates a separate issue or prepares changes elsewhere.
Agents can use a terminal to execute development commands and a web browser to interact with an application. Browser access is important for tasks whose outcomes are not fully represented by source files—for example, checking whether a page renders as intended or whether an interface responds to a sequence of interactions.
Task workflow and artifacts
A typical task begins with a natural-language request, such as implementing a feature, investigating a defect, or adding tests. The agent examines relevant project material, develops an approach, performs actions, and produces material for review. The scope of those actions depends on the available tools and the environment’s approval settings.
Antigravity uses artifacts to communicate work beyond a conversational transcript. These can include implementation plans, task lists, code changes, screenshots, browser recordings, and walkthroughs of completed work. Their purpose is to make an agent’s proposed approach and observable results easier to inspect.
Artifacts also provide a place for feedback. Comments on a plan or result can guide subsequent work without requiring the developer to reconstruct the entire task in a new prompt. This creates a workflow in which delegation, execution, review, and revision are distinct but connected stages.
Artifacts are not equivalent to formal verification. A screenshot demonstrates a particular observed state, and a successful test run demonstrates success under the conditions tested; neither establishes that an implementation is correct in every relevant case.
Uses and limitations
Antigravity is designed for activities such as feature implementation, debugging, project exploration, interface development, and test execution. Combining editing and execution tools allows an agent to investigate problems through feedback rather than generate code in isolation.
Its reliability nevertheless depends on the model, the task specification, the available project context, and the quality of validation. AI hallucinations can appear as nonexistent interfaces, incorrect explanations, or unsupported assumptions about a codebase. An agent can also produce changes that pass existing tests while failing requirements those tests do not cover. Plans and walkthroughs improve visibility but do not independently establish correctness.
Security and control
An agent with terminal and browser access has a different security profile from a text-only coding assistant. Its actions may affect files, execute programs, or interact with network services. Approval policies and execution restrictions therefore influence both how independently it can operate and the consequences of an incorrect action.
A particular concern is prompt injection: instructions embedded in project files, web pages, or other material may attempt to redirect an agent away from the developer’s intended task. The resulting risk depends on the agent’s permissions and access to sensitive resources. Access control, execution isolation, and review mechanisms govern the scope of possible actions, but the presence of such controls does not make generated code or autonomous execution inherently safe.