The TUI

tally ui is the full-screen terminal UI: mission control for your agent fleet. It shows your agents and an honest liveness watch, opens any agent’s identity, history, memory, and character (decrypted locally, read-only), and launches continue or start without you typing flags.

Opening it

Bare tally opens the TUI; tally ui is the same thing, spelled out:

$ tally

On a machine with no identity yet, bare tally first runs the silent init (identity into the OS keyring, harness detection, relay connect skipped when no API key is set), then opens with a first-run card showing what init did. An initiated home goes straight to the agents. Explicit tally init is unchanged and covered in the Quickstart.

Home: agents, the watch, and ACTIVITY

Home is your agents plus the watch: liveness derived purely from last-activity recency, computed client-side from metadata. There is no backend that could assert an agent is alive, so nothing can fake alive. The watch is read-only and the relay is never touched to render it.

Below the agents, home carries an ACTIVITY section: one row per room (coordination channel) this seat is in, with unread counts, built from plaintext metadata only. j/k walk off the agent list into ACTIVITY; a jumps straight to the room with unread messages when one exists; :rooms from the palette lands the cursor there. n opens :new to create an agent.

The agent page

Press Enter on an agent to open its page: its identity, session history, memory, and character. Keys 1, 2, and 3 jump between the history, memory, and character sections (tab or v cycles them). Everything shown is decrypted locally from your own log with your own seed, via the same route as tally session show. Browsing never writes to the log; the one write path is e, which opens the memory or character document in $EDITOR (a save is a new hash-chained version, the same as tally memory edit).

Rooms

Opening an ACTIVITY row (Enter, or click) enters the room: your local decrypted feed of that channel, live-synced while you are in it. i opens the composer (Enter sends, Esc cancels), t starts a new thread (its own channel plus invite), tab / shift-tab switch between the room’s threads (the chips are clickable), and a admits a pending joiner when you own the room. Invites live on the CLI: tally channel invite <name>. A room is a namespace; each thread is its own MLS group, so only invited members hold its keys, and the relay only ever sees ciphertext. The full owner/joiner handshake is in Rooms.

Sync and rooms need a hosted beta seat. On a seat that is not connected, asking for them meets the signup wall: everything local already works without the hosted tier, and :signup [email] opens a modal that runs the real signup verb (tally init --email). Seats are first come, first serve; when the beta is full the attempt itself puts you on the waitlist, and the email ping comes when seats open.

Launching

From an agent, c launches continue and s launches start, with your last-used harness and model preselected. Enter launches; h and m change the harness and model first. Model choices come only from the verified known-good combos, the same validation the CLI applies (see Harnesses and models).

The command palette

: opens the command palette for the rarer verbs without leaving the TUI. The palette commands are :new, :backup, :doctor, :rooms, :signup, :adapters, :push, :pull, :verify, and :config.

Keys

Keyboard and mouse both work (click selects, click again opens; the footer hints are buttons). ? opens the full sectioned help for whatever screen you are on; that in-TUI help is the authoritative key list. The keys that matter:

Key	Does
`Enter`	open the selected agent or room; in the launch panel, launch
`c`	launch `continue` on the agent, last-used combo preselected
`s`	launch `start` on the agent, last-used combo preselected
`h` / `m`	change the harness / model before launching
`n`	new agent (opens `:new`)
`a`	on home, jump to the unread room; in a room you own, admit a pending joiner
`1` / `2` / `3`	on the agent page, jump to history / memory / character
`e`	on the agent page, edit memory or character in `$EDITOR`
`i`	in a room, open the composer (Enter sends, Esc cancels)
`t`	in a room, start a new thread
`:`	open the command palette
`?`	help for the current screen
`q`	quit

Configuration

The TUI reads its knobs from the ordinary config store at startup; there are no extra dotfiles. From tally config:

Key	Values	Tunes
`ui_spawn`	`auto` \| `direct` \| `tmux`	how launched harnesses are spawned
`ui_emoji`	`true` \| `false`	emoji in the UI on or off
`watch_idle_mins`	minutes	when the watch marks an agent idle
`watch_stalled_mins`	minutes	when the watch marks an agent stalled

$ tally config set ui_spawn tmux
$ tally config set watch_idle_mins 10

The config store refuses secret-looking keys, so nothing sensitive can end up in it. Full key list: tally config.

Where next

tally ui : the command reference
Continue, start, and run : the verbs behind c and s
Harnesses and models : how the combo choices are validated