When any companion proposes an edit, hit open diff → to review the whole file in VS Code's native diff editor, focused on the first changed line, then Allow once / always or Reject. The file is written only after you approve. Completed edits provide an instant one-click revert edit ↶ action synthesized across all five companions.

Connect any of the five companions in Settings → Providers. Antigravity CLI (agy) brings Gemini 2.5/3 Pro & Flash with full streaming reasoning; Grok Build brings Grok 4.7; Codex, Claude Code, and Muse Code run over ACP. Muse adds native approval modes, a shell sandbox, and account usage windows. Change models supported by the current companion; start a new conversation to change companions after a turn.

Tailored, battle-tested integration for Google Antigravity:

• Multimodal Vision & Screenshot Ingestion: Paste or drop images directly into the composer. Images are auto-staged to ~/.gemini/staging and provided to Gemini via native view_file, bypassing stream-JSON limits and search loops.
• Plan Mode Review Workflow: Intercepts implementation_plan.md generation in Plan mode and surfaces the interactive "Approve & implement" review card (x.ai/exit_plan_mode).
• Silent Background Auto-Compaction: Recognizes Antigravity's server-side auto-compaction; the chat composer stays 100% active and unblocked, and the context popover displays an informative auto-managed notice.
• Zero-Flicker Windows Execution: Spawns with windowsHide: true, eliminating black console window flashes.

Click the context donut for exact window usage, input/cache/output tokens, and cost tracking. The interface adapts intelligently to each provider: Grok/Codex/Claude trigger manual compaction, while Gemini automatically displays "Context managed automatically by Antigravity" or "Context probably compacted automatically by now". The /compact slash command is gracefully intercepted for Gemini to prevent wasting prompt tokens.

Switch from the bottom toolbar — even mid-turn, so you can flip to Auto accept to stop approving cards without stopping the agent. Plan mode enforces client-side safety: workspace writes and non-read-only commands are genuinely blocked until you approve the plan.

Settings → Agents & Crew is where roles and crew flows are configured; you no longer have to hand-write YAML for either.

A role is a session recipe — which companion answers, on which model, at which effort, in which mode, and the prose saying when to reach for it. /agent <role> <task> runs one in its own session. The five shipped roles (planner, implementer, reviewer, researcher, fixer) work out of the box; editing one writes a file that takes over from it.

Pointing each role at its own companion is the point rather than a detail: a reviewer on a different model from the implementer is what makes a review worth having, and a review by the same model in the same thread finds nothing while looking like it did. A model the chosen companion does not carry is refused rather than quietly replaced with its default.

A crew flow is how /crew walks a plan: which roles may be assigned and in what order, a command to run after each writing step (a red check splices in a fixer), how often to stop and review, and whether independent steps may run at once in their own worktrees.

Both are stored as plain Markdown files you can read, diff and review — this project (.companions/, versionable and shared with your team) or all projects (~/.companions/, this machine only). A project file wins over an all-projects one of the same name, and the page says which file is actually in force.

Companions: New Worktree Session creates an isolated git worktree under ~/.grok/worktrees/ and opens a fresh session whose cwd is that checkout — so agent edits don't touch your main tree until you Apply worktree. Works for all five companions: a live Grok session uses Grok's worktree RPCs (including clone mode); otherwise the host runs git worktree add itself (linked worktrees only). Apply worktree copies files back with a conflict check — a file you changed in the main checkout since the worktree branched is never overwritten silently.

/crew [flow] walks a step list as a team: each step is a fresh session with a compact briefing, assigned to a role by host rules (you are asked when that is unclear). Sequential is the default; a flow can run independent writers at the same time, each in its own worktree. The Crew panel above the composer shows every step's role, status, duration and cost. Companions: Run Crew is the same action from the Command Palette.

The microphone button dictates speech via Speech-to-Text — words appear live as you talk. Say "companion send" to submit hands-free and keep dictating; messages spoken while the companion responds queue and flush when it finishes.

The active editor rides along automatically; add more by typing @ in the composer, dragging from the Explorer, right-click → Companions: Send File, Alt+G, or the + button. Relative file links in chat automatically resolve across parent directories and nested subprojects (findInSubtree).

Sessions run in parallel: start a new one with + while another is mid-turn and switch between them instantly. Each row's status dot reflects its state (🔵 Blue: working, 🟡 Yellow: waiting for approval, 🟢 Green: finished unread, 🔴 Red: error unread, ⚪ Gray: idle). Sessions persist across restarts, restoring conversation IDs and replaying transcripts.

Messages sent mid-turn queue smoothly at the end of the chat. Hit Steer on a queued message to redirect the companion immediately without losing tool work in flight.

LaTeX in answers — inline \(…\), display \[…\], matrices, integrals — renders as real typeset math via MathJax, bundled offline.

```mermaid blocks render as interactive diagrams matching your VS Code theme.