Google Antigravity's /boost: A Three-Phase Multi-Agent Pipeline for the Bugs That Break Single-Agent Coding

Google’s agent-first IDE just picked up a new gear. The documentation team behind Google Antigravity has published the spec for /boost, a slash command now live in Antigravity 2.0 and the Antigravity CLI that hands your prompt off to a full multi-agent reasoning pipeline — purpose-built for the class of engineering problems where single-shot coding assistants stall out: intermittent race conditions, algorithmic optimization, cross-file refactors, and root-cause hunts through unfamiliar code.

The timing matters. Agentic coding tools have spent the past year in a capabilities race, and the frontier has visibly split. On one side: fast, cheap, single-agent loops that autocomplete features and navigate codebases in seconds. On the other: long-horizon autonomous campaigns that scope a project in an interview phase and grind for days. What has been missing is a productized middle tier — heavy reasoning you can invoke mid-session, on demand, without a setup ritual. That is precisely the gap /boost targets.

What /boost actually does

According to the official documentation, invoking /boost activates “an on-demand multi-agent reasoning pipeline designed for challenging software engineering tasks.” The command decouples strategy formulation from isolated execution and verification, running a three-phase pipeline:

Phase 1 — Goal & strategy formulation. A Primary Orchestrator receives your prompt, inspects workspace context, and formulates an execution strategy. It breaks the engineering challenge into discrete, verifiable subtasks and determines which specialized workstreams are needed.

Phase 2 — Parallel execution & verification. The orchestrator dispatches subtasks to specialized subagents running in clean, isolated scopes. The docs split these into three kinds of workstream: implementation workers that construct candidate code solutions, apply refactoring, and generate unit tests; investigation workers that perform root-cause debugging, trace execution call graphs, and analyze unfamiliar dependencies without modifying files; and local verification workers that execute build targets and test suites to validate hypotheses before reporting results.

Phase 3 — Synthesis & delivery. Before anything ships to your chat, the orchestrator aggregates findings and runs regression checks: the combined solution is validated against full test suites and edge cases. If an assertion fails, error diagnostics are fed back into the next iteration for automated correction. Only once all tests and requirements pass does the pipeline deliver a concise summary with verified changes.

The workspace model is the quietly important detail. Where Antigravity’s default agent works in your shared working tree, /boost subagents run in ephemeral isolated Git worktrees — experiments branch off, get verified, and are either synthesized back or discarded, without polluting your files or your main chat context with verbose debug logs and scratch diffs.

How it slots into Antigravity’s three modes

Google now explicitly frames Antigravity as having three execution modes, and the comparison table in the docs is worth reading closely:

Dimension	Default Agent	/boost	/teamwork-preview
Primary focus	Full-spectrum interactive coding	Deep reasoning and tricky bugs	Autonomous multi-day agent teams
Task horizon	Seconds to minutes	Seconds to hours	Hours to days
Plan tier	All plans	Paid plans	Paid plans
Scoping phase	Single prompt	Immediate execution	Two-phase scoping interview
Architecture	Single-agent direct loop	3-phase reasoning hierarchy	Multi-role agent teams
Workspace model	Shared working tree	Ephemeral isolated worktrees	Persistent worktrees per milestone
Verification	Single-pass tool check	Multi-round independent verification	Adversarial falsification and audit

Note what /boost does not have: a scoping interview. /teamwork-preview starts with a two-phase scoping conversation before agents deploy; /boost jumps straight into execution. The design bet is that by the time you’re typing /boost, you already know what’s broken — you just don’t want to be the one to grind through the trace analysis.

Where Google says it helps

The documentation names four canonical use cases, each with a sample invocation:

1. Concurrency and race conditions — reproducing intermittent deadlocks in things like connection pools, where reproduction requires careful trace analysis and isolated verification: /boost Reproduce and fix the intermittent deadlock in the connection pool during high connection turnover.
2. Algorithmic problem solving — lock-free data structures, custom graph traversals, SIMD-vectorized routines with rigorous boundary testing: /boost Optimize the matrix transposition algorithm to use SIMD vectorization and benchmark throughput.
3. Non-trivial refactoring — tightly coupled modules, legacy interface modernization, synchronous-to-async API migration across multiple files.
4. Deep root-cause investigation — tracing execution paths across large unfamiliar codebases without modifying code: /boost Trace why HTTP request timeouts spike when batch payload size exceeds 2MB, without modifying code.

Safety, permissions, and price

Boost respects all standard Antigravity security policies. Subagents inherit the file access rules and command permission policies configured for your workspace, and when a worker proposes a protected terminal command or an edit outside trusted scopes, the authorization prompt surfaces in your interface for confirmation.

The pricing story is straightforward but not free: /boost is available on paid plans across Antigravity 2.0 and the Antigravity CLI — per the subagents documentation, Google One AI Premium Pro and Ultra tiers and Enterprise plans. There is no separate per-call price, but the token spend is meaningfully higher than a default agent turn, since you are paying for orchestration plus multiple subagents plus verification rounds.

The bigger picture

Antigravity itself is Google’s bet on agent-first development, with Gemini 3 Pro as its main reasoning engine and other frontier models exposed through Vertex AI. /boost is best read as a productized version of a pattern power users have been hand-rolling for months: split a hard problem into pieces, run parallel exploration and implementation, verify against tests, iterate on failure. Making that a single slash command lowers the bar for reaching for deep reasoning when you actually need it — instead of burning tokens on it for every trivial task.

It also continues a broader industry consolidation around the orchestrator-worker pattern. Anthropic’s Claude Code subagents, OpenAI’s agent teams, and now Google’s boost pipeline all converge on the same architecture: a planning layer, isolated execution workers, and verification loops. What differs is the packaging — and Google’s packaging choice here, a zero-ceremony slash command wedged between the default loop and multi-day team campaigns, is among the most usable interpretations yet.

The open question is verification honesty. Multi-round independent verification only helps if the tests are meaningful, and every vendor’s agent benchmarks show verification loops that pass suites while missing the bug. Google’s decision to make failed assertions feed back into automated correction — rather than surfacing them for human triage — is efficient, but it shifts even more of the review burden onto the test suite itself. Teams adopting /boost for concurrency bugs would be wise to invest in the stress tests first.