Where BoB Talks to You

Six surfaces, one run. In BoB in One Day you did everything in one terminal. BoB can reach you in five other places too. This tutorial tries each one once, on the same hello-bob project, then gives you a table to pick one by situation. Every command below comes from The Surfaces BoB Talks On, which also explains why each surface carries what it does.

← Tutorials · docs home

What you will do

You start one run and keep it going for the whole tutorial. You watch it from each surface in turn, and answer one real question from your phone:

Stop	Surface	You will
1	Terminal	Start Claude with a level and a kit, and see both applied
2	tmux	Start a run you can walk away from, attach, and detach without killing it
3	Desktop app	Open a session in the app and pick it up again
4	Telegram	Turn the bridge on and answer the run’s question from your phone
5	claude.ai / Claude iOS	Drive a session from the phone app
6	iBoB	Open BoB’s fleet view on the phone

Allow about an hour. Most of it is the run working while you move between surfaces.

Before you start

Finish BoB in One Day first. This tutorial reuses its hello-bob project.
A Mac with iTerm2 and the Claude desktop app for Stops 2 and 3. On Linux, Stop 2 works in any terminal (a plain tmux attach), and Stop 3 is skipped.
Your phone, with Telegram and the Claude app installed and signed in, for Stops 4 to 6.
The Telegram bridge configured for this machine: bob notify in Stop 4 tells you if it is not.
One approved requirement in hello-bob. Open Claude Code there, file a small one with /requirement (for example “The greeting includes today’s date”), say yes when it asks whether to approve it, and /exit.

Stop 1. The terminal

The terminal is where every other surface starts. Open a new shell and run:

cd ~/projects/hello-bob
claude -a2 --kit review

/automation

bob provision overlay status
bob provision overlay restore

The first two lines start Claude Code at Level 2 with the review kit. Inside the session, run /automation, then /exit. Back in the shell, run the last two lines.

What you should see.

Before Claude starts, two lines: BoB: Setting automation level 2... and BoB: Applying kit review....
/automation reports Level 2 as the active level.
bob provision overlay status names the active overlay as kit review and lists its items. restore removes it, and a second status reports no overlay.

What just happened. claude here is BoB’s shell wrapper, not the bare Claude Code binary. It reads -a2, -rdb and --kit, applies each one and prints a BoB: line before Claude Code starts. The level and RDB stay set for the project after you exit. The kit stays until you restore it.

Checkpoint. You can say which of the three flags lasts after /exit, and which one you had to undo.

Stop 2. tmux

A run in a plain terminal ends when you close the terminal. Start one in tmux instead:

bob warp start --level 2 --rdb --session hello-bob-run
tmux ls
bob warp attach hello-bob --cc

tmux detach-client -s hello-bob-run
bob warp status

Run the first block. When the iTerm2 window opens, watch the run for a minute. Then run the second block from another shell.

What you should see.

bob warp start runs the preflight, then prints the session name hello-bob-run, its tmux -CC attach line and the viz URL.
tmux ls lists hello-bob-run.
bob warp attach opens a new iTerm2 window in control mode. The run’s window is a native tab, and Claude Code is working in it.
tmux detach-client closes that window. bob warp status still shows the run in progress.

What just happened. The run lives in the tmux session, not in the window. Attaching and detaching only changes whether you are looking at it. Never close the iTerm2 tab to leave: in control mode, closing a tab kills that tmux window, and the run with it. Detach instead, with tmux detach-client or Esc in the control-mode gateway window. The run was started at Level 2 with --rdb, so its end-of-requirement question will go to Telegram in Stop 4.

Checkpoint. tmux ls still lists hello-bob-run after you detached.

Stop 3. The desktop app

Skip this stop on Linux. On the Mac, in a shell:

cd ~/projects/hello-bob
claude --desktop

/what-next

claude --desktop --continue

The first two lines open the Claude desktop app on a new hello-bob session. Run /what-next in the app, then close its window. Run the last line to bring the same session back.

What you should see.

The desktop app opens with a Claude Code session in the hello-bob folder.
/what-next lists the run’s requirement as in progress, with rendered links.
claude --desktop --continue reopens the app on the same conversation, with /what-next and its answer still in it.

