Google Antigravity 2.0 SDK: Build Custom Agents on Your Own Infrastructure

When Google shipped the original Antigravity in 2025, it was a competitive response to Cursor: an AI-first IDE running on Gemini, aimed squarely at the developer audience that had already moved away from VS Code. It was good enough, but it lived entirely inside Google's desktop client. You couldn't build on top of it. Antigravity 2.0, launched at Google I/O on May 19, changes that completely. There is now a public SDK, a CLI called agy, and a Managed Agents API in the Gemini platform that runs full agent workloads in isolated Linux environments on demand. The platform is open to developers in a way the first version never was.

What changed at I/O 2026

Antigravity 1.0 was a desktop IDE. Antigravity 2.0 is an agent platform that happens to ship a desktop IDE alongside it. The distinction matters because it changes what you can build.

In the 1.0 era, agents lived inside the Antigravity desktop application. If you wanted automation, you drove it from the GUI. Programmatic access meant using the underlying Gemini API directly, which had no awareness of the Antigravity agent harness — you were wiring tools by hand. The 2.0 announcement at I/O collapses that gap. Three new surfaces ship together:

• Antigravity SDK — programmatic access to the same agent harness powering Google's own products. Define custom agent behaviors in code, deploy to any infrastructure.
• agy CLI — a lightweight terminal client for developers who live in the shell. Replaces the legacy Gemini CLI.
• Managed Agents API — a single Gemini API call that spins up an isolated Linux environment, gives the agent tool access, and returns a completed result. No infra to manage.

The SDK: your agents, your infrastructure

The Antigravity SDK gives you "programmatic access to the same agent harness powering Google's products." That phrasing is doing a lot of work: it means the SDK is not a thin wrapper around the Gemini completions API. It exposes the orchestration layer — the part that manages tool calls, state, multi-turn sessions, and subagent dispatch.

Custom agents are defined in code and can be deployed to your own infrastructure or managed on Google Cloud via the Enterprise Agent Platform. The key design decision here is that Google doesn't require you to host agents in their cloud. You can run the SDK on-premises, in your own Kubernetes cluster, or anywhere else you control. That's a direct answer to the enterprise objection that killed several cloud-AI products in 2024.

# Code Review Agent

You are a TypeScript code-review agent for this repository.
Your job is to review pull request diffs for correctness, type safety,
and performance. Never suggest style changes unless a lint rule is violated.

## Tools you may use
- read_file: read any file in the project tree
- list_files: enumerate paths matching a glob
- bash: run read-only shell commands (grep, find, wc)

## Output format
Return a JSON object:
{
  "summary": "one-sentence verdict",
  "findings": [{ "file": "...", "line": N, "severity": "error|warn|info", "message": "..." }],
  "approved": true | false
}

The SDK also ships custom agent templates in Google AI Studio — you can scaffold a working project from the browser and export it for local development. For teams that want a faster start, that removes the blank-slate problem.

agy: the new terminal-first CLI

Google is asking everyone to migrate off the Gemini CLI to agy. The new CLI is written in Go (unlike the Python-based Gemini CLI), which means a single static binary, faster startup, and no Python environment to manage. Installation is one command:

# macOS / Linux
curl -fsSL https://antigravity.google/cli/install.sh | bash

# Windows PowerShell
irm https://antigravity.google/cli/install.ps1 | iex

# Verify
agy --version

On first launch, agy opens a browser tab for Google OAuth. After that, authentication is handled silently via a local credential file, consistent with how gcloud works. The core interaction loop is intentionally minimal:

# Start an interactive agent session in the current project
agy run

# Run a one-shot task (non-interactive)
agy run --task "Find all TODO comments and create a GitHub issue for each"

# Create a new agent project with a starter AGENTS.md
agy init my-agent-project

# Check current quota usage
agy usage

# List installed skills
agy skills list

Multi-agent orchestration

The most technically interesting part of 2.0 is not the CLI or the SDK individually — it's that both surfaces now expose the same orchestration primitives. You can define dynamic subagents in an AGENTS.md file and the platform dispatches them in parallel without you writing a scheduler.

