Google Antigravity
YouTube ... Quora ...Google search ...Google News ...Bing News
- Gemini Notebook ... Google AI Studio ... Google Antigravity
- Google AI Studio homepage
- Conversational AI ... ChatGPT | OpenAI ... Gemini | Google ... Claude | Anthropic ... Bing/Copilot | Microsoft ... Siri | Apple ... Meta ... Perplexity ... You ... phind ... Grok | xAI ... Groq ... Ernie | Baidu ... DeepSeek ... Alibaba
- End-to-End Speech ... Synthesize Speech ... Speech Recognition ... Music
- Video/Image ... Vision ... Enhancement ... Fake ... Reconstruction ... Colorize ... Occlusions ... Predict image ... Image/Video Transfer Learning ... Art ... Photography
```wikitext Template:Short description Template:Infobox software
Google Antigravity is Google's "agent-first" platform for building software. Instead of an AI that only suggests the next line of code, Antigravity lets you hand whole tasks to AI agents that can plan the work, edit files, run commands in a terminal, test the result in a browser, and then show you proof of what they did.
The product was announced on 18 November 2025 alongside Gemini 3. At Google I/O on 19 May 2026 it was expanded into Antigravity 2.0: a standalone desktop app for managing agents, plus the Antigravity IDE, a command-line tool (agy), and a Python SDK that all share the same agent "harness."<ref name="overview">Antigravity 2.0 Overview, Google Antigravity Docs.</ref>
Contents
Introduction for New Users
The short version
Think of a traditional code editor as a very good set of power tools. You still do every cut yourself; the tools just make each cut faster.
Antigravity is more like running a small construction crew. You describe the job ("add a login page with tests"). A crew member (an agent) writes up a plan, you approve it, they do the work, and when they're done they hand you a walkthrough with photos (screenshots and browser recordings) so you can inspect the result without watching every hammer swing. You can run several crews on different jobs at once and check in on them whenever you like.
You're still the one in charge. You just spend more time reviewing and directing, and less time typing.
What you actually get
- Antigravity 2.0 (desktop app) – the "command center" where you launch, monitor, and coordinate agents. Google describes it as a standalone app that works independently of an IDE.<ref name="overview" />
- Antigravity IDE – a full code editor with AI tab-completion, inline commands, and an agent side panel, for when you want to work hands-on.
- Antigravity CLI (
agy) – the same agent in your terminal. It replaced Gemini CLI, whose consumer access ended on 18 June 2026. - Antigravity SDK – a Python library (
google-antigravity) for building your own agents on the same harness.<ref name="bwg">Build with Google, Google Antigravity Docs.</ref> - IDE extensions – official plugins bringing Antigravity agents into Visual Studio Code, Visual Studio, JetBrains IDEs, Zed, and Xcode.
- Getting Started guide – installation and first project.
- Getting Started with Google Antigravity – Google Codelab with step-by-step exercises.
- Artifacts documentation
- Changelog – check this for the latest models and features.
Getting started in five minutes
- Download the app for your OS from antigravity.google/download.
- Sign in with a Google account. A free tier is available; Google AI Pro and Ultra subscriptions raise usage limits.
- Open an existing project folder or create a new one.
- Give an agent a task in plain English, e.g. "Build a responsive landing page and add tests for the signup form."
- Review the Implementation Plan it produces, leave comments if needed, then let it run.
Technical Architecture
The agent-first idea
Most AI coding tools embed an assistant inside an editor. Antigravity flips that: the agent is the center, and the editor, terminal, and browser are tools the agent uses. In Google's launch post, the Manager surface "flips the paradigm of agents being embedded within surfaces to one where the surfaces are embedded into the agent."<ref name="launch">Introducing Google Antigravity, Google Antigravity Blog.</ref>
A single agent can:
- read and write files in your workspace,
- run shell commands (build, install, test, start a dev server),
- search the web,
- drive a Chrome browser to click through and verify a running app,
- call external tools through Skills and MCP servers,
- spawn subagents to handle pieces of a larger job,
- produce Artifacts that document its plan and results.<ref name="overview" />
Editor view
The Editor view is the "hands-on" mode. It looks and feels like a modern code editor:
- Tab completion – multi-line AI autocomplete as you type.
- Inline commands – highlight code and describe a change in natural language.
- Agent side panel – a full agent you can chat with while you keep coding.
Use it when you want to stay close to the code: small fixes, careful refactors, or reviewing what an agent changed.
Manager view (Agent Manager)
The Manager view is "mission control." Rather than one chat window, you see a dashboard of agents, each tied to a workspace and a task, with its status, its Artifacts, and any actions waiting for your approval.
Key ideas:
- Parallel work – run several agents at once across different workspaces (for example, one fixing a bug, one writing tests, one researching a library).
- Asynchronous by design – agents keep working while you do something else; an inbox notifies you when they need input or finish.
- Fast hand-offs – Google deliberately kept Manager and Editor as separate views optimized for switching quickly between them, instead of cramming both into one window.<ref name="launch" /> In the original IDE the toggle is
Cmd+E/Ctrl+E.
In Antigravity 2.0, the Manager experience grew into the standalone desktop app described above.
Execution modes and safety controls
| Control | What it does | When to use it |
|---|---|---|
| Planning mode | Agent researches and writes an Implementation Plan before touching code | New features, unfamiliar codebases, anything risky |
| Fast / direct execution | Agent acts immediately on simple requests | Small, well-understood edits |
| Permissions | Decide which actions (commands, file writes, browsing) need your approval | Always review these on a new project |
| Terminal sandbox | Runs agent shell commands in a restricted environment | When agents run commands you haven't vetted |
| Browser allowlist / denylist | Limits which sites the agent's browser may visit | Protecting internal or sensitive sites |
Extending agents
- Agent Skills – packaged instructions and scripts that teach agents a domain (e.g. Firebase, Android). Skills replaced the older "Workflows" feature.
- Rules /
AGENTS.md– project-level instructions such as coding standards and conventions. - MCP (Model Context Protocol) – connect agents to external systems like databases and APIs.
- Custom subagents, lifecycle hooks, and sidecars – advanced controls for shaping how agents run.
- Plugins – bundles of the above.
Technologies Implemented
Supported reasoning models
You choose the model from a drop-down under the prompt box. The choice "sticks" for the rest of the agent's current turn even if you change it mid-run. Official availability as of September 2026:<ref name="models">Models, Google Antigravity Docs.</ref>
| Model | Provider | Free & AI Plus | AI Pro | AI Ultra | Enterprise |
|---|---|---|---|---|---|
| Gemini 3.8 Flash (Low / Medium / High) | ✔ | ✔ | ✔ | ✔ | |
| Gemini 3.7 Flash | ✔ | ✔ | ✔ | ✔ | |
| Gemini 3.6 Flash | ✔ | ✔ | ✔ | ✔ | |
| Gemini 3.1 Pro (Low / High) | ✔ | ✔ | ✔ | ✔ | |
| Claude Sonnet 4.6 (Thinking) | Anthropic | ✔ | ✔ | ✔ | ✘ |
| Claude Opus 4.6 (Thinking) | Anthropic | ✔ | ✔ | ✔ | ✘ |
| GPT-OSS-120B | OpenAI (open weights) | ✔ | ✔ | ✔ | ✘ |
A note on history: At launch in November 2025 the headline model was Gemini 3 Pro. It has since been superseded in Antigravity by Gemini 3.1 Pro and the newer Gemini Flash releases, so tutorials that mention Gemini 3 Pro are describing an earlier version.
Antigravity also uses models you can't select directly. For example, Nano Banana 2 powers the image tool that agents use to create UI mockups, placeholder images, and architecture diagrams.<ref name="models" />
Core platform
- Antigravity IDE – built on a heavily modified fork of Visual Studio Code, which is why it can import your VS Code (or Cursor) settings, themes, and keybindings. Some commentators note it may descend from Windsurf, itself a VS Code fork; Google has not framed it that way.
- Antigravity 2.0 – marketed as a standalone agent app rather than an editor. It is a separate install from the Antigravity IDE.
- Antigravity CLI (
agy) – rewritten in Go and positioned as the successor to Gemini CLI. - Antigravity SDK – Python (
google-antigravity), with support for custom tools, MCP servers, safety policies, subagents, structured output, and lifecycle hooks.<ref name="bwg" />
Ecosystem Fit
Google Cloud and Google developer platforms
Antigravity 2.0 ships "Build with Google" bundles, curated sets of Skills, MCP servers, and editor extensions you can switch on during onboarding or later under Settings → Customizations → Build with Google Plugins.<ref name="bwg" /> Highlights include:
- Data Agent Kit Starter Pack – skills for BigQuery SQL and ML, dbt, Apache Spark, Dataflow, Cloud Spanner, and BigLake, plus Google Cloud data MCP servers for inspecting databases, running queries, and debugging failed pipeline jobs.
- Firebase – agents can set up services, manage Authentication users, deploy Security Rules, and work with live Firestore data. There is also an official migration path from Firebase Studio.
- Android CLI, Dart & Flutter, Chrome DevTools, and Google Maps Platform bundles.
- Enterprise tier – available for organizations, with a narrower model list (Gemini models only) per the models table above.
- Managed Agents in the Gemini API – announced alongside 2.0, letting developers start hosted agents with an API call.
Your local machine
Antigravity runs as a native desktop app on Windows, macOS, and Linux. Agents work directly on your local files and use your local terminal and toolchain, so if your project builds with npm, pip, gradle, or make, the agent uses the same commands you would. Because that's powerful, the permission system, terminal sandbox, and browser allowlists matter. Some users also run the agent's Chrome instance with a separate profile to keep it away from their personal logins.
Existing tools
- Other editors – If you don't want to switch editors, official extensions bring Antigravity agents into VS Code, Visual Studio, JetBrains, Zed, and Xcode.
- Terminal and CI – The
agyCLI supports a headless mode, useful for scripts and automation pipelines. - Any service with an MCP server – issue trackers, databases, internal APIs, and third-party platforms can be plugged in as tools.
- Game engines and others – community packages exist (e.g. a Unity external-editor integration), though these aren't maintained by Google.
Examples & Artifacts
Why Artifacts exist
Handing work to an agent requires trust, and reading hundreds of raw tool calls ("ran command…", "edited file…", "ran command…") is tedious and easy to skim past. Antigravity's answer is Artifacts: human-readable deliverables that show what the agent understood, what it did, and how it verified the result.<ref name="devblog">Build with Google Antigravity, our new agentic development platform, Google Developers Blog, 20 November 2025.</ref>
You can comment directly on an Artifact, much like commenting on a shared document, and the agent folds your feedback into its work without starting over.
Types of Artifacts
| Artifact | When it appears | What it's for |
|---|---|---|
| Task list | Throughout the run | A live checklist of the steps the agent is working through |
| Implementation Plan | After research, before coding | Lets you catch a wrong approach before any code is written |
| Walkthrough | At completion | Summary of what changed, why, and how it was tested |
| Screenshots | During UI work | Visual proof of what the app looks like now |
| Browser recordings | During verification | A replay of the agent clicking through the app to test it |
Example 1: UI change with visual proof
Prompt: "Make the pricing page cards stack vertically on mobile and fix the misaligned 'Buy' button."
- The agent inspects the CSS and components and writes an Implementation Plan.
- You approve it (or comment: "keep the desktop layout unchanged").
- The agent edits the styles, starts the dev server, opens the page in Chrome at a mobile width, and captures screenshots.
- It finishes with a Walkthrough linking the diff and before/after images.
Instead of scrolling a log, you check two screenshots and a short diff.
Example 2: Background bug fix
Prompt (in Manager view): "Reproduce issue #412 (checkout fails with an empty cart), write a failing test, then fix it."
The agent runs in its own workspace while you keep working in the Editor. When you check back, the task list shows each step done, and the Walkthrough includes the new test, the fix, and the passing test output.
Example 3: Parallel agents
Launch three agents at once: one refactors an authentication module, one generates tests for a billing API, and one researches a charting library and writes up options. Each produces its own Artifacts, so you review three focused summaries rather than three streams of tool output.
Example 4: Data pipeline on Google Cloud
With the Data Agent Kit enabled: "Ingest the raw CSVs from our Cloud Storage bucket, clean them through bronze/silver/gold layers with dbt, and load the result into BigQuery." The agent scaffolds the pipeline, runs queries through the Google Cloud data MCP servers, and reports back with a plan and walkthrough.<ref name="bwg" />
Tips for good results
- Start in Planning mode until you trust how the agent approaches your codebase.
- Put your conventions in an
AGENTS.mdfile so every agent follows them. - Keep human code review mandatory, and treat Artifacts as the start of review, not a replacement for it.
- Restrict destructive shell commands unless a task truly needs them.
Recommended Viewing
| Video | Date | Stated length | Summary |
|---|---|---|---|
| Google Antigravity FULL COURSE 4 HOURS (Build & Automate Anything) | Jan 2026 | ~4 hours (per title) | A long-form course covering building and automating projects with the original Antigravity IDE. Best for learners who want an exhaustive, hands-on walkthrough. Predates 2.0. |
| Google Antigravity Full Course (2026) – From Beginner to Pro in 1 Hour | Apr 2026 | ~1 hour (per title) | A structured beginner-to-advanced tour of the IDE's core features. Good middle ground between quick overviews and multi-hour courses. Predates 2.0. |
| Google Antigravity 2.0 Tutorial for Beginners: Learn 90% of Antigravity in Under 25 Minutes | Jun 2026 | Under 25 min (per title) — verify it meets the 20-minute minimum | One of the few beginner tutorials made after the 2.0 launch, so it reflects the current standalone app. |
| Vibe once, run anywhere with Google Antigravity and Flutter (Google I/O 2026) | May 2026 | Not stated — verify | An official Google I/O talk, embedded in Flutter's documentation, showing Antigravity building cross-platform Flutter apps. |
Excluded: several popular tutorials were left out because their titles state runtimes under 20 minutes (for example, "From Beginner to Expert in 14 Minutes" and "Learn 90% of Google Antigravity in Under 20 Minutes").
```
