Google Antigravity /plan: dedicated planning mode before the agent executes

On September 25, 2026 (shown as Sep 26 in some locales), Google's official @antigravity account shipped Antigravity 2.0 planning mode — triggered with /plan. The agent steps back, researches, writes an implementation plan for your review, and asks for approval before it executes on the task. Google explicitly aligned the desktop app with the Antigravity CLI: the same /plan flow, not a CLI-only afterthought.

Demo thread: X video — Antigravity /plan. Product docs: Plan (/plan) on antigravity.google.

If you track Antigravity's command surface — /boost deep reasoning, Teamwork multi-agent campaigns, CLI subagents — /plan is the human-gated front of the pipeline, not the heavy execution lane.

TL;DR

What Google announced

From the @antigravity post (~387K views in public metrics):

1. /plan matches the CLI — planning mode is parity between GUI and terminal, important for teams that script agy in CI or remote dev boxes.
2. Research before diffs — the agent is instructed to think through the task and conduct extensive research (codebase, docs, web — exact tool mix is product-internal, but the user promise is breadth before edits).
3. Implementation plan artifact — output is framed as a plan for your review, not immediate file changes.
4. Explicit approval — execution begins only after you approve — a productized version of human-in-the-loop that harness engineers previously enforced with custom rules.
5. Light planning in normal chat — you can ask for a plan naturally without the slash command for a lighter planning pass.

That fifth point matters for daily driver UX: power users get /plan as a mode switch; everyone else gets soft planning without memorizing commands — similar to how OpenCode documents /plan on other stacks.

Why planning mode is table stakes — and still worth shipping

Agent coding tools in 2025–2026 converged on plan-then-execute because unconstrained tool loops burn tokens, hide intent, and merge unreviewed diffs. Academic and product writeups explainx.ai cites in agent harness DAG design argue full-horizon or upfront planning can match step-by-step accuracy on structured tasks with fewer LLM calls — because the model reasons once instead of re-deriving strategy every tool step.

Antigravity /plan productizes that insight for Google's stack:

User: /plan <task>
        │
        ▼
   Planning mode ON (no silent writes)
        │
        ├── research codebase / docs / web
        ├── decompose work
        └── draft implementation plan
        │
        ▼
   Present plan ──► user approves / edits / rejects
        │
     approved
        │
        ▼
   Execute (normal agent tools)

Compare to /boost's loop-heavy shape from September's deep-reasoning command:

User: /boost <hard task>
        │
        ▼
   Deep pipeline ──► execute ──► verify ──► loop until evidence

/plan optimizes for governance and clarity at task start. /boost optimizes for evidence at task end. Neither replaces the other.

Parity with the Antigravity CLI

Google's emphasis — "just like the Antigravity CLI" — signals how they expect serious users to work:

• Remote SSH / cloud dev sessions often live in the terminal (VS Code remote agent security debates apply here too).
• Scripts and aliases can prepend /plan for risky directories (payments, auth, infra).
• Teams can require plan logs in ticket comments before merge — easier when CLI and IDE share behavior.

If your org already documents harness engineering, add /plan transcripts to the definition of done for P1 changes.

Example prompts (full vs light)

Full mode — /plan

Use when the blast radius is large, the codebase is unfamiliar, or compliance wants a reviewable artifact:

/plan Add OAuth2 login with Google and GitHub. Must not break existing email auth.
List touchpoints, migration steps, test plan, and rollback. Do not edit files until I approve.

Light mode — natural language

Use for medium tasks where you want orientation without a formal mode switch:

Before you change anything: outline how you'd refactor the billing webhook handler
and which tests you'd add. Wait for my OK.

The difference is depth and product enforcement — /plan is Antigravity's harder guarantee that the agent stays in planning until you release it.

Public reaction on X (how to read it)

Replies on the announcement thread clustered into three buckets — none are specs, all affect buyer perception:

When evaluators compare Antigravity to Claude Code, Cursor, or Codex, score /plan + default model together — a great plan with a weak executor still fails integration tests.

Antigravity slash-command map (September 2026)

For Gemini-forward shops also watching Gemini 4 post-training or Antigravity + AlphaGenome skills, /plan is harness maturity on the Google IDE side — orthogonal to which Gemini revision powers the agent.

Security and compliance angle

Planning mode is a control, not security magic:

• Approved plans can still be wrong — approval means you accepted the approach, not that code is safe.
• Research steps may hit the web — treat /plan like any agent with browsing; align with SwarmTraces-style egress lessons if tools fetch untrusted URLs during research.
• Injection via issues/tickets — if research ingests user-provided specs, pair planning with behavior classifiers or manual review on externally authored requirements.

Still, blocking writes until approval reduces drive-by diffs — a common failure mode when developers accept the first patch because the agent "already started."

Replicating the pattern without Antigravity

Teams on self-hosted or multi-vendor stacks can copy the contract:

1. Artifact — Markdown plan with scope, non-goals, files, tests, rollback.
2. Gate — CI or hook rejects agent write tools until plan file is committed and labeled approved.
3. Versioning — plan v2 when scope creeps; never silent drift.
4. Metrics — track plan-to-merge time vs revert rate; cheap plans that prevent one bad merge pay for themselves.

That is the same planner-worker-critic decomposition explainx.ai diagrams in harness budget posts — Antigravity just named and slash-commanded it for Google's agent IDE.

Who benefits most from /plan

Staff engineers and tech leads get a forced articulation step before juniors merge agent output — the plan becomes the teaching artifact ("why this module, why this test shape").

Regulated or customer-facing teams can attach approved plans to change records without screenshotting chat bubbles.

Solo builders still win when returning to a stale branch — the plan is session memory cheaper than re-ingesting fifty tool messages.

Less ideal: one-line typos, config tweaks, and time-critical hotfixes where plan latency exceeds incident clocks — keep /btw-style fast paths for those (per Antigravity's broader command culture in boost coverage).

What to try this week

1. Run /plan on a real ticket you would normally hand to an agent cold — compare files touched and surprises vs yesterday's workflow.
2. Run the same task with natural-language plan only — note whether research depth differs.
3. For one hard bug, sequence /plan then /boost on the riskiest sub-step — document whether approval narrowed boost's search space.
4. Export the plan text into your PR description — make review about the plan and the diff, not mystery meat.

Bottom line

Antigravity 2.0 /plan is Google's explicit plan-then-execute mode: research, implementation plan, your approval, then execution — CLI and IDE aligned. It will not satisfy users who only want stronger default models, but it does give managers and senior engineers a standard checkpoint that matches how many teams wish agents behaved anyway.

Treat /plan as governance UX; treat /boost as evidence UX; treat model choice as the third leg of the stool.

Related reading

• Antigravity /boost deep reasoning
• Antigravity Teamwork multi-agent framework
• Antigravity CLI — subagents and sandbox
• What is harness engineering?
• Agent harness DAG — planner vs loops
• @antigravity — /plan announcement (video)

Feature availability and model defaults may change on antigravity.google — verify before standardizing team process.