Google Antigravity Works Like an Engineering Team, Not an Engineer

Most AI coding tools are still built around a single agent doing all the work. That design has a ceiling, and complex tasks are where you find it. Google Antigravity is built differently: it works the way a well-run engineering team works, not the way a single engineer works. That distinction is the whole product.

What Google Antigravity Actually Is

Antigravity launched in November 2025 as an agent-first development platform. It’s built on Gemini 3.7 Flash, which was co-optimized with the Antigravity harness. It’s not a wrapper around a model API. The harness and the model are tuned together.

The platform has four components. Two are enterprise-ready today under Google Cloud Terms of Service (ToS): Antigravity 2.0, a standalone desktop application for orchestrating and monitoring agents, and the Antigravity CLI, a terminal-native interface using the same agent harness. Two are still maturing on the enterprise side: the Antigravity SDK, which gives developers programmatic access to build custom agents, and the Antigravity IDE, a full agentic development environment built on a modified VS Code. The IDE currently runs under consumer ToS.

The default model is now Gemini 3.7 Flash, Google’s most capable workhorse model for coding and agents. Released August 13, 2026, it delivers substantial improvements over its predecessor across every benchmark that matters for agentic work:

  • DeepSWE v1.1 at 65.3% (up from 49.0% on 3.6 Flash, and well ahead of Claude Sonnet 5’s 54.0%): end-to-end software issue resolution
  • FrontierCode 1.1 Main at 43.6% (up from 34.4% on 3.6 Flash): complex production-ready code generation
  • WebDev Arena at 1588 Elo (up from 1538 on 3.6 Flash): functional UI and web application generation
  • AutomationBench at 30.4% (up from 17.0% on 3.6 Flash): nearly doubling on multi-step real-world business workflows
  • GDP.pdf at 34.0% (up from 22.0% on 3.6 Flash): reasoning over complex, lengthy documents

Gemini 3.7 Flash is available at an introductory price of $0.75/1M input tokens and $3.75/1M output tokens, half the original cost of 3.6 Flash. It’s a dramatic capability jump at a lower price point, which means you can stay in your development flow all day without worrying about breaking the budget.

How the Agent Architecture Works

When you give Antigravity a complex task, the main agent doesn’t try to do everything itself like other coding harnesses do. It decomposes the goal and delegates subtasks to subagents. Each subagent spins up with its own clean context window, isolated from the parent. This is everything because this way, the parent’s context doesn’t get polluted by the details of the subtasks. The best part: these subagents run concurrently, not serially, and when a subagent finishes, it returns a synthesized result to the parent.

This matters because model performance wanes as the context window gets crowded. A single agent working through a long, complex task accumulates noise. The more it does, the more signal gets buried. Antigravity’s architecture solves this by keeping each agent’s context specific to the task (or subtask). The orchestrator or “parent” maintains clean context and organizes subagent work in the context of its goals (which may have been delegated from the main agent).

Subagents can inherit its parent’s workspace, branch into an isolated Git worktree, or share a directory. Antigravity handles worktree creation and cleanup automatically. There are built-in subagent roles out of the box:

  • A research agent for codebase exploration
  • A browser agent for interactive testing
  • A self agent that’s a clone of the calling agent

You can also define custom subagents in markdown files, specifying the model tier, allowed tools, MCP server details, and command execution policy per agent.

Subagents are asynchronous. Long-running operations offload to a background process so they don’t block the main agent’s loop. The main agent can invoke multiple subagents and immediately continue other work while they run. Subagent states cycle through Running, Idle, and Killed. An idle subagent retains its full context and re-awakens automatically when it receives a new message. Agents can communicate with each other by conversation ID. Nesting goes up to 10 levels deep, with hard enforcement to prevent runaway recursion.

Permissions flow downward. Subagents inherit the parent’s tool scopes, allowed command prefixes, and file access boundaries. They can’t exceed those bounds. If a subagent needs user authorization for something outside its scope, the request surfaces up to the main UI automatically.