Three orchestration patterns ship in 2.0:

• Dynamic subagents — the parent agent spawns child agents on the fly, each with its own tool set and context window. Results flow back to the parent for synthesis.
• Scheduled background tasks — you can register a task that runs on a cron-like schedule against your codebase or external data sources. No server required; Google manages the execution environment.
• Managed Agents API — a single Gemini API call that provisions an isolated Linux VM, runs the agent with full tool access, and streams the result back. Ideal for CI/CD integration where you need a clean environment per run.

import google.generativeai as genai

client = genai.Client()

# Single API call: provisions an isolated Linux environment,
# reasons across tools, returns a completed result.
response = client.agents.run(
    model="gemini-3.5-flash",
    instructions_file="AGENTS.md",
    task="Audit the src/ directory for unused exports and output a JSON report",
    tools=["read_file", "list_files", "bash"],
)

print(response.output)   # structured JSON from the agent

MCP and ecosystem integrations

Antigravity 2.0 speaks MCP natively. Any MCP server you've already wired up for Claude Code or Cursor can be connected to an Antigravity agent with a single config entry. This matters because the MCP ecosystem now has 9,400+ servers — databases, SaaS APIs, internal tooling. Google isn't asking you to rebuild that surface area; it just plugs into what already exists.

mcp_servers:
  - name: filesystem
    command: npx
    args: ["@modelcontextprotocol/server-filesystem", "./src"]
  - name: github
    command: npx
    args: ["@modelcontextprotocol/server-github"]
    env:
      GITHUB_TOKEN: $GITHUB_TOKEN
  - name: postgres
    command: npx
    args: ["@modelcontextprotocol/server-postgres", "$DATABASE_URL"]

Beyond MCP, first-party integrations land with 2.0: Google AI Studio (export a project to local development in one click), Android Studio (Antigravity agents can read and modify Android project files natively), and Firebase (the agent can read Firestore schemas, Cloud Functions, and hosting config without any setup).

Getting started in five minutes

Here's the fastest path from zero to a running custom agent. This covers the CLI workflow; if you need the programmatic SDK, substitute the Managed Agents API call shown above after step 3.

# 1. Install agy and authenticate
curl -fsSL https://antigravity.google/cli/install.sh | bash
agy auth login

# 2. Scaffold a new agent project
agy init code-audit-agent
cd code-audit-agent

# 3. Edit AGENTS.md — describe what your agent does and which tools it has
#    (see example above)

# 4. Add any skills from skills-hub.ai
npx @skills-hub-ai/cli install code-review
# Skill installed to .agents/skills/code-review.md

# 5. Run it
agy run --task "Audit src/ for security issues and output findings.json"

The agy init scaffold drops an AGENTS.md, a .agents/config.yaml, and a .gitignore that excludes credential files. It does not touch your existing source code.

For teams migrating from Claude Code's .claude/agents/ format: the agent definition file structure is similar enough that most SKILL.md files work without modification. The frontmatter key differences are that Antigravity uses tools: (not tools_allowed:) and the model: field defaults to gemini-3.5-flash. Skills from skills-hub.ai/antigravity-skills are already normalized for the 2.0 format.

Plans and pricing

Google simplified the pricing at I/O. There are now four tiers, and the previous $250/mo premium plan is gone:

Pay-as-you-go is also available at $25 credit packs ($0.01 per unit), which makes Antigravity viable for sporadic CI/CD use without a monthly commitment. The Managed Agents API consumes credits from your plan balance regardless of which tier you're on.

The $2 million Build with Gemini XPRIZE hackathon is running concurrently with the launch, accepting submissions through the summer. If you're building something novel with the SDK, it's worth entering — the prize pool is the largest Google has offered for a developer tools competition.

The full announcement is on the Google I/O developer highlights page, and the TechCrunch writeup covers the desktop app angle in more depth. For the SDK reference, start with agy init — the scaffold drops a README.md that links to the full API docs.

Browse skills that work with Antigravity 2.0 at skills-hub.ai/antigravity-skills, or see how it stacks up against Claude Code in the Claude Code vs Antigravity 2.0 comparison.