/antigravity

name: antigravity
description: Run the Antigravity CLI (Gemini) as a collaborating AI inside Claude Code, with intelligent model routing across the software development lifecycle. Claude is the conductor/orchestrator — requirements, architecture, the hard 20%, verification, and review — and routes deterministic, high-volume work (scaffolding, boilerplate, test generation, first-pass review, migrations, web/Vertex AI Search) to Antigravity (Gemini), the cheaper, faster model. Use when the user wants to "use Antigravity / agy", "vibe code / agentic engineering", "accelerate the SDLC", "delegate to Gemini", "scaffold / generate tests / migrate", "first-pass code review", "search web or internal/company data", "deep research / multi-source research report", "second-model cross-check", or "lower token cost on a big job". Claude always verifies Antigravity's output and re-checks itself if unsatisfied.
version: 0.27.4

Antigravity for Claude Code — hybrid SDLC

Run the **Antigravity CLI (`agy`, Gemini)** as a second AI working alongside Claude Code. The organizing idea is **intelligent model routing across the SDLC**: keep judgement-heavy work on Claude (the frontier model) and route deterministic, high-volume work to Antigravity (cheaper, faster Gemini). Two AIs, one workflow.

• **Claude = conductor / orchestrator** — requirements, architecture, the hard 20%

(edge cases, integration, correctness), specs, tests/evals, final review.

• **Antigravity = delegated agent** — a full terminal agent (file edits, terminal,

subagents, MCP, web/Vertex AI Search) that executes well-specified work.

This is **agentic engineering, not vibe coding**: the value is the structure around the model — routing, shared rules, verification gates — not raw generation. *Generation is solved; verification, judgement, and direction are the craft.*

Two modes (pick per task)

• **Conductor (sync, inline):** you're shaping something in real time; delegate a

small, well-scoped chunk to agy mid-flow (e.g. "generate these tests"), use the result immediately.

• **Orchestrator (async, multi-unit):** decompose a larger task into units, dispatch

to agy (often with `--dir`, agentic, in parallel), then review and integrate. Best for migrations, bulk implementation against patterns, test suites.

Division of labor across the SDLC

Route each phase to the right model. This is the core policy.

| SDLC phase | Owner | Why | |---|---|---| | Requirements & planning | **Claude** | ambiguity, human-paced judgement | | Design & architecture | **Claude** | trade-offs; most human-centric | | Implementation — complex / architecture-bearing (the 20%) | **Claude** | correctness, deep context | | Implementation — scaffolding / boilerplate / well-specified | **agy** | deterministic, high volume | | Test & eval generation | **agy** (Claude defines the contract) | cheaper-model territory | | First-pass code review | **agy** → **Claude** final | AI as first-pass reviewer | | Cross-model verification (output + trajectory) | **both** | two model families ≠ same failure | | Maintenance / migration / modernization | **agy** executes, **Claude** directs | tedious, systematic | | Web / Vertex AI Search | **agy** → **Claude** re-checks | tools Claude lacks natively | | Audio / video understanding | **agy** transcribes + digests · **Claude** verifies | Gemini is natively multimodal; no local ffmpeg/speech stack | | Deep research (multi-source) | **agy** fans out search/fetch · **Claude** plans, verifies ≥2 sources, synthesizes | offload bulky pages to cheap Gemini; frontier model judges |

Routing tier within agy: `flash` (default, bulk) · `flash-lo` (cheapest, trivial) · `pro` (harder reasoning / reviews / cross-checks).

**agy is multi-model.** Tiers map to Gemini by default, but you can point delegation at any model `agy models` lists (Claude / GPT on plans that expose them) — via `--model <exact name>`, or persistently with the `default_model` / `tier_*` plugin options. Keep the executor a *different, cheaper* model than the Claude conductor: that's what yields the cost saving **and** the cross-model verification value (Claude executing Claude loses both).

> **Model availability moves fast, and `--tier` needs agy ≥ 1.1.10.** Until 1.1.10, agy > **ignored `--model` and `--effort` in headless `-p`** — the flag was applied after model > configuration had initialised, so the run silently fell back to the persisted default. > This wrapper resolves every `--tier` to `--model` and always runs `-p`, so on an older > agy **tier selection does nothing and looks like it works**: the call succeeds, returns > sensible text, reports usage. `doctor` warns when it sees one — and on agy ≥ 1.1.11 it > stops inferring and **asks**: it requests a tier model via `-p /model` (a read-only slash > command that costs no tokens and starts no agent turn) and reports which model agy says > it would actually run. Below 1.1.11 it does not probe, because there the slash command > falls through as prompt text and the model answers as though it had run. > > The `flash` tiers default to **Gemini 3.8 Flash (High)** / **(Low)** since 0.26.0 > (3.7 from 0.24.0, 3.5 before). 3.8, 3.7 and 3.6 carry identical list prices — > $0.75 in / $3.75 out / $0.075 cached-in per 1M — under a promotion that **ends > 2026-12-31** and then settles at $1.50 / $7.50 / $0.15; 3.5 is $1.50 / $9.00 / > $0.15 throughout. Two sources, checked 2026-09-03. Price a run with > `prices.json`'s `gemini_flash`, which mirrors whatever the flash tier resolves to; > `agy-cost-compare` picks that key by tier NAME, not by model. > > **The move is justified on currency at an unchanged list price, not on quality** — > no comparison has been run between these models on a build where `--model` > actually applies, and an identical per-token price is not an identical per-task > cost (thinking bills as output; read the `AGY_USAGE` line). Measured quirk: under > `--digest`, a prompt with nothing to inspect