The conversation

quox with no arguments opens the conversation.

quox
quox -p staging -n release-checks
quox --verbose full

Option	What it does
-p, --profile <name>	Use a signed-in profile. A profile that does not exist is an error, never created on the fly.
-n, --name <name>	Name this session. See Sessions and agents.
--verbose off|on|full	How much protocol detail to show. Bare --verbose means on.
--demo	Play a simulated journey. No server, nothing real runs.
--no-clear	Do not clear the screen on start.
--service-key	Allow an ambient QUOX_SERVICE_KEY when the profile has no login. Never used without this flag.

Type a message and press Enter. CommanderQ, the default agent, routes it to the right specialist. Type /help for the list your version supports, or /help esc for detail on one key.

Depends on how your QuoxCORE reaches its model

On some provider paths the server does not send tool events yet, so tool lines and the AEE, AOCL and WARD lines below may not appear, and steering is not applied. Approval cards still appear on every path: Quox checks for pending approvals every 4 seconds. A fix is in progress; this note goes when it ships.

Keys

These tables are generated from the client’s own /help registry, so they match what your terminal shows at this version.

Talk

Key	What it does
just type	ask Quox anything; CommanderQ routes it to the right agent
Enter	send; while Quox works, steer the running turn if this server supports it, else queue it Idle: sends. During a turn: steers when the server supports it (shown here once known), delivered at the next model boundary (never kills a running tool). If the server cannot steer, or the turn already finished, it is queued instead and you are told.
Tab	queue your message to run after this turn Queued messages show above the composer. Up (empty composer) pulls the last one back to edit. After an interrupt they wait; press Enter on an empty composer to send the next one.
Esc	ask the server to stop the turn (idle: Esc Esc clears the draft to history) Asks the server to stop before the next model call or tool; you see "stopping" until the server confirms. A tool already dispatched finishes and is reported, never hidden. Until the server route exists the stream is aborted locally and you are told work already sent may still finish.
Shift+Enter / Ctrl+J	new line in the composer (a trailing \ then Enter also works)
Ctrl+G	edit the draft in $EDITOR
Ctrl+S	stash the draft; on an empty composer, restore it
Ctrl+_	undo in the composer
paste	long pastes collapse to [Pasted text #N +L lines] and expand on send
Ctrl+C	clear the draft; during a turn interrupt; twice when idle quits

Context

Key	What it does
status line	profile · org · agent · model · mode, under the composer

Generated from the quox client registry at c484f2178 (quoxcli 0.2.0).

Enter while Quox is working. It steers the running turn when your server supports steering, delivered at the next model boundary, and never kills a running tool. When the server cannot steer, or the turn has already finished, your message is queued instead and Quox tells you so.

Esc. It asks the server to stop. You see “stopping” until the server confirms. A tool already dispatched finishes and is reported, never hidden.

After each turn a grey summary line shows how long it took, how many tools ran and how many approvals it raised.

/quit (or /exit) leaves. Work already sent to the server keeps going.

Slash commands

Approvals

Command	What it does
/approvals	list what is waiting for you
/approve N	approve item N from the list Run /approvals first. Mid-turn approval cards also take a (approve), d (deny), o (open); they arm after 300 ms and never default to approve.
/deny N	deny item N from the list

Skills

Command	What it does
/skills [name]	list your org's governed skills, or show one as a card Lists your org skills (reusable procedures an agent follows; not Crystals, which are deterministic replays) with edition and one-line description. /skills <name> shows its card: purpose, version and review state, tests (results only when run-tests recorded them), the agents it is for, where it came from, recorded use, and how to run it.
/skill <name> [args]	ask Quox to run a skill (governed: approvals still apply) Sends "Run the skill <name> with: <args>" as a normal turn, so CommanderQ runs it through the usual governed path. Nothing is executed from here, and approval cards work as always.
/rules [files|off|on|N]	which rules win: advisory QUOX.md, the dev pack, enforced server policy /rules shows the precedence: QUOX.md and the dev pack only guide; armed governance policies on the server are enforced and win. /rules files shows the QUOX.md text. QUOX.md in this directory and parents up to the git root, plus ~/.quox/QUOX.md, are sent with each turn as your rules. World-writable files and symlinks leaving your home or repo are ignored. /rules N shows page N.
/workflow <name|id|run>	the step flow of a workflow's latest run (or one run): state, timings, human gates Steps come from the workflow definition and each state and duration from that run's recorded envelopes. A reached human gate shows amber. Enter on a workflow row in the roster shows the same flow.
/crystal <workflow>	is this workflow eligible to become a Crystal? checked against the real gate Computed from the workflow's recorded runs with quoxflow's crystalliser rule: at least 3 runs, at least 80% successful, one action sequence. Says how many more successful runs are needed.

Conversation

Command	What it does
/clear also /new, /reset	fresh conversation and a clear screen; rules and memory kept, /resume goes back Clears the screen and starts a new conversation. Your QUOX.md rules, attached agent, model choice and Quox memory stay as they are. The previous conversation is kept on the server: /resume lists it.
/resume [id|name]	pick a recent conversation and carry on where it left off Alone: a picker of your recent conversations (title, agent, age); Up/Down and Enter resume, Esc cancels. With an id (or the start of one) or a /rename name it resumes directly. The last turns are shown as history and your next message continues that conversation. Also at launch: quox --resume [id|name] or quox --conversation <id>.
/compact [show]	summarise the conversation on the server, keeping decisions The server summarises this conversation with your AI provider, keeping decisions, and the summary becomes the start of the conversation for later turns. Shows the token change and the first lines of the summary; /compact show prints all of it. Refused while a turn runs, and when the org has not given AI processing consent. Asking "compact this conversation" in words only suggests it.
/help [command]	this reference, or detail for one command or key
/note <text>	jot an observation for the dev observer (also: // text); not sent to Quox Records your text in the dev transcript only: not sent to the model or the server, no turn, not in chat history. Needs dev transcripts on (touch ~/.config/quox/dev-transcripts). Up to 2000 characters.
/copy [N|code]	copy the last answer (raw markdown) to the clipboard; N = Nth-last, code = last code block Uses the OSC 52 terminal escape (works over SSH in most terminals; wrapped for tmux). Needs a terminal that allows OSC 52. Mouse selection is untouched: select and copy with your terminal as usual.
/eye	the Q opens its eye and blinks (the Dragon's Eye) A small Easter egg. Under reduced motion (QUOX_REDUCED_MOTION=1) it shows a still open eye instead.
/sound [profile|test]	earcons for approvals, failures and long turns: Silent | Minimal | Operational | Full Same setting as the dashboard (your account's soundProfile). Minimal (default) sounds for approvals, critical alerts and failures; Operational adds a short tick when a turn over 20 s finishes or the terminal is in the background. Over SSH only the terminal bell rings, for approvals and critical alerts. QUOX_SOUND=off mutes this terminal; --print never makes sound.
/about	who we are, terms, privacy, licence and docs links
/quit also /exit	leave; finished work is kept and /resume picks the conversation up Idle: leaves at once; the conversation stays on the server for /resume (or quox --resume). During a turn it asks first, because leaving disconnects the turn and the server stops it before its next step (a tool already running finishes and is recorded). /quit again within 5 s leaves anyway.
/restart	restart into the latest installed quox and resume this conversation Re-runs the quox on your PATH in this terminal with the same arguments and profile, plus --resume for this conversation. During a turn it asks first: restarting disconnects the turn and the server stops it before its next step (this server cannot reattach a running turn yet); /restart again within 5 s goes ahead. When a newer build is installed than the one running, a dim line says so (checked at most once a minute, no network).
/gripe <text> also /gripe!	file a GitHub issue through the GRIPE agent; shows it first, /gripe! files at once The same governed path as `quox gripe`: the GRIPE agent files the issue through your org's GitHub connector (default repo quoxai/quox). /gripe <text> shows what would be filed and asks; /gripe! (alone, within 2 minutes) files it, or /gripe! <text> files straight away. The issue link is shown when one comes back; with no link it says so and treats it as not filed.
/sessions [all]	your recent conversations; /sessions all shows everything live in your org /sessions all is the same overview as `quox sessions`: every live tmux session, conversation, held slot and running objective, loop or workflow in your org, grouped by agent, with how to attach. Bare /sessions lists recent conversations from the server. Names set with /rename are kept on this machine (~/.config/quox/sessions.json) because the server has no rename route yet.
/rename [name]	name this session (shown in the top rule); alone shows the current name Also settable at launch with quox -n <name>. The name is kept on this machine, keyed by conversation, and shown in /sessions.
/slot <name>	give this session a slot address (checks out the slot) Checks out the slot, creating it if needed, as `quox slot checkout <name> --create --session <session>` does; typing it is your consent. Discord replies are not relayed into this window yet (no slot wait loop here).
/attach [agent]	send your turns to a specific agent; alone shows the current one The agent name is checked against your org's agent list. Later turns go to that agent (the chat stream assistant field) until /detach.
/detach	back to CommanderQ

Connect

Command	What it does
/connect [provider]	see what is connected; /connect openai adds a key safely Alone: AI providers (OpenAI, Claude API, Ollama) and the integrations in your org vault, with real status from the server; anything it cannot read shows ? unknown. /connect openai (or anthropic) opens a secure card: paste the key, Enter tests it with the provider and saves it to your org vault as the default; Esc cancels. Keys typed there never reach chat, history or transcripts. A key pasted into the composer is never sent.
/capabilities [name]	what this Quox can do here: ready, needs setup, not available, planned Asks the server (GET /api/v1/capabilities), which checks real service health, your plan, plugin install state and connected providers. Each gap says why and how to set it up; /capabilities <name> gives the one-line offer for one. If the server cannot answer, nothing is assumed.

Verbose

Command	What it does
/verbose off|on|full	protocol lines: off = receipts only, on = compact, full = adds thinking on (default) shows compact AEE / AOCL / WARD lines as they happen. off collapses to the receipt line. full adds the thinking stream.
/proof [envelope]	the evidence chain for the last tool call: AEE, AOCL, tool, WARD Each link is read back from the server and drawn confirmed only when the read says so. WARD is the server-verified inclusion receipt; it can be slow on a large chain and is bounded, so a link may stay open.
/reconcile	check tool calls that ended with effect unknown against the server's record

Context

Command	What it does
/status	profile, org, server and its health, model, agent, slot, session, version The provider and model shown are what the server last reported running (turn.started), not what was asked for. Server health is checked live. Asking "what is my status" in words prints the same panel as a tip.
/cost also /usage	tokens and cost per model for this session, from real usage Counts only what the server reported on turn.finished (input, output and cache tokens, cost when the provider gives one). Cost stays blank when the server did not report it, and says so; nothing is estimated. Asking "what is this costing" prints the same panel.
/context	model, conversation tokens, rules, skills, memory and the attached agent Conversation tokens are the sum the server reported for this conversation in this session. Skills and memory are real calls to your server; anything it cannot answer shows ? with the reason. Asking "how much context have we used" prints the same panel.
/doctor	the quox doctor checks plus chat checks, as rows Runs the same checks as `quox doctor` (services, auth token, CLI version) in this process, then chat checks: the chat routes answer, a provider is connected, the capability contract.
/config also /settings	settings: theme, motion, verbose, model; saved on this profile An interactive card: Up/Down pick a setting, Left/Right or Space change it (saved at once to this CLI profile), Enter on Model opens /model, Esc closes. Theme replaces the env-only QUOX_THEME; if QUOX_THEME is set in your shell it still wins and the card says so.
/model [provider [model] [compact|full]|auto]	see what is connected and choose the provider/model for your next turns Alone: auto, OpenAI, Claude API and Ollama with real status from your org vault (the same source as /connect). /model openai, /model openai gpt-5.4-mini, /model anthropic, /model auto (server policy). The choice is saved for this profile (no keys) and sent with each turn; the server decides, and the status line shows what it actually ran. A provider that is not connected is refused with a /connect offer; if the server runs something else, you are told once. quox --provider openai does the same for one run. A trailing compact or full picks the prompt profile: compact is a short system prompt for small or local models (the default on Ollama, LM Studio and vLLM), full is the default elsewhere; --prompt-profile does the same for one --print run.

Awareness

Command	What it does
/roster [all]	show or hide the live roster under the status line; all includes background work The roster lists what needs you: pending approvals, then work you started (objectives, loops, manual workflows). Scheduled and event-driven workflows are hidden; background failures show once per workflow in the bar below. /roster all shows everything. Refreshed every 15 s from the server. Down on an empty composer focuses it; Enter peeks, s asks to stop (y confirms), Esc returns. A source the server cannot answer shows nothing and is named here.
/agents <name>	an agent's card: role, tools, slot, last action and its WARD witness
/memory <query>	facts Quox remembers, each with where it came from, age, trust and conflicts
/observers	LUCID situation, what changed since you last looked, what Quox records about its own learning Facts only, read from persisted data: the LUCID situation (without moving your cursor), recent changes, lessons taught, and the reflect / learn / insight counters. Nothing is summarised by a model.

Generated from the quox client registry at c484f2178 (quoxcli 0.2.0).

A few worth knowing by name:

• /model shows which AI providers are connected and picks the one for your next turns. The server decides, and the status line shows what actually ran.
• /capabilities asks your Quox what it can do here: ready, needs setup, not available, or planned, with how to set up each gap.
• /copy puts the last answer (or its last code block) on your clipboard.
• /sound sets the earcons for approvals, failures and long turns. It is the same setting as the dashboard.
• /note jots an observation for the dev observer. It is not sent to Quox.
• /eye makes the Q open its eye and blink.

Managing the conversation:

• /clear starts a fresh conversation on a clear screen. Your rules, agent, model choice and memory stay, and the old conversation is kept on the server.
• /resume picks a recent conversation and carries on where it left off. Give it an id or a /rename name to go straight there.
• /compact has the server summarise the conversation, keeping decisions, so later turns start from the summary. /compact show prints the whole summary.
• /restart re-runs the latest installed quox in this terminal and resumes this conversation. During a turn it asks first.
• /gripe <text> files a GitHub issue through the GRIPE agent, the same governed path as quox gripe. It shows what it would file and asks before filing.

Knowing where you stand:

• /status shows your profile, org, server and its health, model, agent and version. The model shown is what the server reported running, not what was asked for.
• /cost counts tokens and cost per model for this session, only from what the server reported. When the server gives no cost, it stays blank and says so.
• /context shows the model, conversation tokens, rules, skills, memory and the attached agent.
• /doctor runs the quox doctor checks plus chat checks, as rows.
• /config opens a settings card for theme, motion, verbose and model, saved on this profile.

Agents, memory and workflows:

• /agents <name> shows an agent’s card: role, tools, slot, and its last action with the WARD witness.
• /memory <query> lists facts Quox remembers, each with where it came from, its age, trust and conflicts.
• /workflow <name> draws the steps of a workflow’s latest run with state, timings and human gates.
• /crystal <workflow> checks whether a workflow can become a Crystal, against the real rule: at least 3 runs, at least 80% successful, one action sequence.

Checking the evidence:

• /proof walks the evidence chain for the last tool call (AEE, AOCL, the tool, WARD), reading each link back from the server. A link only shows as confirmed when the read says so.
• /reconcile checks tool calls that ended with their effect unknown against the server’s record.

Planned

These are listed under “Coming” in /help and refuse to run until they are built.

Conversation

Command	What it does
/peek <id>	look up an envelope, task or agent by id
/aside	a read-only side question

Context

Command	What it does
/profile	switch profile or org without leaving

Generated from the quox client registry at c484f2178 (quoxcli 0.2.0).

Key	What it does
@mention	complete agents, hosts, tasks and receipts

Generated from the quox client registry at c484f2178 (quoxcli 0.2.0).

Approvals

When an action needs a human, a card appears in the conversation with the action, its scope and its risk. Press a to approve, d to deny, o to open it in the dashboard.

These single keys act only when your draft is empty, or after you press Tab to focus the card, so a stray a in a sentence cannot approve anything. Keys arm after 300 ms, nothing defaults to approve, and Enter never approves.

You can also approve later with /approvals, then /approve N or /deny N. Pending approvals also come first in the roster.

Protocol lines

Quox shows what the platform did, not only what the model said. Tool rows read as one line each: family, verb, result.

Mode	Shows
off	Collapses to the receipt line.
on (default)	Adds compact lines for the envelope (AEE), policy checks (AOCL) and the witness record (WARD) as they happen.
full	Adds the thinking stream.

Set it at start with --verbose, or during a session with /verbose.

Receipts

Actions Quox takes end with a receipt line, which can show as pending until the witness record lands. The CLI has a verb to check one receipt against the witness chain, quox governance ward verify --envelope <id>. We have not recorded that flow for this site yet.