Continue, start, and run

The core interaction in Tally is one line:

$ tally continue vision --claude-code --fable-5
#              └agent┘ └─harness──┘ └─model─┘

You do not start claude or codex. You start your agent, and point it at whatever harness and model you have right now:

vision is the durable noun: the agent’s identity plus its portable encrypted log (memory, history, character). This is what you own and what persists.
--claude-code is the harness it runs in this time. Swappable.
--fable-5 is the model driving it this time. Swappable, on your own auth.

Tomorrow, on another machine, with different equipment, the same agent:

$ tally continue vision --codex --gpt-5.5

Same memory, same history, same character, now thinking with different tools.

The three verbs at a glance

Verb	Session	Use when
`tally continue <agent>`	Resumes the agent’s newest portable context, interactive	You are picking up where the agent left off
`tally start <agent>`	Fresh session (creates the agent’s identity if absent), interactive	You want a new agent, or a blank conversation for an existing one
`tally run <agent> "<task>"`	Resumes the agent’s context, non-interactive one-shot	You want a task done and the result printed, no chat

All three compose the same machinery: resolve the agent’s seat, load its portable context (for continue and run), materialize it into the target harness’s native store, and launch that harness with the model injected.

Choosing a harness and model

Every launch verb accepts the harness and model in two equivalent surfaces:

# canonical
$ tally continue vision --harness pi --model gpt-5.5

# sugar (harness shortcut + model alias)
$ tally continue vision --pi --gpt-5.5
$ tally continue vision --claude-code --fable-5
$ tally continue vision --codex --gpt-5.5

The v1 harnesses are:

claude-code (Anthropic models)
pi (multi-provider)
codex (OpenAI models)

How combos are validated

Marketed, known model shortcuts are guaranteed to launch: they are validated against the installed harness (for example --fable-5 resolves to claude-fable-5).
Other model tokens are family-validated, and the harness makes the final model check.
Clearly invalid pairs (an OpenAI model on claude-code, for example) are rejected before anything is written.

See the command without running it

Pass --print-cmd to any of the three verbs to print the composed harness command instead of launching it. Useful for checking what Tally is about to run, or for wiring the command into something else.

$ tally continue vision --pi --gpt-5.5 --print-cmd

tally continue

$ tally continue <AGENT> [--harness <h> --model <m> | sugar] \
  [--cwd <dir>] [--seq <n>] [--print-cmd] [--no-sync] [--no-capture] [--no-reflect]

Resumes the agent’s portable encrypted log under the chosen harness and model: loads the newest portable context, materializes it into that harness’s native store, and launches the harness’s resume command with the model injected.

<AGENT> is the agent to continue. default (or callers that omit the name) use the single-seat home.
--cwd <dir> sets the working directory for the launched harness.
--seq <n> selects a specific stored context instead of the newest.
--no-sync skips the sync step for this launch.

Capture on exit: when the harness exits, the session it wrote is captured back into the encrypted log as the agent’s next portable context. --no-capture skips that. After capture, a background reflect pass distills the session into the agent’s memory; --no-reflect skips that (see Memory and character).

Reference: tally continue.

tally start

$ tally start <AGENT> [--harness <h> --model <m> | sugar] \
  [--cwd <dir>] [--print-cmd] [--no-capture] [--no-reflect]

Creates and spins up a fresh agent under the chosen harness and model:

$ tally start vision --claude-code --sonnet
$ tally start vision --harness codex --model gpt-5.5

Creates the agent’s identity if it does not exist yet (the normal signin-to-seed path), then launches the harness on a new session under the model.
Same two surfaces and the same combo validation as continue.
On exit, the fresh session is captured as the agent’s first portable context (--no-capture skips it).

A fresh start on an existing agent is a blank conversation, not a blank self: the agent’s character and memory are injected at every launch, start included.

Reference: tally start.

tally run

$ tally run <AGENT> [--harness <h> --model <m> | sugar] "<task>" \
  [--cwd <dir>] [--seq <n>] [--print-cmd] [--no-sync] [--no-capture] [--no-reflect]

One-shots a task on an agent, non-interactively:

$ tally run vision --pi --gpt-5.5 "add a --json flag to the exporter"

run resumes the agent’s memory (its newest portable context) like continue, injects the task, runs the harness non-interactively (claude --print, pi --print, or codex exec depending on the harness), and prints the result. --print-cmd prints the composed command instead of running it.

Reference: tally run.

The interactive route: tally ui

If you prefer picking over typing, tally ui opens the full-screen terminal UI: the agent roster, a liveness watch derived purely from last-activity recency (client-side, no backend), and the continuity picker. Press Enter on an agent to browse its stored portable contexts (decrypted locally with your own seed, strictly read-only), and press c or s to launch continue or start interactively. The TUI suspends, the chosen harness runs on your terminal, and the TUI resumes when it exits. Model choices in the TUI come only from the verified known-good combos.

$ tally ui

Reference: tally ui.

Where to go next

First-time setup: Quickstart
What gets injected at launch: Memory and character
What capture and sync send off the machine: What syncs, and what the cloud can see