Skip to main content
Back

Google's Antigravity Turns /btw Into a Full Multi-Turn Conversation Branch

The /btw slash command grows beyond quick side questions, letting you fork a conversation, explore tangents, and promote the ones worth keeping.

  • Antigravity reworked its /btw slash command beyond one-off side questions.
  • You can now fork, explore, and promote side threads without losing your place in the main task.
  • Each /btw still spawns an isolated child conversation with its own ID.
  • Available in both the Antigravity App and the Antigravity CLI.
  • Forks miss the prompt cache, costing roughly 4.9x a normal warm ping per call.
  • Best for exploratory tangents and debugging without polluting the main agent's context.

The team behind Antigravity has expanded its /btw slash command from a single side question into a multi-turn conversation branch. Developers can now explore follow-up questions inside the fork and promote useful work to a full conversation while the primary agent continues its task with an unchanged history.

Side questions can keep growing

The original command created an isolated child conversation, answered one question, and stopped. Each later /btw invocation opened a fresh fork from the main conversation, so it could not see earlier side questions. Continuing a useful tangent required copying the exchange elsewhere or bringing it into the primary thread.

Behavior Earlier version Updated version
Follow-up questions New fork for every question Continue inside the same branch
Main agent Continues its current task Continues its current task
Conversation history Side answer stays isolated Side thread stays isolated
Useful tangents Require manual copying Can become full conversations

The revised workflow has three stages:

  1. Fork: Ask a side question from the current conversation without interrupting the primary agent.
  2. Explore: Continue asking questions within the child thread while preserving its context.
  3. Promote: Turn the branch into a full conversation when the investigation develops into separate work.

Isolation keeps the main task focused

An initial /btw request creates a child conversation with its own ID and injects instructions for handling the side question. The child receives enough context to answer, but its subsequent turns remain outside the primary agent’s history. That separation reduces unrelated context during long agent runs and lets the main task proceed while the branch is active.

The update preserves that architecture while adding continuity. Follow-up questions remain attached to the same child conversation, and promotion preserves the branch as an independent full thread without changing the original task’s trajectory.

Where branches help

  • Testing an alternate approach: Explore another implementation while the main agent continues with the current plan.
  • Investigating an error: Examine a stack trace, dependency, or unfamiliar file in a separate thread.
  • Checking an assumption: Validate an API detail or architectural constraint without adding exploratory turns to the primary history.
  • Starting related work: Promote a quick question when it develops into implementation, research, or debugging of its own.

Forks carry a token cost

Each child conversation has a separate ID, which can prevent it from reusing the primary conversation’s cached input. In one measurement, a /btw request recorded no cache reads and paid for uncached input tokens. It cost about 4.9 times as much as a warm request that reused cached context and roughly 26% more than an ordinary cache miss.

Developers working under weekly quotas should account for that overhead when opening many branches or using them as disposable scratchpads. The feature protects context quality, but frequent forks can consume more tokens than short questions asked in an already warm conversation.

Run it from the app or CLI

The updated command is available in the Google Antigravity App and Antigravity CLI. Enter /btw followed by a question in the prompt box:

/btw Why is this test failing?

Antigravity opens the question in a child conversation while the primary agent keeps working. The interface displays tool calls as the branch runs, supports follow-up questions in that thread, and allows the branch to be promoted when it becomes substantial work. Command details are available in the CLI reference.