CLI

continuum is the terminal client. It speaks the same wire protocol as the Mac, iPhone, and web apps, so a session you start from a shell shows up on your phone, and a session your Mac started is one continuum sessions away. Everything it prints as a human table also prints as machine JSON with --json, which is the point: this is the client you script against.

The CLI is in beta. It is newer than the Mac and iPhone apps and still moving; expect the occasional rough edge.

Install

The installers are user-local — no sudo, no system directories touched. They resolve the newest CLI release, verify the archive against the checksums published with it, and atomically replace any existing binary.

macOS · Linux
Windows

curl -fsSL https://continuumcode.ai/install-cli.sh | sh
# continuum installed to ~/.local/bin

Prefer to read the script before running it, or pin a version:

curl -fLO https://continuumcode.ai/install-cli.sh
sh install-cli.sh --version 0.73.0
sh install-cli.sh --version 0.73.0 --install-dir "$HOME/bin"

Invoke-WebRequest https://continuumcode.ai/install-cli.ps1 -OutFile install-cli.ps1
.\install-cli.ps1
# continuum.exe installed to %LOCALAPPDATA%\Continuum\bin

Pin a version with -Version, or change the destination with -InstallDir.

Neither installer edits your PATH. Both tell you to add the install directory if it is not already there. Six archives ship per release, covering macOS, Linux, and Windows on both x64 and arm64. Windows gets a .zip; macOS and Linux get a .tar.gz so the executable bit survives.

CLI archives are not code-signed — the release pipeline has no cross-platform signing certificate, and manifest.json says so explicitly. The SHA-256 checks detect accidental corruption; they do not authenticate the origin, because anyone who can replace the archive can replace its checksum too. GitHub’s keyless build provenance is attached to the release artifacts on a best-effort basis. Verify the release origin yourself until Continuum ships a real release-signing trust root.

Updating

Automatic updates are deliberately off for the same reason. Updating is an explicit opt-in:

continuum update --version 0.73.0 --check   # inspect that release's manifest
continuum update --version 0.73.0           # verify and replace the binary

A read-only or system-installed binary is never replaced — use the user-local installer instead. If you have your own signing setup, CONTINUUM_UPDATE_MINISIGN_PUBLIC_KEY makes the updater require a minisign signature, and --require-signature makes it fail closed.

Connecting to a daemon

Every command resolves a daemon the same way. Direct HTTP defaults to 127.0.0.1:21731 — the canonical port for the Mac app’s daemon and for a headless continuum-agent.

What	Resolution order
Host / port	`--profile`, else `CONTINUUM_PROFILE`, else the current profile · overridden by `--host` / `--port` · `CLAWDMETER_HTTP_PORT` changes the default port
Bearer token	`--token`, else `CONTINUUM_TOKEN`, else `<dataDir>/agent-token`
Data dir	`CLAWDMETER_DATA_DIR`, else `~/.clawdmeter` (`%USERPROFILE%\.clawdmeter` on Windows)

A missing token gives you a clear unauthorized error rather than a silent failure.

~/.clawdmeter is where a standalone daemon keeps its state. The desktop app bundles its own daemon, which keeps state inside the app’s data directory and binds a loopback port assigned at launch rather than the default 21731. To drive it, set CLAWDMETER_DATA_DIR to that folder (or point --token at the agent-token inside it) and pass the port it actually bound with --port.

Named profiles

continuum config set work --host 100.64.0.5 --port 21731 \
  --provider codex --account codex/work --model gpt-5.6-sol \
  --mode worktree --effort xhigh
continuum config list
continuum config use work
continuum sessions --profile work

Profiles hold non-secret connection metadata and new-session defaults, stored in your OS config directory (~/Library/Application Support/continuum/config.json on macOS, ~/.config/continuum/config.json on Linux, %AppData%\continuum\config.json on Windows). The file never accepts or stores bearer tokens. Explicit flags always beat a profile’s defaults.

Reaching a host that isn’t directly routable

--relay carries every request over the encrypted relay instead of direct HTTP — the same ChaCha20-Poly1305 channel the web app and iPhone use. The credential is the daemon’s own relay-pairing.json: on the daemon’s own box, bare --relay finds it; from another machine, copy it over and point at it with --relay-pairing <path> (which implies --relay). Guard that file like a credential — it is one. One limit worth knowing: a relay request must fit a single 32 KiB frame, so a very large prompt body should go over the direct path.

Commands

Sessions

session is the canonical group; the older top-level verbs remain as aliases.

# Create in an existing repo, after the daemon validates provider/model/account.
continuum new -repo /src/project -provider claude -model opus -effort high

# Let the daemon own a worktree, and deliver the opening prompt with it.
continuum new -cwd /src/project -agent codex -effort xhigh \
  -worktree -base-branch main -prompt "Implement the fix"

Command	Does
`continuum sessions`	List managed sessions, live first (`--all` includes archived)
`continuum session show <id>`	The canonical session record
`continuum session new …`	Create, after provider/model/account preflight
`continuum send <id> <text…>`	Deliver a prompt, with an idempotency key
`continuum session interrupt <id>`	Interrupt the active turn; the session stays available
`continuum session stop <id>`	Stop the process, keep the session
`continuum session rename <id> <name>`	Set the display name
`continuum session archive <id>` / `unarchive <id>`	Change archive state, idempotently
`continuum session delete --yes <id>`	Permanently delete
`continuum session model <id> <model>` / `effort <id> <effort>`	Change model or reasoning effort
`continuum session mode <id> <local\|worktree>`	Switch workspace mode
`continuum resume <id>`	Continue the conversation as a new managed session
`continuum attach <id>`	Full-duplex terminal attach (relay only)

