Main area
Agency
ki-werkzeuge

Google Antigravity

Redaktion ·

Antigravity in one sentence — and why it matters to you

Google Antigravity is Google’s attempt to build the development environment around the agent rather than the editor. If you code with AI today, you know the pattern: you type a task into a chat window, the model suggests code, you accept it. Antigravity flips that. You aren’t the one at the wheel pulling suggestions — the agent plans the task, writes code, runs terminal commands, opens a browser to verify, and reports back when it’s done or stuck. You orchestrate instead of typing.

This matters because three of the loudest players in the market — Google, the startup Cursor and Anthropic with Claude Code — are all moving in the same direction: away from the single copilot, toward multiple agents working in parallel on one codebase. If you’re evaluating tools for agentic coding, or you’ve been using the Gemini CLI, Antigravity is unavoidable. This article explains what it is, how it works, what it replaces and where its pitfalls lie.

The facts here reflect the state at Google I/O 2026 (May 19, 2026). The field moves fast — verify versions, limits and pricing on Google’s pages before relying on them in production.

The core idea: agent-first instead of editor-first

Antigravity launched on November 18, 2025, alongside the Gemini 3 model — initially as a standalone desktop app, an agent-first IDE. The difference from a classic editor with an AI plugin is in the name: the editor isn’t the lead character, the agent is.

In a normal IDE the editor is the center, and the AI assistant sits at the margins — an autocompleter, a chat window, an inline suggestion. In Antigravity it’s the other way around. The interface is built to launch agents, watch them, and steer several of them at once. You describe what should happen, and the agent gets it done across editor, terminal and browser.

What an Antigravity agent can do

A single agent is not a one-shot tool. It typically runs through a cycle of several capabilities:

  • Plan — break the task into sub-steps before starting.
  • Write code — create and edit files across multiple spots in the project.
  • Use the terminal — run commands, start tests, install dependencies.
  • Use the browser — verify its own work by opening the running app in a browser and checking the result against the task.

That last capability is the real difference from a pure code-suggestion tool: the agent verifies its own result instead of just producing it and leaving the checking to you.

Multiple agents in parallel

Antigravity is built from the start to run several agents at the same time — not one after another. Multiple agents work asynchronously in different workspaces, each on its sub-task. You launch them, orchestrate them, and watch what they do. This is exactly where the central challenge of agentic coding lives: the question is no longer whether you deploy a swarm of agents, but how you steer it without losing control.

What Antigravity 2.0 adds: from app to suite

At Google I/O 2026 on May 19, 2026, Google unveiled Antigravity 2.0. The core of the announcement is less a single feature than a structural shift: the pure desktop app becomes a platform with three entry points — desktop app, CLI and SDK — plus a server-side execution feature.

1. The revamped desktop app

The new version is a standalone desktop application built entirely around agent orchestration. It puts running multiple agents in parallel front and center. On top of that come dynamic subagents for parallelized workflows, scheduled tasks for background automation, and integrations into the Google ecosystem — Google AI Studio, Android and Firebase. Google also added native voice commands, like those rolled into Gmail and Docs.

2. The CLI — agents in the terminal

The Antigravity CLI targets developers who work terminal-first and don’t need a graphical interface. It’s written in Go and, according to Google, faster and more responsive than its predecessor. It lets you launch agents without opening the editor — a lightweight, high-velocity surface for spinning up new agents.

The CLI is also why Antigravity falls into the coding-CLI category: it brings the agentic logic to where many developers already work — the command line, scriptable and automatable.

3. The SDK — build your own agents

The Antigravity SDK gives you programmatic access to the same agent harness that powers Google’s own products. You can define custom agent behaviors and host them on the infrastructure of your choice. The SDK is optimized for Gemini models.

4. Managed Agents in the Gemini API

There’s also a Managed Agents feature in the Gemini API. With a single API call you can spin up an agent that reasons, uses tools and executes code in an isolated Linux environment. That removes the infrastructure question: you don’t have to operate a sandbox yourself where an agent can run commands safely.

The relationship to Gemini CLI: full replacement

This is the most important point for existing users. The Antigravity CLI doesn’t supplement the old Gemini CLI — it replaces it entirely. Anyone who built workflows on the Gemini CLI has to migrate them.

According to Google’s developer blog, the Gemini CLI and Gemini Code Assist IDE extensions stop serving requests on June 18, 2026 — for Google AI Pro and Ultra as well as for free use via Gemini Code Assist for individuals. It’s not an emergency, but it’s not a free ride either: scripts, CI hooks and familiar commands change.

The strategic logic: Google consolidates its scattered terminal tools under one roof. Instead of a Gemini CLI for plain model calls and a separate Antigravity app for agentic work, there’s now a suite where the CLI is part of the same agent platform as the desktop app and SDK.

Pitfalls and trade-offs