What just happened. Here the app ran Claude Code on your Mac, against a folder on your Mac, with the same ~/.claude as the terminal. So BoB’s commands work the same. Two limits follow from that. The app lists only the sessions it started, so a run that lives in tmux is not in its sidebar (a project that lives only on farm-01 is reached by adding an SSH connection in the app’s environment menu). And the shell wrapper’s flags do not apply, so use /automation and /rdb inside the app instead.

Checkpoint. You reopened the session with its history intact.

Stop 4. Telegram

The run from Stop 2 will ask one question at the end of its requirement. First, check the bridge from a new Claude session in hello-bob, then from a plain shell:

/rdb status
/rdb on

bob notify "hello from BoB"

The first two lines go inside Claude Code; /exit afterwards. The last line runs in a shell. Then put the laptop down and wait for the run’s question.

What you should see.

/rdb status reports whether RDB is on for this project. bob warp start --rdb already turned it on, so it reads enabled.
/rdb on sends a test message, RDB enabled — you'll receive decisions here, to Telegram.
bob notify puts hello from BoB in the same Telegram chat. If the bridge is not configured, it prints the message instead, says so, and exits 3.
A few minutes later, Telegram shows phase notices from the run, then the question Continue to next task?. Reply no. The run ends, and Telegram shows its session ending notice.

What just happened. With RDB on, the session sends every decision through ask_remote instead of the terminal prompt, and waits for your reply. bob notify is the shell’s way into the same chat, used by the farm and by scripts with no session. You answered a real decision without going back to the desk.

Checkpoint. tmux ls no longer lists hello-bob-run, and bob warp status says there is no active run.

Stop 5. claude.ai and the Claude iOS app

Remote Control lets you drive a whole session from the phone. In a shell:

cd ~/projects/hello-bob
claude -a2 --remote-control hello-bob

Run bob warp status and tell me the phase in one line.

Run the shell lines. On your phone, open the Claude app, go to Code, and open the session named hello-bob. Type the prompt line there. Then /exit the session on the laptop.

What you should see.

The terminal shows the session running, with Remote Control enabled.
On the phone, the hello-bob session is listed. It shows the same conversation.
Your prompt appears in the terminal too, and the answer (the phase, or “no active run”) appears in both places.
After /exit on the laptop, the phone shows the session as disconnected.

What just happened. The session runs on the laptop. The phone is a second window onto it, not a copy. So a remote session is only as available as the machine that runs it. Unlike Telegram, Remote Control carries the whole conversation, but only for a session that has it on.

Checkpoint. You sent one prompt from the phone and read the answer on both screens.

Stop 6. iBoB

iBoB, BoB’s own phone surface, comes in two parts. Its terminal kit is shipped: Run BoB from Your iPhone takes a phone with nothing installed to a live warp run on farm-01. Its web app is not shipped yet. Until it is, the phone’s view of BoB is the fleet view on the tailnet. In a shell:

bob viz --tailnet

Open the printed MagicDNS URL on your phone, which must be on the same tailnet.

What you should see. One tile per project on every fleet machine, hello-bob among them, with its last run. Tap the tile to open its warp viz card.

What just happened. bob viz reads the same fleet feed as the desktop view and fits a phone screen. When iBoB ships, it adds actions to this view, and this stop becomes its tutorial.

Checkpoint. You found hello-bob on the phone.

Which surface, when

You have now used every surface once. Next time, start from where you will be, not from the task:

Your situation	Surface	Start it with	What reaches you there
At the desk and watching	Terminal (or the desktop app on a Mac)	`claude -a2`	Everything: each decision, each permission prompt, the diffs as they happen
At the desk, working on something else	tmux	`bob warp start --level 3`	Nothing interrupts you. The run asks in its own window, and a push reaches the Claude app only when it stops for you
Away for an hour	tmux, with Telegram	`bob warp start --level 3 --rdb`	Every decision in Telegram, a notice per phase, and the push when it stops for you
Away for a day	tmux on farm-01, with Telegram	`bob warp start --flightplan <N> --level 3 --rdb`	Telegram notices, and a todo for anything only you can do. Next morning, read it with `/status`
On the phone only	claude.ai / Claude iOS	`claude -a2 --remote-control <name>`	The whole conversation, typed and read from the phone
Several loops at once	tmux, one window per loop	`bob fork fork --from-issues 3`	Each loop in its own iTerm2 tab, and all of them on `bob viz`