Easy and intuitive!

Two Ways You Should Use It Now

Antigravity 2.0 is the visual orchestration surface. You define a goal, set a project context with scoped permissions, and watch the agent work. Projects control what the agent has access to and what actions it’s allowed to take, which matters when you’re running agents against production data or sensitive repos. Scheduled Tasks let you set cron schedules for prompts you want agents to run periodically without manual invocation: daily PR digests, hourly deployment checks, weekly architecture reports. Voice input is built in via Gemini Audio models, with live transcription that converts rambling speech (we all do it!) into clearly phrased text before sending.

The Antigravity CLI brings the same agent harness to the terminal. It’s faster and lower-overhead than 2.0, and it supports Application Default Credentials for headless and CI environments. If your team already works in the terminal, the CLI is where they’ll live. Custom slash commands let you encode team playbooks as executable commands that register natively in the workspace.

How It’s Different From the Rest

The honest comparison isn’t about features. It’s about how these tools are fundamentally designed to work.

GitHub Copilot and Cursor are context-aware autocomplete tools with agent modes bolted on. They assist a developer who is still doing the work. Antigravity is designed to do the work. You give it a goal, and it builds a plan, delegates to specialized subagents, executes, tests, and delivers you the results.

Honestly, Antigravity should be understood as a different product category.

Claude Code is the closest architectural peer. It’s a genuine terminal-native agentic coding tool, not a glorified autocomplete layer, and it deserves credit for that. But the comparison is still instructive. Claude Code runs as a single agent in a single context window. On a complex, multi-file task, that context accumulates noise. A Claude Code session working through a large codebase refactor is accumulating context with every step. By the time it’s deep into the task, the context window is massive and its reasoning quality has degraded because the relevant signal is buried. It’s inevitable, and when the models on which Claude Code depends are as pricey as those from Anthropic, it’s expensive too.

Antigravity’s architecture sidesteps this trap by isolating each subtask in its own context and using far less expensive, yet extremely capable models. Claude Sonnet 5, the model powering Claude Code today, costs $2.00/1M input tokens and $10.00/1M output tokens. Gemini 3.7 Flash runs at $0.75/1M input and $3.75/1M output. That’s roughly 3x cheaper, and it scores higher on DeepSWE v1.1 (65.3% vs. 54.0%), the benchmark built specifically around real software engineering tasks.

Also, with Antigravity via Gemini Enterprise Agent Platform, every session runs under Google Cloud ToS. Your prompts, responses, code, and telemetry stay in your private GCP project, VPC Service Controls apply, and IAM controls manage access. The Agent Gateway enforces network policies and protects against prompt injection.

And then there’s the entitlement. If your organization has Gemini Enterprise Standard or Plus, generous entitlements to Antigravity 2.0 and the CLI are already included. You don’t need a separate vendor relationship, a separate contract, or separate billing.

The On-Ramp to Agent Platform

Antigravity is the lowest-friction path to building governed, production-grade agents on Gemini Enterprise Agent Platform.

When you build agents with Antigravity and Agents CLI on the Gemini Enterprise Agent Platform, you inherit the full platform stack automatically. Agent Identity assigns a unique digital ID to every agent, enforcing least-privilege access. IT teams get a central catalog in the Agent Registry to curate and distribute approved agents across the organization. Network policies, data access rules, and security guardrails are enforced at the infrastructure level by the Agent Gateway. The MCP Store extends what your agents can reach. Pre-built connectors are available for AlloyDB, BigQuery, Spanner, Cloud SQL, and Looker. Your agents can query and act on live operational data without custom integration work. Deployments to Agent Runtime, Cloud Run, or GKE are simple using natural language prompts. The path from “agent that works in Antigravity” to “governed agent running in production” is shorter than on any other platform, and it’s not a close call.

Antigravity is where you build agents and Agent Platform is where you run them. Simple. If your organization has Gemini Enterprise, you already have Antigravity. The question is whether your engineering teams know it.

You know what to do.

Want to Go Deeper?