Lock-in only moves up one layer

Antigravity’s bet is model optionality — and it’s only half delivered. Yes, you can run Claude and GPT-OSS inside Google’s own IDE, which is notable: Google sells the platform and the orchestration, not necessarily the model underneath. But anyone using Antigravity ties themselves to Google’s interface, its CLI and its SDK. The lock-in doesn’t disappear, it moves from the model layer to the platform layer.

The rate limits aren’t model-neutral

The generous rate limits apply explicitly to Gemini 3 Pro — not necessarily to the same degree for Claude or GPT-OSS. So the economic incentive to end up running Google’s own model anyway remains. Model agnosticism here is a selling point, not a neutral referee. If model choice is a real criterion for you, test concretely whether the limits for third-party models are practically sufficient.

Agent swarms need supervision

Multiple agents in parallel sounds like speed, but it’s also a control problem. The more agents simultaneously write code, run commands and change files, the harder it gets to trace who did what and why. Orchestration is not a solved problem — it’s the actual work, at Antigravity just as at Cursor and Claude Code.

Comparison: Antigravity vs. Claude Code vs. Codex

All three target agentic coding but set different priorities.

| Feature | Google Antigravity | Claude Code | OpenAI Codex | |---|---|---|---| | Primary surface | Desktop app + CLI + SDK | CLI (terminal-first) | CLI / cloud agent | | Model choice | Gemini, Claude, GPT-OSS | Anthropic models only | OpenAI models only | | Multi-agent parallel | central, in the app | via workflows/subagents | limited | | Server execution | Managed Agents (Gemini API) | via custom setups | cloud sandbox | | Lock-in layer | platform | model + platform | model + platform |

The short version: Anthropic naturally runs only its own models in Claude Code — lock-in at both model and platform layer, but tightly integrated. OpenAI’s Codex thinks heavily from the cloud agent. Google positions Antigravity between the chairs: model-agnostic at the surface, broader with app, CLI and SDK, but with an economic pull back toward Gemini. For a detailed comparison of the agentic coding tools, see the tool comparison.

In practice: when Antigravity makes sense

You’re evaluating agentic coding. The free public preview is free for individuals, usable with a personal Google account, no credit card and no waitlist. The barrier to entry is low — test Antigravity alongside Cursor and Claude Code. Pay less attention to demo speed than to how well you can steer and observe several agents at once.

You need headless/agentic coding in the terminal. The CLI and Managed Agents in the Gemini API are built for scriptable, server-side flows — for example when an agent should run in a CI pipeline or isolated environment without you operating a sandbox yourself.

You’re sitting on the Gemini CLI. Plan the migration. The June 18, 2026 deadline is set and the predecessor is being replaced.

For more quota, you can book the AI Ultra plan at $100 per month, which according to Google offers five times higher AI limits in Antigravity than the Pro plan.

FAQ

What is Google Antigravity?
An agent-first development suite from Google, made up of a desktop app, CLI and SDK. Instead of delivering code suggestions in an editor, it lets agents independently plan, write, execute and verify tasks in the browser — including several in parallel.
Does Antigravity replace the Gemini CLI?
Yes, entirely. The Antigravity CLI replaces the former Gemini CLI. According to Google, the Gemini CLI and Gemini Code Assist IDE extensions stop serving requests on June 18, 2026. Existing workflows must be migrated.
Which models run in Antigravity?
Gemini 3 Pro with generous rate limits, plus full support for Anthropic Claude Sonnet 4.5 and OpenAI GPT-OSS. The generous limits apply mainly to Gemini, though, not necessarily equally to the third-party models.
What does Antigravity cost?
There's a free public preview for individuals with no credit card. For higher limits there's the AI Ultra plan at $100 per month with, according to Google, five times higher Antigravity limits versus the Pro plan.
How does Antigravity differ from Claude Code?
Claude Code is terminal-first and runs only Anthropic models. Antigravity offers a desktop app, CLI and SDK and allows third-party models too. Antigravity's lock-in is more at the platform layer, while Claude Code adds lock-in at the model layer.

Conclusion

Google Antigravity is the attempt to turn agentic coding into a platform — not as a single feature, but as a suite of desktop app, CLI and SDK. The interesting move is model optionality: Google sells orchestration rather than just a model, and explicitly allows Claude and GPT-OSS in its own IDE. The catch: the lock-in only moves up one layer, and the economic incentives keep pulling toward Gemini.

In practice this means: if you’re comparing agentic coding tools, test Antigravity in the free preview alongside Cursor and Claude Code, and check how well agent swarms can actually be steered. And if you’re on the Gemini CLI, don’t postpone the migration — June 18, 2026 comes faster than you think. We track how this develops in the news on Antigravity 2.0.

Themenuebersicht

KI-WerkzeugeCoding-CLI