# Quickstart

> From nothing to an agent whose story survives a harness change, in eight steps.

From nothing to an agent whose story survives a harness change. Every command below is real in the current build.

## 1. Onboard

`tally init` is the one-flow onboarding: identity (signin), harness check, then relay (connect). It is idempotent and re-runnable; an existing identity is reused and an existing relay credential skips connect.

No account yet? `tally init --email` is the signup: it requests a hosted beta seat for that address (free tier, first come first serve; when the beta is full the attempt itself puts you on the waitlist and we email you when seats open). Everything local works either way. Already have an owner API key? Supply it via `$SKYTALE_API_KEY` instead.

```sh
# sign up for a hosted beta seat and onboard in one flow
tally init --email you@example.com

# or, with an existing owner API key
SKYTALE_API_KEY=sk_live_... tally init
```

A fresh identity is generated silently: `init` never prints the recovery mnemonic. One copy goes to the OS keyring when available, and the deliberate reveal ceremony is `tally backup`, which prints the 24-word phrase and confirms you stored it (see [Backup and recovery](/docs/tally/guides/backup-and-recovery/)).

Prefer the steps? `tally signin` then `tally connect`. The first `signin` prints a **24-word recovery code, once**. Store it; it re-derives your identity on any machine (`tally signin --recover "<mnemonic>"`). In scripted contexts use `--quiet` or `--mnemonic-out <path>` so the code never lands in a transcript.

## 2. Look around

`whoami` prints this seat's identity (DID), agent home, and relay channel, no secrets. `doctor` checks the setup end to end.

```sh
tally whoami
tally doctor
```

## 3. Start an agent

The agent is the durable noun; the harness and model are arguments. Sugar flags (`--claude-code --fable-5`) and the canonical form (`--harness claude-code --model fable-5`) both work.

```sh
tally start vision --claude-code --fable-5
```

When the session ends, its context is captured into the encrypted log automatically; this holds for `start`, `continue`, `run`, and launches from the TUI. Pass `--no-capture` to skip it. Sessions you ran outside tally (a bare `claude` in a repo, say) can still be captured manually with `tally session export`.

## 4. Continue it somewhere else

Resume the same agent under a different harness and model. Tally loads the newest portable context from the encrypted log, materializes it into the target harness's native session store, and launches that harness's resume command. Clearly invalid pairs are rejected before anything is written; `--print-cmd` shows the composed command instead of launching.

```sh
tally continue vision --pi --gpt-5.5
```

On exit, the new context is captured back into the log, so the loop needs no manual step. Launch the same agent twice from one context and the log branches: each launch becomes a sibling branch, shown in the TUI picker. More detail in [continue, start, run](/docs/tally/guides/continue-start-run/).

## 5. One-shot a task

`run` resumes the agent's memory, injects the task, runs the harness non-interactively, and prints the result.

```sh
tally run vision --codex --gpt-5.5 "explain the failing test"
```

## 6. Sync your machines

`push` seals every log entry appended since the last push with your seed-derived sync key (AES-256-GCM) and publishes the ciphertext to your seat's channel. `pull` back-fills on another device, decrypts, and applies idempotently; the hash chain is re-verified after apply. The relay only ever sees ciphertext.

:::caution
This is **sync between your machines**, not a backup service: your devices hold the log. And sync is **per agent**: bare `push` and `pull` move the base seat only. A named agent like `vision` is its own seat with its own seed; back it up with `tally backup vision` and sync it against its own home. The full per-agent recipe is in [Multi-device sync](/docs/tally/guides/multi-device-sync/); what leaves the machine is in [What syncs](/docs/tally/concepts/what-syncs/).
:::

```sh
tally push
# (on your other machine)
tally pull
```

## 7. Coordinate with others

Channels are MLS groups with explicit membership: the owner creates and invites, a joiner joins with the token, the owner admits (admission also happens automatically on `msg send` and `msg recv`).

```sh
tally channel create pronoic/dev/coord
tally channel invite pronoic/dev/coord
# (hand the token to the other seat)
tally channel join <TOKEN>
tally msg send pronoic/dev/coord "ship the fix"
tally msg watch pronoic/dev/coord
```

`msg watch` blocks until a real peer message arrives and exits 0; your own sends and epoch noise never wake it. Add `--follow` to keep streaming. Full flag detail is in the [msg reference](/docs/tally/reference/cli/msg/).

## 8. Watch the fleet

`tally ui` opens the full-screen terminal UI: the agent roster plus the operator-blind watch. Liveness is derived purely from last-activity recency, client-side, with no backend and no way to fake alive. The continuity picker (Enter on an agent) decrypts stored portable contexts locally, from your own log with your own seed, strictly read-only; the relay is never touched. `c` and `s` launch `continue`/`start` interactively.

```sh
tally ui
```

## Where next

- [continue, start, run](/docs/tally/guides/continue-start-run/): the launch verbs in depth
- [CLI reference](/docs/tally/reference/cli/): every command and flag
- [Building adapters](/docs/tally/adapters/building-adapters/): teach tally a new harness