Decide before you walk away. --rdb and --remote-control are set when a session starts, and you cannot reach a session from the phone if it was not started with one of them. A run you want to outlive its window always goes in tmux, whichever surface you then watch it from.

Checkpoint. Pick the row for tomorrow afternoon, and say the command you will run before you leave.

What reaches each surface

Stop 4 showed that a decision moved to Telegram once RDB was on. The full routing is fixed:

Message	Sent by	Reaches
A decision, RDB off	`AskUserQuestion` in the session	The session’s own window: terminal, tmux, desktop app, or Remote Control
A decision, RDB on	`ask_remote` in the session	Telegram only. The session waits for your reply there
A phase notice	`notify_remote` in the session, RDB on	Telegram
A notice with no session	`bob notify` from a shell (the farm’s tick, `bob brief --send`, a release)	Telegram, or printed to the shell with exit 3 when no bridge is configured
“BoB needs you”	the handoff record, when a run stops for you	A push through the Claude app from a session, or through `bob notify` from a shell, plus the banner on `bob viz` and `bob warp viz`

Two things follow. A decision goes to one place only. With RDB on, the terminal does not ask it as well, so someone at the desk cannot answer it there. And some things never leave the machine: the output of commands you run in your own shell, and the transcript and permission prompts of a session that does not have Remote Control on.

When it breaks

Telegram is silent. In Claude Code, then in a shell:

/rdb status
/mcp

bob notify "bridge test"

/rdb status must read enabled, and /mcp must list remote-decision-bridge as connected. If RDB is on but the server is missing, the session has no ask_remote, so restart Claude after /rdb on. If bob notify exits 3 and says the bridge is not configured, this machine has no BRIDGE_WORKER_URL and BRIDGE_SECRET, in the environment or in .mcp.json. Add them there, then restart Claude.

The tmux session is gone.

tmux ls
bob warp status
bob warp start --level 2 --rdb --session hello-bob-run

If tmux ls no longer lists the run but bob warp status still shows a phase, the session was killed while the run was in flight: a closed control-mode tab, or a reboot. The run’s state is still on disk, so start it again with the same flags (the third line). The new session resumes from the phase it had reached. Next time, detach instead of closing the tab.

The desktop app does not see the project.

ls ~/projects/hello-bob
bob doctor

A Local session only opens folders on the Mac the app runs on. If ls finds nothing, the project lives on another machine: reach it with tmux over SSH, with Remote Control on in a session on that machine, or with an SSH connection added in the app’s environment menu. If the folder is there but BoB’s commands are missing in the app, bob doctor on the Mac tells you whether ~/.claude is deployed.

Remote Control disconnected. The session stopped on its machine: the laptop slept, the process exited, or the network dropped. Run the remote session inside tmux on a machine that stays awake, so it outlives your terminal:

tmux new -s hello-bob-rc -d 'cd ~/projects/hello-bob && claude --remote-control hello-bob'
tmux ls

tmux ls lists hello-bob-rc, and the session reappears in the Claude app. Stop it with tmux kill-session -t hello-bob-rc when you are done.

Where you are now

You started one run, watched it from a tmux window, a desktop app and a phone, and answered its question from Telegram. You know what each surface is for, which one fits the situation you are in, what reaches you there, and what to check when it goes quiet.

Where to go next

The Surfaces BoB Talks On: why each surface carries what it does.
Warp Drive from the Command Line: the whole shell lifecycle of a run started with bob warp start.
tmux cheatsheet: every key binding, including the ones for panes and copy mode.

Next tutorial: Watching BoB Work — Watch one live run from every layer: the run itself, the project around it, the machine under it and the fleet it belongs to, and learn which view answers which question.