A closed tab
Close the browser, sleep the phone, switch apps. The session was never in the tab; it is on the daemon. Reopen and it is mid-render where you left it.
A session is one running agent, or one shell, attached to one working directory, in chat mode or terminal mode. The daemon owns it. Your devices are just windows onto it, which is why you can open and close them at will without ever losing your place.
When you open a session, the daemon spawns the agent or shell inside a pseudo-terminal. In chat mode it parses the output into clean chat events and keeps a history; in terminal mode it streams the raw bytes. Either way the state lives on the daemon, not in the browser tab: the chat history, the scrollback, the cursor, a half-finished TUI, all of it. A device that connects is handed the current state and then the live stream. A device that disconnects changes nothing about the session it was watching.
Run as many sessions as you like, across projects and across machines. The point is that they are genuinely independent processes, not tabs in one program.
claude chat in ~/projects/api
Refactoring an auth flow, churning through files, asking you to approve each command.
shell (terminal) in ~/projects/api
Tailing logs so you can watch what the refactor breaks in real time.
claude chat in ~/sandbox
A throwaway experiment in a different repo entirely, untouched by the other two.
None of these blocks another. Each has its own working directory, its own mode, its own history.
The session list in the UI shows everything the daemon is running, ordered like a messaging app: most recent activity first. Two indicators tell you where the action is. A working glow means the agent is running a turn right now; an accent dot means replies arrived that you have not read yet.
Tap one to attach, tap another to jump over. Switching does not pause, snapshot, or disturb the session you leave; it keeps running exactly as it was. When you come back to it, you see what happened while you were gone, the same as glancing back at a terminal tab you left open.
There is nothing to save and nothing to lose. The session lives on the daemon, so the failure modes that would normally cost you your terminal state simply do not apply.
A closed tab
Close the browser, sleep the phone, switch apps. The session was never in the tab; it is on the daemon. Reopen and it is mid-render where you left it.
A dropped connection
Signal cuts out in a lift or on a train. The encrypted channel reconnects on its own, and the session was running the entire time.
A device switch
Start on your phone on the walk home, finish on your desktop at the desk. Both are paired, both attach to the same live session.
A daemon restart
Restart codeout itself and your sessions come back. A chat session resumes the conversation and replays its history; a terminal session reattaches to the agent, which a small helper kept alive in the background the whole time.
What does end a session is the underlying process actually dying. Reboot the host, or kill the agent process itself, and the work inside goes down with it. Restarting the codeout daemon is survivable; rebooting the machine it runs on is not, because that takes the agent down too. Detaching from a device is always safe. Archiving a chat, or stopping a terminal session, is the clean way to end one on purpose.
Want sessions to come back after a reboot too? Install codeout as a boot service with codeout --install. It returns on the same address and reattaches what it can; the daemon's own lifecycle, not magic, is what brings a session back across a full restart.
Closing a window detaches; it does not stop the agent. Walking away leaves a session running, on purpose, because that is usually what you want. When you do mean to end one, the two modes part ways. A terminal session has no transcript to keep, so ending it works the way it always has: stop it from the session list, the process ends, and the working directory it was holding is freed. A chat session is archived instead.
Archive a chat from the session list and the agent stops cleanly. Unlike killing a session, archiving preserves your entire conversation history, tool calls, thinking traces, and uploaded files 1:1 with zero summarization loss or token spend. Archived chats live in Settings → Archived chats, where you can inspect past work, export logs, or reopen them at any time.
Reopening an archived chat is instantaneous. The daemon spins up a session in the same working directory and seamlessly restores the full historical transcript and attachments. The agent resumes with complete conversation context rather than a degraded summary, so you can continue right where you left off. Reopening moves the session straight back into your active sessions list.