Antigravity is Google’s agent-first development platform — a standalone desktop application, a command-line tool, a software development kit, and a managed runtime in the Gemini API — all of it built around the orchestration of AI agents. Antigravity 2.0 launched at Google I/O on May 19, 2026, and it’s the same agent harness that powers Gemini Spark, Google’s consumer-facing 24/7 AI agent.
If you’ve heard “Antigravity” in conversations about Gemini, agent development, or the Google AI stack — this is the developer-side product. It’s where you build agents that do what Spark does (and more), or use agents Google built that compose into your workflows. By June 18, 2026, Antigravity CLI also replaces the older Gemini CLI as Google’s primary command-line AI tool.
What Antigravity actually is, in plain language
The problem Antigravity solves: AI agents are now the dominant way Google’s customers want to use Gemini, but building production-grade agents is hard. You need a model. You need a runtime that handles tool calls, retries, errors, and state. You need a way to define skills the agent can use. You need observability — what did the agent do, when, why. You need a way to ship the agent somewhere users can interact with it.
Before Antigravity, you had to build most of that yourself. The model came from Google; everything else was your engineering. Antigravity is Google’s attempt to ship the whole stack as one product.
The platform has four surfaces:
| Surface | What it is | Who it’s for |
|---|---|---|
| Antigravity 2.0 desktop app | A native app for macOS (and soon Windows) with an agent-first UI. Drag tools into agents, run sessions, see what the agent is doing | Power users and developers who want a graphical UI |
| Antigravity CLI | A Go-based command-line tool that shares the same agent harness as the desktop app | Developers who prefer terminal workflows |
| Antigravity SDK | Programmatic access to the agent harness. Define agents in code, host on your own infrastructure | Developers building agents into their own products |
| Managed Agents (in Gemini API) | Agents hosted by Google, accessible via API, with the full harness | Teams who don’t want to operate infrastructure |
The unifying piece is the agent harness — the runtime layer that handles tool definitions, calls, multi-turn state, error recovery, and the orchestration of multiple sub-agents working on the same task. It’s the same harness Google uses for Gemini Spark and other internal agent products. By shipping it as Antigravity, Google’s giving developers the same infrastructure that powers their own consumer AI.
A common analogy: Antigravity is to Google AI agents what Xcode is to iOS apps. It’s the platform you use to build, debug, and ship agents — desktop UI, CLI, SDK, all coordinated. Without it, you’d be assembling agents from scratch using lower-level pieces. With it, you start from a working harness and customize.
Why Antigravity exists (and what came before)
In 2024-2025, the “build your own AI agent” workflow looked roughly like this:
- Choose a model (Gemini, Claude, GPT)
- Write the orchestration logic yourself (LangChain, LlamaIndex, or hand-rolled)
- Define your tools (MCP, function calling, custom integrations)
- Add memory and state management (whatever you cobbled together)
- Handle errors, retries, multi-turn flows (your code)
- Deploy somewhere (your infra)
This worked for early-adopter developers but didn’t scale to the “every team in the company wants an agent” wave that hit in 2025. The piece everyone got stuck on was the harness — the orchestration layer that turns a model + some tools into a reliable agent.
Google’s first attempt at the developer surface was Gemini CLI, released in 2024 as a command-line interface to Gemini. It was a useful command-line wrapper but not really an agent platform. Anthropic shipped Claude Code in late 2024 and quickly took over the “developer-friendly agent CLI” position. OpenAI shipped Operator and Codex. Google was visibly behind.
Antigravity 1.0 launched in February 2026 as Google’s response: a unified platform with desktop, CLI, SDK, and managed agents. Adoption was modest but growing through Q1. The 2.0 announcement at I/O 2026 was the major push — bringing Gemini 3.5 Flash optimization, a redesigned desktop UI, enterprise features, and the explicit positioning as the agent harness behind Gemini Spark.
The Gemini CLI deprecation in June 2026 consolidates Google’s command-line AI story under Antigravity CLI. Starting June 18, 2026, the legacy Gemini CLI stops serving requests for Google AI Pro and Ultra users; the migration window is open through summer for developers to switch.
How Antigravity works under the hood
The platform is layered:
Layer 1 — Models. Antigravity is co-optimized with Gemini 3.5 Flash. You can use other Gemini models (3.5 Pro, 3.5 Ultra), but Flash is the recommended default for most agent workloads — fast, cost-efficient, optimized for tool use.
Layer 2 — Agent harness. This is the runtime that turns a model into an agent. The harness handles:
- Tool definitions (MCP-compatible)
- Tool calls and responses
- Multi-turn state across the session
- Sub-agent spawning (orchestrating multiple agents on one task)
- Error handling and retries
- Permission management (including AP2 for spending agents)
- Observability and logging
The harness is the same code Google uses to power its own agent products. When Gemini Spark spawns 30+ sub-agents to handle a complex task, that’s the Antigravity harness doing the orchestration.
Layer 3 — Skills (custom). Beyond the built-in tools, you can extend an Antigravity agent with custom skills defined in markdown files. The skills tell the agent what extra capabilities it has, when to invoke them, and what they return. This is the “give your agent a personality and a job” layer.
Layer 4 — Hosting surfaces. Pick one (or more):
- Local desktop app — runs on your machine, with full UI
- CLI — terminal-driven, scriptable
- Self-hosted via SDK — agents in your codebase, your infrastructure
- Google-managed — agents hosted by Google, called via Gemini API
The same agent definition can run on any of the four surfaces. You write the skills once; you ship to whichever surface fits your use case.
Session resume: A signature feature. Each interaction with an Antigravity agent creates an environment that you can resume in follow-up calls with all files and state intact. This lets you build multi-day, multi-session agent workflows that don’t lose context. Resume is what enables Gemini Spark to “watch my inbox for the next two weeks and tell me when something interesting happens” — it’s the harness state-management, not anything inherent to the model.
Multi-agent orchestration: Antigravity supports launching multiple sub-agents in parallel for complex tasks. At I/O, Google showcased Antigravity 2.0 launching 93 separate sub-agents that generated 2.6 billion tokens and completed the core framework of an operating system in roughly 12 hours. That’s not a typical workload, but it shows the harness scales to genuinely large multi-agent work.
What Antigravity looks like in practice (May 2026)
The May 2026 state of the product:
Desktop app (macOS):
- Native macOS application
- Visual interface for designing agents
- Drag-and-drop skill composition
- Real-time view of agent reasoning, tool calls, sub-agent activity
- File system integration (the agent can read your local files with your permission — the same bridge Gemini Spark uses for macOS file access)
- Windows version: announced, no firm date yet
CLI (Go-based, snappy):
- Available globally as of I/O 2026
- Lightweight, terminal-only
- Same agent harness as the desktop
- Orchestrates multiple agents in the background
- Replaces Gemini CLI on June 18, 2026
SDK (Python and Go primary, others coming):
- Defines agents programmatically
- Host on your own infrastructure
- Same harness, same tool ecosystem
- Open templates in Google AI Studio Playground
Managed Agents (Gemini API):
- Agents hosted by Google
- Called via the standard Gemini API
- Same harness, no infrastructure for you
- Enterprise pricing per API call
Pricing as of May 2026:
- Google AI Pro ($19.99/mo): Limited Antigravity access, capped sub-agents
- Google AI Ultra ($100/mo, new entry): Priority Antigravity access, higher concurrency
- Google AI Ultra ($200/mo, top): Maximum sub-agent concurrency
- Gemini Enterprise Agent Platform: Custom pricing for businesses, includes managed-agent hosting and enterprise SSO/audit
Why Antigravity matters for your job (by profession)
The platform is developer-facing, but its consequences land across many work contexts.
If you’re a software developer:
Antigravity is the most relevant tool to evaluate this quarter if your team is building anything agent-shaped. The desktop app is a fast way to prototype agents you can later move to the SDK or Managed Agents. If you’ve been using Gemini CLI, the migration to Antigravity CLI is now mandatory — start the migration before June 18, 2026 (when Gemini CLI stops serving Pro/Ultra requests). The skill: get fluent with the agent harness’s primitives — sub-agents, skills as markdown, session resume — these are the building blocks of every Antigravity agent.
If you’re a data engineer or analytics professional:
Antigravity’s multi-agent orchestration is well-suited to data pipeline work — agents that watch data sources, transform, validate, alert. The skill: think of agents as composable workers in your pipeline rather than as monolithic “do everything” systems. A pipeline of 5 specialized Antigravity agents (each with a tight skill set) is more debuggable and reliable than one agent that tries to do all 5 things.
If you’re an AI builder or ML engineer:
The SDK is the surface you’ll spend the most time in. The harness handles enough boilerplate that you can focus on the model and skill design, not the orchestration code. The skill: learn to write skills as markdown — it’s a different cognitive model than writing code, and it’s the right level for agent capabilities. Markdown skills are easier to review, easier for non-engineers to contribute to, and easier to audit.
If you’re in DevOps or platform engineering:
Hosting Antigravity-SDK agents in your infrastructure is now a common request. The skill: stand up the Antigravity SDK with monitoring (Prometheus, Datadog, etc.) hooked into the agent’s emitted events. The harness emits rich telemetry; turning it into operational dashboards is the table-stakes platform engineering work for the agent era.
If you’re in operations or workflow automation:
Even if you don’t write code, the Antigravity desktop app is useful — you can build prompt-driven workflows by composing skills from a library, no programming required. The skill: think in workflow templates rather than one-off scripts. An Antigravity workflow you build once can run on a schedule, on demand, or in response to events — and it’s portable across surfaces.
If you’re in business operations or IT decision-making:
The procurement question is whether to standardize on Antigravity vs alternatives (Claude Code + custom, OpenAI’s Operator/Codex stack, LangChain + something). The skill: evaluate based on your stack, not on novelty. If your business runs on Google Workspace, Antigravity has the deepest native integrations. If you’re heavy on Microsoft 365 or AWS-native, the calculus changes.
Common misconceptions about Antigravity
Antigravity is not a model. It’s the platform around a model. The model (Gemini 3.5 Flash, primarily) is separate.
Antigravity is not the same as Gemini Spark. Spark is one consumer-facing agent product built ON Antigravity. Antigravity is the platform; Spark is a thing you can ship with it. You can build other agents on Antigravity that look nothing like Spark.
Antigravity is not closed source. Parts of the SDK are open source, and the protocol-level pieces (MCP, AP2) are explicitly open standards. The agent harness’s core implementation is Google’s proprietary code, but extending the platform via the SDK doesn’t require licensing Google source.
Antigravity CLI is not a fork of Gemini CLI. It’s a from-scratch rebuild in Go (Gemini CLI was Node-based). Faster startup, more concurrent agents, different command structure.
Antigravity is not just for developers. The desktop app is genuinely usable by non-engineers — agent composition is drag-and-drop, skills are markdown. The “developers only” framing undersells the breadth of users it’s targeting.
Antigravity doesn’t lock you into Gemini models. While it’s co-optimized with Gemini 3.5 Flash, the SDK supports model adapters for other providers. In practice most users stick with Gemini for the performance match, but you’re not contractually bound.
Limits and risks of Antigravity
Be realistic about the gaps:
Multi-agent orchestration adds complexity. Spawning 30+ sub-agents for a single task creates debug surface area that a simple sequential agent doesn’t have. When something goes wrong, tracing the failure across multiple agents is harder than tracing it in one.
Token costs at scale add up. The 93-sub-agent / 2.6-billion-token demo at I/O was impressive but expensive. Multi-agent workflows can rack up real costs if you’re not careful. Pricing-aware design is now part of agent engineering.
Vendor lock-in is real. Antigravity is a Google product. The MCP and AP2 protocols are open, but the harness itself is Google’s. Switching from Antigravity to another platform requires rewriting the agent harness integration, even if your skills and tool definitions are portable.
The Windows version isn’t ready. macOS-first is fine for many developers but excludes a meaningful fraction of the developer audience. If you’re on Windows, the CLI works but the desktop UI doesn’t.
Documentation maturity is uneven. Antigravity 2.0 launched May 19, 2026 — documentation is being filled in week by week. Expect rough edges and missing examples for the next quarter.
The “agent does everything” framing oversells. Antigravity makes building agents easier; it doesn’t make agents work for problems where agents aren’t the right tool. A simple cron job + a few API calls is still better than an agent for many tasks. Pick the abstraction that fits the problem, not the latest buzzword.
How to start learning Antigravity
Three paths by depth:
Path A — Non-developer user:
- Download the Antigravity 2.0 desktop app (macOS)
- Open one of the agent templates from the Google AI Studio Playground
- Customize the skills (markdown files — readable by anyone)
- Run an agent for a real task in your workflow
Path B — Developer or technical user:
- Install Antigravity CLI (replaces your Gemini CLI installation)
- Read the Antigravity developer documentation
- Build a custom skill (a markdown file describing what the agent can do)
- Wire the skill into an agent and ship it via the CLI to test
Path C — Builder shipping a real product:
- Install the Antigravity SDK (Python or Go)
- Define agents programmatically with your custom skills
- Host on your own infrastructure or use Managed Agents in the Gemini API
- Wire up monitoring (the harness emits rich event streams — capture them)
- Iterate on production-grade error handling, AP2 spending controls (if your agent transacts), and multi-agent orchestration
What’s next for Antigravity
Three trends to watch through the rest of 2026:
1. Cross-vendor harness adoption. Anthropic has Claude Code; OpenAI has Operator/Codex; Google has Antigravity. The interesting question is whether MCP (already adopted everywhere) plus AP2 (in adoption discussions) plus a future common harness protocol could create a “write once, run on any vendor” world. Watch the agent-platform RFCs.
2. Enterprise hardening. Antigravity Enterprise (announced at I/O) is the enterprise version — SSO, audit logs, custom data residency. Expect significant enterprise adoption through Q3-Q4 2026 as larger businesses commit to agent platforms.
3. The “agent app store” pattern. Antigravity’s skill-based composition (markdown skills, drag-drop assembly) is the foundation for a marketplace of pre-built skills users can install. The pieces are there — what’s missing is the curation layer. Likely to land late 2026 or early 2027.
The bottom line
Antigravity is Google’s agent-platform play, launched at I/O 2026 as a unified desktop+CLI+SDK+Managed-Agents stack. It’s the harness behind Gemini Spark and the successor to Gemini CLI. For developers and builders shipping anything agent-shaped, evaluating Antigravity this quarter is the right move. For non-developers, the desktop app is usable enough to be worth a serious look if your work has repetitive operational sliver that an agent could handle.
The Gemini CLI deprecation deadline (June 18, 2026) is the immediate pressure point — if you’ve been on Gemini CLI, the migration to Antigravity CLI is no longer optional.
For most professionals, the right level of Antigravity literacy is: know it exists, know what surface (desktop/CLI/SDK/managed) fits your work, and let the platform’s primitives (agent harness, sub-agents, markdown skills, session resume) shape your mental model of how AI agents actually work in production.
If you want to learn the agent stack with Antigravity as the concrete tool — not just the theory but the actual day-to-day developer practice — these FindSkill courses are the right starting points:
- AI Agents Deep Dive — the architectural literacy course. How agent harnesses work, what MCP does, how to design agents that fail safely. Maps directly to Antigravity’s design.
- Claude Code Mastery — the closest peer product to Antigravity CLI in the broader ecosystem. Worth knowing the alternative even if you commit to Antigravity.
- Agentic AI — the conceptual primer if you’re new to agents and not sure where Antigravity fits in the broader stack.
Sources
- Google blog: I/O 2026 developer highlights — Antigravity, Gemini API, AI Studio
- Google developers blog: All the news from the I/O 2026 developer keynote
- Google developers blog: Transitioning Gemini CLI to Antigravity CLI
- MarkTechPost: Google launches Antigravity 2.0 at I/O 2026
- SiliconANGLE: Google expands Antigravity platform for agent-native software development
- Cybernews: Google pushes “agentic AI” at I/O 2026 with Gemini Omni, Antigravity 2.0
- Google AI Studio (Antigravity templates)
- TechCrunch: Google introduces Gemini Spark with Gmail integration
- Google blog: I/O 2026 — Welcome to the agentic Gemini era
