/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.30.2

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.

• **Hand-off (whole task, tests as the gate):** hand one coherent, test-covered task

to agy as a whole with `agy-handoff`, read nothing, verify only by running the tests, hand the diff to a human as a first draft. The only delegation shape measured cheaper than Claude alone on implementation work — see **Hand-off mode** below.

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 (in `~/.claude/settings.json` `pluginConfigs` or env `CLAUDE_PLUGIN_OPTION_*`). The `pro` tier defaults to **Gemini 4 Argon (High)** since 0.29.0 (consumer Google AI plans list Argon instead of 3.1 Pro — as reported in #104, not measured here — and enterprise plans on agy 1.4.x, which were measured, renamed `gemini-3.1-pro-high`'s display name to `Gemini 3.1 Pro` while also serving `Gemini 4 Argon (High)`). When `tier_pro` is unremapped and the active plan does not expose Argon, `agy-delegate` automatically falls back to `Gemini 3.1 Pro` (then `Gemini 3.1 Pro (High)`) and logs `pro fell back to …` on stderr — check `AGY_USAGE.model` for the model that actually ran. The retry fires only on agy's "model not recognized" error, never after a timeout (a timed-out attempt exits 12). That rejection is not instant: measured on agy 1.4.2 (enterprise plan, four runs) it took 5–37 s per attempt, so a plan with none of the three costs up to three such starts — well under one `--print-timeout` each, not three timeouts. 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 >