Session creation is transport-only — the daemon does every process, repository, and worktree operation. If a provider has more than one account and you name none, creation fails rather than quietly billing the wrong subscription.

Review and status

Command	Does
`continuum diff <id>`	Unified git diff for the session’s worktree
`continuum pr <id>`	PR status — title, state, checks, mergeability
`continuum usage`	Live per-provider gauges: session and weekly percentages, reset times
`continuum context <id>`	Context-window fill, turn count, last-turn duration
`continuum providers`	Per-provider availability and auth state
`continuum accounts`	Multi-account rows

Because every one of these takes --json, they compose:

continuum usage --json | jq '.gauges[] | select(.weeklyPct > 80)'
continuum sessions --json | jq -r '.[].id'

Approvals and questions

continuum permissions list
continuum permissions respond <sessionId> <optionId>
continuum questions list

Destructive permission choices require --confirm-destructive. questions handles the structured AskUser forms an agent raises mid-run.

Frontier groups

Run the same prompt across two or three provider/model/effort slots and keep the best answer:

continuum frontier create --slot claude:opus:high --slot codex:gpt-5.6-sol:xhigh
continuum frontier send <groupId> "Implement the fix"
continuum frontier pick-winner --yes <groupId> <childIndex>

pick-winner continues from one child and archives the others, so it requires --yes. turn-winner records a per-turn preference without destroying anything.

Cross-provider memory

continuum memory stores durable learnings — conventions, decisions, debugging workflows — per repo or globally on the daemon, then materializes them into every new session’s CLAUDE.md / AGENTS.md so every provider reads them natively. No single underlying CLI can do that.

continuum memory enable      # review the disclosure and opt in
continuum memory remember "the parser lives in parser.go; dedupe by messageId"
continuum memory remember "prefer ripgrep over grep" --global
continuum memory search parser
continuum memory flush <sessionId>   # summarize a session into repo memory
continuum memory disable     # opt out and scrub every materialized copy

It is off by default and asks for consent on first use, because memory captured from one provider is deliberately shared with all of them, and flush sends transcript text to an LLM for summarization. Storage is daemon-private (<dataDir>/memory/, mode 0600) and bounded so materialization never blows the agent’s context. A repo you never add memory to is never written to.

The TUI

continuum tui                 # opens on the most-recent session
continuum tui --session <id>  # opens directly on one

A full terminal workbench: session list on the left, transcript and composer in the middle, a review pane on the right.

Key	Action
`↑` / `↓` + `Enter`	Pick a session, or choose a permission response
`Tab`	Move focus between the session list and the composer
`Enter`	Send the prompt (in the composer)
`n`	New session, using the same preflight as `session new`
`/`	Command palette — `/diff` `/pr` `/usage` `/new` `/interrupt` `/theme` `/help`, plus your host’s skills
`@`	Mention picker — open sessions, and files or artifacts the agent cited
`d` / `p` / `u`	Right pane: diff / PR / usage
`c`	Return the pane to the session transcript
`t`	Attach the terminal to the session’s pane (relay only; `Ctrl+]` detaches)
`T`	Cycle the color theme
`Ctrl+C`	Interrupt a streaming turn, else quit

The transcript renders markdown, reasoning, bounded tool calls and results, plans, todos, sources, artifacts, and structured question forms. Pending permissions arrive as a first-class option card; a destructive choice needs a second Enter. /remember and /flush route to memory rather than to the provider. Narrow terminals hide the sidebar and keep the transcript usable.

Shell completions

source <(continuum completion bash)
continuum completion zsh > "${fpath[1]}/_continuum"
continuum completion fish > ~/.config/fish/completions/continuum.fish

continuum completion powershell | Out-String | Invoke-Expression

The daemon behind it

The CLI ships out of the same Go codebase as continuum-agent, the headless daemon that hosts sessions on a box. They are two separate executables with different jobs:

continuum is the client — it drives a daemon over HTTP or the relay, and runs everywhere.
continuum-agent is the daemon — it owns the processes, the repos, and the worktrees.

The Windows and Linux desktop app bundles both, which is why the CLI is already on any machine where you installed the desktop app. On a headless Linux VPS you install continuum-agent on its own and it becomes an execution host your other clients can target — see Remote devices.

Getting started

Surfaces

Features

Accounts & devices

Providers

Security & privacy

Hidden surfaces

Reference

Install

Updating

Connecting to a daemon

Named profiles

Reaching a host that isn’t directly routable

Commands

Sessions

Review and status

Approvals and questions

Frontier groups

Cross-provider memory

The TUI

Shell completions

The daemon behind it

​Install

​Updating

​Connecting to a daemon

​Named profiles

​Reaching a host that isn’t directly routable

​Commands

​Sessions

​Review and status

​Approvals and questions

​Frontier groups

​Cross-provider memory

​The TUI

​Shell completions

​The daemon behind it

Install

Updating

Connecting to a daemon

Named profiles

Reaching a host that isn’t directly routable

Commands

Sessions

Review and status

Approvals and questions

Frontier groups

Cross-provider memory

The TUI

Shell completions

The daemon behind it