Hand a tab to another agent

Agents: claude, codex, opencode · On: phone, desktop

Change the agent on a tab and keep the conversation: same tab, same title, same history. The new agent reads a written brief of the transcript with your next message.

Why you would use it

Claude hit a usage limit and you want codex to carry on. Or one agent has been going in circles and you want a second opinion with the same context, in the same tab, without retyping anything. Or the work moved from design to a job of mostly shell commands the other one is better at.

How to use it

Tap the agent button under the composer (#agentpick), the first of the three, right of +. It shows the agent's own mark and name, the same symbol the tab strip, the usage meters and every assistant card use.
The slash panel opens on its Agent slot, listing the agents under Agent for this tab. The agent already running is labelled running this tab now. Any other row reads hand this tab over; it reads the transcript as a brief; tapping it hands the tab over. Either way the panel stays open and moves to the Models slot of the agent now running, with the Effort slider above it, so you can pick the model and effort next. Pick a model, or tap #agentpick again, to close it.

An agent logged out on the tab's computer reads <Agent> · log in: tapping it opens the login in the panel and hands the tab over once you are in. An agent whose CLI is not on that computer reads Install <Agent>, with install it, then hand this tab over under it: tapping it runs the install in the panel, then any login the agent needs, then the handoff. OpenCode has no login here, so it never reads · log in.
Send your next message. The brief goes in front of it, once.

You can also pick a model of another agent straight from the Models slot or from your starred favourites. That hands the tab over and sets the model and effort in one go.

While a turn is running

A handoff picked while the agent works, a compaction included, waits for the turn to end. It runs before anything you queued, so a queued message goes to the agent and model you picked. A toast reads Hands over to Claude after this turn, and the transcript shows hands over to claude on opus after this turn. Pick the running agent again before the turn ends to call it off: handoff to claude called off; codex stays.

Or type /handoff codex. /vendor, /harness and /agent are the same command under other names; use whichever word you reach for. With exactly two agents installed, a bare /vendor picks the other one. With more it is a question rather than a change and toasts the choices, for example vendor: codex or opencode.

What you see

A system card in the transcript: handed off from claude to codex; codex gets a brief of 18 items with your next message. The handoff itself does not toast; a refusal does.

A system card in the transcript reading "handed off from claude to codex; codex gets a brief of 2 items with your next message".

The agent button shows the new agent and its mark. The model and effort pickers reset to auto (a model id belongs to one vendor), so pick new ones if you want something other than the CLI's default. The send mode goes back to Agent, so the composer is back and your next message goes to the agent, not the shell. Replies already in the transcript keep the mark and the name of the agent that wrote them, so you can see who said what.

Button tooltips:

idle: Agent: Claude. Changing it hands this tab over
during a turn: Agent: Claude. Changing it hands this tab over after the running turn

Refusals come back as toasts, in the server's words:

already running codex
claude is still starting; try again in a moment
unsupported agent: <name>

Limits and known gaps

The vendor session does not travel. claude's JSONL and codex's rollout are different formats and neither CLI reads the other's, so the session is dropped the way /clear drops it and the transcript travels as text.
The brief is capped at 24,000 characters, and one message inside it at 4,000. It is built newest-first and then reversed, so the end of the conversation is what survives; anything dropped is counted in a line reading (N earlier items omitted).
The brief carries decisions, not bulk: your messages, the replies, one line per tool call (- tool Bash: npm test) and one per edit (- edited src/a.js (+12/-3)). Tool output is dropped; the new agent can re-run anything it needs. Reasoning, system notes, approvals and subagents are not carried at all, and are not even counted as omitted.
The brief is spent by the next turn. If that send fails, the brief is re-parked so the retry carries it again.
/clear after a handoff discards the parked brief.
The context token count, the plan strip and the subagents strip are cleared with the session. Anything queued behind an agent that failed to start is drained into the new agent.
The agent button is disabled with no tab open and while a handoff is already in flight.
A handoff waiting on a turn also waits for any background subagent of the old agent, which ends with its process.
The list comes from the agents the server advertises, with synthetic entries filtered out, so an agent added or retired server-side needs no change in the UI.