Watch it work

A real session on film — the machine and the phone at the same moment, and every command in its own recording.

Every recording on this page was made against a real agent, a real multiplexer and — in the third — a real Claude Code. Each is one take, and nothing is a mock-up.

Where a scene shows two of them, they are not two performances: st gives every client its own view of one session, so the terminal and the phone are watching the same shell at the same moment. The terminal is an asciinema recording, which is text you can select; the phone is a video.

Start sharing

st prints a link and a QR code and gives the prompt back. The session it starts belongs to the multiplexer, not to st, which is why it outlives every connection to it — including this one.

Nothing was installed on the phone. The address is the agent's own, and the ?k= on the end of it is the token that opens the terminal once, after which a cookie keeps it open.

Put an agent on it

The point of a terminal on a phone is not to type into it. It is to reach what is already running on the machine — and to start something that will keep running when the phone goes back in a pocket.

Two things in that recording need the key bar. The trust question is a list that is answered with ↑ and Enter, and leaving Claude Code afterwards takes Esc. A phone keyboard has neither key.

More than one agent in a session

Claude Code's agent teams can put each teammate in its own tmux pane, which is worth knowing here because the pane is what st watches. Teams are experimental and off by default:

export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1
claude --teammate-mode auto

auto uses split panes when you are already inside tmux, and stays in one terminal when you are not — so inside a session st is sharing, you get a pane per teammate.

What that means for st:

• Each teammate is its own agent. They run as separate Claude Code processes in separate panes, so st ls counts them in AGENTS and the apps list them separately.
• Subagents are not the same thing. A subagent runs inside one session and appears in Claude Code's own panel below the prompt, not in a pane of its own, so st sees one agent with subagents running inside it.
• Both fold away when they are done. In the browser's windows sheet and the apps' window lists, an agent's subagents and a lead's teammates sit under a header, Subagents · 2 running, 5 done, that is open while one runs and closed when none does. Finished ones go into a Completed group at the bottom, closed until you open it, newest first. What you open or close stays that way while the tab (or the app) is open.
• A team can leave a tmux session behind. Claude Code's own documentation says one can persist after the session ends; it will show in st ls like any other. tmux kill-session -t <name> removes it.

The keys a phone keyboard has not got

No Ctrl, Alt, Esc, Tab, arrows or function keys — and no way to split a window or move between panes. The key bar has them, and its last row splits windows and moves between panes.

pane moves to the next pane each time it is tapped. For a particular direction, Ctrl-b and an arrow work as they always have: tap ctrl, press b, then the arrow.

In the iPhone and Android apps the bar also has a row for the agent in the pane: Codex's ⇧← ⇧→ to answer its questions, ⇧tab for Claude Code's permission mode, esc esc to rewind, 1 2 3 for a choice, and the rest of each agent's keys. It follows the agent st sees and shows itself while one runs; hold a key to see what it sends. See the agent keys.

The commands

st on its own starts sharing. The rest are for a terminal that is already sharing. One recording each, made the same way as the rest of this page: a real binary, a real session, nothing typed twice.

The ones linked to another page are described there rather than recorded here. Every command, with all of its flags, is in the command reference.

st

An empty terminal, and a link and a QR code a few seconds later. The session belongs to the multiplexer, so what this starts outlives the command.

st url

The same link again, and its QR code with it: whoever asks for the link has usually lost the screen that had the code. The ?k= on the end is the token that opens the terminal once.

st ls

What the multiplexer is running and who is on each session. It is a list you move around in; q leaves it, Enter attaches. A session where Claude Code teammates are still running after their agent team ended says team ended.

The AGENTS column counts the panes of a session that are running a coding agent — blank when none are, which is most of them. It counts every window, not the one on screen, so a session running several agents at once says so from the list.

st attach

How the machine joins the session it is sharing. The multiplexer is carried inside st, so on a machine with no tmux or zellij of its own this is the only way in. Ctrl-b d leaves it running.

st exit

Stops sharing: the agent and the tunnel go, the session stays. st url has nothing to print afterwards.

st login

Signing in gives the machine one address that survives restarts, instead of a new one each time. It is a device code: open the page, approve the code.

st whoami, st machines, st logout

The rest of the account commands, from a machine that has not signed in.

st upgrade

Replaces the binary it is with the latest release, wherever it was installed. An agent that is already running keeps the copy it opened. Then it lists what's new since the version it replaced (st 0.3.78 and later).

st doc

Hands a document to your phone or tablet: st doc notes.md, or cat plan.md | st doc --title Plan. It stays on the machine (a copy: the file itself is never written to); the app is told the title. See Documents.

st awake

Keeps the machine from going to sleep on its own while an agent is busy, so a turn does not stop halfway and the phone can still reach the terminal (st 0.3.71 and later). It is off until you turn it on: holding a laptop awake drains the battery.

st awake            # the mode now, and whether it is holding the machine awake
st awake working    # awake while an agent is working
st awake agents     # awake while an agent is working or waiting for an answer
st awake off        # never (the default)

The mode is kept in ~/.sophonz/awake.json, so it survives a restart; set while st is not running, it takes effect when st starts. Only the idle timer is held off: the display can still sleep, a machine already asleep is not woken, and the hold goes when st stops. macOS uses caffeinate, Linux systemd-inhibit, Windows the system's own call; a machine with none of them says it has no way to stay awake.

st version

st --help

Every command and flag, from the binary itself. --help after any command, or st help <command>, shows that command's help and does nothing else: st upgrade --help does not upgrade (st 0.3.90).

The flags

--no-tunnel keeps it on this computer: no public address, and only this computer reaches it (st listens on 127.0.0.1). --session shares a session by name, so a machine can have more than one. --mux chooses between tmux, zellij, psmux and none.