Your machines. One self-hosted dashboard.

There is a MacBook in a drawer, a Mac mini under the desk, and a Linux box in the corner. All of that capacity sits idle while one laptop does the work.

Meanwhile “remote” means opening a terminal, SSH-ing in, and hunting for the session you left running — assuming it survived the disconnect. From a phone it means nothing at all.

And an agent CLI is a single-session tool: one window, one machine, one thing at a time, with no way to see which of the five you started is waiting on an answer.

One coordinator connects every supported machine you own. It is control plane only — auth, an append-only event log, and fan-out to every open browser — and the machine running it is usually a worker too. Every other macOS or Linux box joins as a worker.

Workers dial outbound and never listen, so a worker machine never opens a firewall hole, exposes an inbound port, or needs a publicly reachable name. The sidebar groups live sessions by machine and each machine carries tiles for CPU, memory, disk, and network from its own heartbeat, so “which box has capacity right now” is a glance instead of an SSH session.

Adding a machine is one command on an automatic-mode coordinator —roost add-machine --platform macos or linux — which mints a one-shot token valid for 24 hours and prints the enrollment command to paste on the new host. Machines join by pulling; the coordinator never SSHes out. See fleet.

Streaming raw PTY bytes into a browser looks simple and corrupts in practice: every resize re-reflows history, and every reconnect duplicates or drops output. Roost uses the model server-side multiplexers use instead, and then adds the things that make a browser feel like a terminal emulator.

• One authoritative grid, on the worker. The worker holds the grid and rebuilds it at a single agreed width when your viewport changes. The browser renders those cells as-is and never re-reflows history.
• Reconnects splice instead of guessing. Every cell frame carries a monotonic seq, and a stale or unset viewer sequence is answered with exactly one authoritative full frame — so a reconnect can never duplicate or drop rows.
• Scrollback is fetched on demand. History is never streamed. It is requested explicitly and served from the worker's retained buffer of roughly 10,000 lines per session, walked in slices so one backfill never blocks another session's live output.
• Wide glyphs stay atomic. Column occupancy is stated on the wire, so a double-width CJK ideograph or emoji is one two-column span and no phantom continuation cell is ever emitted.
• Links are real. OSC 8 hyperlinks travel as per-cell link identity. On top of plain output Roost infers URLs, owner/repo#123and bare #123 references, and file paths; Cmd- or Ctrl-click opens a path in the in-app file viewer, which honours the#L42 anchor.
• The application decides about the mouse. Pointer gestures are forwarded only when the running program actually asked for them — DECSET 1000 and 1002 tracking, SGR 1006 encoding, focus events 1004 — so a click in vim or less is not silently swallowed.
• Predictive echo, mosh-style. Above roughly 10 ms round trip, a keystroke is drawn immediately in a client-side overlay and reconciled against the authoritative frame that lands an RTT later. The overlay never reaches the worker, and alt-screen TUIs suppress it entirely.
• Keyboard parity. The ⌘ and Ctrl shortcuts behave like a native app. A browser running on Windows gets a deliberately separate binding set — Alt and Alt+Shift chords — so a plain Ctrl plus letter still reaches the program in the PTY.

The whole data plane is described in terminal fidelity.

Roost never spawns, supervises, or owns an agent. There is no wrapper process, no transcript store, and no agent execution RPC — the CLI is an ordinary command in a shell PTY. Status reads and event waits observe that terminal without changing the boundary. That is what makes “any CLI” true rather than aspirational: a shell, a REPL,vim, htop, a build, ssh, tmux, and any coding agent, including Claude Code.

Ten agents are first-class in the launcher and in status detection — Codex, Gemini CLI, OpenCode, Cursor Agent, Amp, GitHub Copilot CLI, Droid, Grok, Pi, and OMP — beside a custom-command entry that launches anything you type. What the list adds is a status badge, not the ability to run; an unlabelled terminal is the normal case, not a failure.

Detection, its three tiers, and what the badges mean are inagents and status.

A keeper subprocess hosts every PTY on a machine over a single capability-authenticated local endpoint, with one channel per session. Because it is a separate process, PTYs outlive the worker: a restarted or updated worker reattaches over the same endpoint and re-adopts its open sessions.

So drop WiFi, close the laptop, refresh the tab, or reopen the same session from a different machine — the process is still running, with full scrollback. The browser redials on capped backoff, sends the last event id it saw, and gets exactly the events it missed. When the coordinator itself restarts, every session is re-projected from the event log, because the log is the source of truth.

Roost labels a terminal with the state of whatever agent is running inside it: working, needs input, ordone. It shows up in four places — the session's sidebar row, its tab, its card on mobile, and a rollup on the folder that contains it, for example 2 working · 1 needs input.

An in-app toast and an unseen count in the tab title need no setup at all. OS notifications, the kind that reach you when Roost is not the tab you are looking at, need one explicit grant per device, because browsers only prompt on a real click — and a device already viewing that session is deliberately left alone.

OMP and Pi report their own lifecycle over a per-worker Unix socket, validated against the reporting process id. The other eight are detected from pinned screen and OSC-title manifests plus a periodic process-tree scan, so an agent you started by hand still gets recognised. Nothing about status is persisted: a worker, coordinator, or browser restart re-derives it rather than leaving a stale badge behind.

Typing a long prompt on a phone is miserable, so tap the mic and dictate. The recognized text is typed into the session as real input and sent, with no review step in between.

The zero-setup path is the browser's own speech recognition, which is a rough fallback. The recommended path is a Deepgram nova-3 key added once in Settings → Voice: it is stored on the coordinator and shared to every paired device, so you configure it once rather than per phone, and it can run a single language, automatic detection, or multilingual mode with live code-switching.

Roost also extracts terminal jargon from the screen you are dictating into and passes it to Deepgram as keyterm bias, so project vocabulary and identifiers transcribe as themselves rather than as phonetic mush.