When you're going back and forth with an AI on a long task, something else sometimes catches your curiosity. "What was that file called again?", "What was that number just now?" — a question slightly off to the side of the main work.
You can just ask. But once that question and its answer land in the conversation, the flow breaks for a moment and the record grows along with it. The longer the task runs, the more these accumulate and disturb the flow of the main conversation.
/btw is the command for asking such a question without leaving it in the main conversation.
How to use it
At the prompt, type /btw and add your question.
The answer then appears in a small window that pops up and closes. Neither the question nor the answer enters the main conversation.
The question and answer are ephemeral: they appear in a dismissible overlay and never enter the conversation history.
Once you've read the answer, press Space, Enter, or Esc to dismiss it and return to where you were. If the answer is long, scroll with ↑/↓, and if you like it, press c to copy the raw Markdown (dragging with the mouse pulls in the terminal's hard wrapping, so c is cleaner). Earlier questions from the same session stack up dimmed above, and you can step between them with ←/→ (this requires v2.1.187 or later).
It sees the whole conversation, but has no tools
/btw sees the entire conversation so far. You can ask about anything from the session — code Claude has already read, decisions it made earlier, whatever came up.
What it doesn't have is tools. It can't open a new file, run a command, or search.
No tool access: side questions answer only from what is already in context. Claude can't read files, run commands, or search when answering a side question.
The docs put the two together in one sentence.
So the uses split. For asking about what's already known, use /btw; for something it has to go find out, use a subagent.
Slipping one in mid-task
You can run /btw even while Claude is hard at work.
Available while Claude is working: you can run /btw even while Claude is processing a response. The side question runs independently and doesn't interrupt the main turn.
That window answers only once. There's no following up inside it. If you want to dig further, press f to fork the question into a new session (branching off into a new conversation). The new session inherits the parent conversation plus this question and answer as real transcript turns, and from there you have full tool access. The original session stays put under /resume (forking works in local sessions only).
In short, /btw is an entry point for asking once, lightly, then closing; and if it grows from there, you raise it into a new conversation.
Codex has the same /btw
This way of asking off to the side of the main conversation exists in the Codex CLI too. And even the entry name is the same — in Codex, /btw is another name for /side.
But the same name points to a fairly different shape. The Codex docs describe /side as a separate conversation forked from the current one.
Codex opens a side conversation whose transcript is separate from the parent thread. While you are in side mode, the TUI continues to show parent-thread status so you can see whether the main task is still running.
Seeing the conversation so far is something they share. Just as Claude's /btw sees the whole current conversation, Codex's /side inherits the conversation up to that point as it forks off. The split comes after that. Where Claude's /btw is a window that answers once and closes, Codex's /side is a separate conversation you go back and forth in. It doesn't end after one answer — you keep asking inside it, then return to the main conversation.
The biggest split is tool use. Claude's /btw can't use tools. Codex's /side can. It can read files and run commands, too — because /side runs within Codex's current session permission and sandbox settings. That's where it differs from Claude's /btw, which cuts tools off entirely.
| Aspect | Claude Code /btw | Codex /side (a.k.a. /btw) |
|---|---|---|
| Shape | A window that answers once and closes | A separate forked conversation; back and forth, then back to the original |
| Tools | None | Yes |
| Record | Doesn't stay in the conversation history | Doesn't merge into the main conversation (ephemeral) |
| Continuing | f to make a new session (tools from there on) | Already a tool-having conversation — back to the original when done |
| Limits | Making a new session: local sessions only | Not inside another side conversation, or during review mode |
So the two tools solved the same problem differently. Claude split it in two — a light, context-only question and work that holds tools: ask with /btw, and fork with f when you need to dig deeper. Codex merged the two — /side is itself a forked conversation that inherits the main conversation and gets tools as well.
One thing, though, is the same. In both, that quick question doesn't pollute the main conversation's record. With Claude, the answer never enters the record at all; with Codex, the forked conversation's transcript doesn't merge back into the main one ("without disrupting the main thread's transcript," as the docs put it). Keeping the main line clean while you step away for a moment — that's what both tools were after.
Sources
- Anthropic Claude Code: Interactive mode
- Anthropic Claude Code: Commands
- OpenAI Codex: Slash commands
