# Command-line reference

Every `akou` command with its help page, exactly as `akou help COMMAND` prints it, then the table of what each action is called through the command line, the HTTP API, MCP and the window. The page is generated from the code, and CI fails when it differs.

Exit codes: 0 ok, 3 nothing live, 64 usage, 65 bad vocabulary term, 69 unavailable, 70 software, 75 already recording, 77 permission, 78 the settings refuse it, 124 timed out, 130 interrupted.

## start

```
akou start: Start a call; answers once audio is being written

usage: akou start [-w WORKSPACE] [-t TITLE…] [--template T] [--call system|app:ID|none] [--mic ID|none] [--vocab TERM,…] [--live MODEL] [--review MODEL] [--review-every S] [--final MODEL] [--without-models] [--attach] [--json]

  -w, --workspace WS    the workspace the call goes in
  -t, --title TITLE     the call's title
      --template T      the notes template for this call
      --call SRC        what the call side records: system (default), app:ID or none
      --mic ID          the microphone: a device id or none
      --vocab A,B       words for this call only, comma-separated
      --live MODEL      the live model for this call only: auto, a model id from `akou models list`, nemotron or parakeet (default: asr.live); upgrade, the old spelling, is nemotron with --review qwen
      --review MODEL    the second pass for this call only: none, a model id, qwen or parakeet (default: asr.review.model)
      --review-every S  how often the second pass reviews, seconds, 30 to 600 (default: asr.review.everySeconds)
      --final MODEL     the final pass's model for this call only: auto, qwen, parakeet, a model id, or fusion for the fusion preset's engines with their words combined (default: asr.final.model)
      --without-models  record audio now and transcribe later, before the models are downloaded
      --attach          if a call is already recording, answer with that call (exit 0) instead of exit 75
      --json            print the answer as JSON, errors included
  -h, --help            show this help
      --restart         if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou start -w work -t "Weekly sync" --vocab Kubernetes,Terraform
example: akou start --live nemotron
example: akou start --live nemotron --review qwen --review-every 120
example: akou start --final fusion
example: akou start --attach --json
```

## stop

```
akou stop: Stop the live call

usage: akou stop [-c CALL] [--json]

  -c, --call CALL  live, last or a call id (default: live)
      --json       print the answer as JSON, errors included
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou stop
```

## pause

```
akou pause: Pause the live call

usage: akou pause [-c CALL] [--json]

  -c, --call CALL  live, last or a call id (default: live)
      --json       print the answer as JSON, errors included
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou pause
```

## resume

```
akou resume: Resume the paused call

usage: akou resume [-c CALL] [--json]

  -c, --call CALL  live, last or a call id (default: live)
      --json       print the answer as JSON, errors included
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou resume
```

## mute

```
akou mute: Mute your microphone in the live call

usage: akou mute [-c CALL] [--json]

  -c, --call CALL  live, last or a call id (default: live)
      --json       print the answer as JSON, errors included
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou mute
```

## unmute

```
akou unmute: Unmute your microphone

usage: akou unmute [-c CALL] [--json]

  -c, --call CALL  live, last or a call id (default: live)
      --json       print the answer as JSON, errors included
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou unmute
```

## restart

```
akou restart: Start a new part in the same call, make before break

usage: akou restart [--force] [-c CALL] [--json]

      --force      restart even when the capture looks healthy
  -c, --call CALL  live, last or a call id (default: last)
      --json       print the answer as JSON, errors included
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou restart
```

## status

```
akou status: The app, the live call, health, recognizer lag, models, provider, sharing

usage: akou status [--json]

      --json     print the answer as JSON, errors included
  -h, --help     show this help
      --restart  if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou status
example: akou status --json
```

## open

```
akou open: Show the window on a call, opening it if akou runs headless; with no desktop shell (Linux tarball, source checkout), print its address for a browser

usage: akou open [CALL | -c CALL] [--json]

  -c, --call CALL  live, last or a call id (default: the window's own choice)
      --json       print the answer as JSON, errors included
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou open
example: akou open last
```

## calls

```
akou calls: List calls by date, title and duration (no content search), rename one, or empty the trash

usage: akou calls [-w WORKSPACE] [--limit N] [--failed] [--json] | akou calls rename CALL TITLE… [--json] | akou calls empty-trash [--yes] [--json]

  -w, --workspace WS  only calls in this workspace
      --limit N       at most N calls, newest first
      --failed        only calls whose start failed (nothing was recorded), instead of the others
  -c, --call CALL     live, last or a call id (default: none; name one)
      --yes           with empty-trash: delete without asking (needed when stdin is not a terminal)
      --json          print the answer as JSON, errors included
  -h, --help          show this help
      --restart       if akou takes the connection and never answers, restart it first, even for a command that only reads

calls empty-trash deletes every call in the trash for good, now, instead of 30 days after it was trashed; it cannot be undone. On a terminal it asks first; elsewhere it needs --yes.

example: akou calls -w work --limit 5
example: akou calls rename last Weekly sync
example: akou calls empty-trash --yes
```

## workspaces

```
akou workspaces: List the workspaces, empty ones included, with how many calls each holds

usage: akou workspaces [--json]

      --json     print the answer as JSON, errors included
  -h, --help     show this help
      --restart  if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou workspaces
```

## workspace

```
akou workspace: Add a workspace, so it exists before its first call

usage: akou workspace add NAME [--json]

      --json     print the answer as JSON, errors included
  -h, --help     show this help
      --restart  if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou workspace add Personal
```

## show

```
akou show: One call's transcript

usage: akou show CALL | -c CALL [--layer best|live|final] [--format md|json|txt] [--json]

  -c, --call CALL  live, last or a call id (default: none; name one)
      --layer L    best (default), live or final
      --format F   md (default), txt or json
      --json       print the answer as JSON, errors included
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou show last --format txt
example: akou show -c last
```

## finalize

```
akou finalize: Run the accurate final pass on an ended call

usage: akou finalize [CALL | -c CALL] [--force] [--model qwen|parakeet|fusion] [--json]

  -c, --call CALL    live, last or a call id (default: last)
      --force        run it again on a call that already has a final layer
      --model MODEL  the model for this run only: qwen, parakeet, or fusion for the fusion preset's engines (default: asr.final.model)
      --json         print the answer as JSON, errors included
  -h, --help         show this help
      --restart      if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou finalize last --force
example: akou finalize last --force --model qwen
```

## enhance

```
akou enhance: Write enhanced notes with the configured provider (on a live call: so far)

usage: akou enhance [--template T] [-c CALL] [--json]

      --template T  the template the notes follow
  -c, --call CALL   live, last or a call id (default: last)
      --json        print the answer as JSON, errors included
  -h, --help        show this help
      --restart     if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou enhance --template standup
```

## templates

```
akou templates: List the note templates, or print one as the enhanced notes would use it

usage: akou templates list | akou templates show NAME   [--json]

      --json     print the answer as JSON, errors included
  -h, --help     show this help
      --restart  if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou templates list
example: akou templates show standup
```

## quit

```
akou quit: Stop the app cleanly (the live call is stopped and its log ended first)

usage: akou quit [--json]

      --json     print the answer as JSON, errors included
  -h, --help     show this help
      --restart  if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou quit
```

## tail

```
akou tail: Committed lines with wall times; -f follows the call until it ends

usage: akou tail [-c CALL] [-f] [--since SEQ] [--last 5m] [--format txt|md|json] [--json]

  -c, --call CALL  live, last or a call id (default: live)
  -f, --follow     keep printing until the call ends
      --since SEQ  lines after this cursor
      --last 5m    lines from the last 90s, 5m or 1h
      --format F   txt (default), md or json (one row per line)
      --json       same as --format json
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou tail -f --last 2m
```

## events

```
akou events: The call's log events as JSON lines, one object per line; -f follows until it ends

usage: akou events [-c CALL] [-f] [--type T,…] [--since SEQ] [--mention] [--client NAME]

  -c, --call CALL    live, last or a call id (default: live)
  -f, --follow       keep printing until the call ends
      --type T,…     only these event types: health,seg,ask,answer,share.started,share.stopped
      --client NAME  who is following (claude-code); with -f and ask, questions typed in the ask box go to you first
      --since SEQ    events after this cursor (default: all)
      --mention      also a mention row when user.name is said on the call channel: time and speaker, never the text
      --json         accepted; the output is always JSON lines
  -h, --help         show this help
      --restart      if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou events -f --type ask,health,share.started,share.stopped --mention --client claude-code
example: akou events -f --type health,answer
example: akou events -c last --since 120
example: akou events -f --type health,share.started,share.stopped --mention
```

## context

```
akou context: Print the context pack an agent answers from (no model is called)

usage: akou context "QUESTION" [-c CALL] [--budget N] [--json]

  -c, --call CALL  live, last or a call id (default: live)
      --budget N   the most tokens the pack may use
      --json       print the answer as JSON, errors included
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou context "what did we decide about the release?" --budget 4000
```

## ask

```
akou ask: Answer a question with akou's configured provider (excerpts when it cannot)

usage: akou ask "QUESTION" | akou ask --preset NAME [--speaker NAME]   [-c CALL] [--json]

  -c, --call CALL     live, last or a call id (default: live)
      --preset NAME   ask a preset's question instead (`akou presets list` names them)
      --speaker NAME  with --preset: the speaker a per-speaker preset asks about
      --json          print the answer as JSON, errors included
  -h, --help          show this help
      --restart       if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou ask "what did we decide about the release?"
example: akou ask --preset decisions
example: akou ask --preset speaker --speaker Ben
```

## answer

```
akou answer: Answer a question typed in the ask box, as the agent following the call

usage: akou answer ASK "TEXT" | akou answer ASK -   [-c CALL] [--client NAME] [--model M] [--json]

  -c, --call CALL    live, last or a call id (default: live)
      --client NAME  who answers (claude-code); shown in the box
      --model M      the model that wrote the answer, if you know it
      --json         print the answer as JSON, errors included
  -h, --help         show this help
      --restart      if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou answer q0007 "We agreed to ship on Friday [15:41 Ben]." -c 01J8Z3
example: akou answer q0007 - < answer.txt
```

## presets

```
akou presets: List the ask presets: the shipped questions and your own files

usage: akou presets list [--json]

      --json     print the answer as JSON, errors included
  -h, --help     show this help
      --restart  if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou presets list
```

## search

```
akou search: Exact word hits in a call, with wall times

usage: akou search "QUERY" [-c CALL] [-k N] [--json]

  -c, --call CALL  live, last or a call id (default: live)
  -k, --k N        at most N hits (default 5)
      --json       print the answer as JSON, errors included
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou search migration -k 3
```

## wait

```
akou wait: Block until a call reaches final.done, enhanced or exported (69 unavailable, 70 failed, 124 timeout)

usage: akou wait [CALL | -c CALL] --for final.done|enhanced|exported [--timeout 30m] [--json]

  -c, --call CALL    live, last or a call id (default: last)
      --for STAGE    final.done, enhanced or exported
      --timeout 30m  give up after 90s, 30m or 1h (exit 124)
      --json         print the answer as JSON, errors included
  -h, --help         show this help
      --restart      if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou wait --for final.done
example: akou wait -c last --for enhanced --timeout 1h
```

## watch

```
akou watch: Follow a call in the terminal and ask it questions as it runs

usage: akou watch [-c CALL]

  -c, --call CALL  live, last or a call id (default: live, else last)
      --json       exits 64: watch is for a terminal; `akou tail -f --json` streams JSON
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou watch
example: akou watch -c last
```

## name

```
akou name: Name a speaker, or merge and unmerge speakers

usage: akou name SPK NAME… | akou name --merge A B | akou name --unmerge SPK   [-c CALL] [--json]

      --merge      merge speaker A into speaker B
      --unmerge    undo a merge of this speaker
  -c, --call CALL  live, last or a call id (default: live)
      --json       print the answer as JSON, errors included
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou name c2 Ben Carter
example: akou name --merge c3 c2
```

## note

```
akou note: Add a line to the call's notepad, or edit or delete one

usage: akou note "TEXT" | akou note --edit ID "TEXT" | akou note --del ID   [-c CALL] [--json]

  -c, --call CALL  live, last or a call id (default: live)
      --edit ID    replace the text of this note
      --del ID     delete this note
      --json       print the answer as JSON, errors included
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou note "ship on Friday"
example: akou note --edit n0001 "ship on Thursday"
```

## remember

```
akou remember: Keep a line for the agent's later turns, or retract one with --del

usage: akou remember "TEXT" | akou remember --del ID   [-c CALL] [--json]

      --del ID     retract this line
  -c, --call CALL  live, last or a call id (default: live)
      --json       print the answer as JSON, errors included
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou remember "Ben owns the deploy"
```

## export

```
akou export: Hand a finished call off to the export folder (Markdown, event log, audio)

usage: akou export [CALL | -c CALL] [--to DIR] [--json]

  -c, --call CALL  live, last or a call id (default: last)
      --to DIR     export here instead of export.dir
      --json       print the answer as JSON, errors included
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou export last --to ~/notes/calls
```

## hooks

```
akou hooks: Re-run the hand-off hooks of a call

usage: akou hooks run CALL | -c CALL [--stage call.ended|final.done|enhanced] [--json]

  -c, --call CALL  live, last or a call id (default: none; name one)
      --stage S    only this stage's hooks
      --json       print the answer as JSON, errors included
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou hooks run last --stage final.done
```

## import

```
akou import: Convert hark-viewer call folders (every part) into akou calls

usage: akou import hark-viewer DIR… [-w WORKSPACE] [--json]

  -w, --workspace WS  the workspace the calls go in
      --json          print the answer as JSON, errors included
  -h, --help          show this help
      --restart       if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou import hark-viewer ~/Recordings/calls/work -w work
```

## jobs

```
akou jobs: The file transcription jobs on this akou, or those your key sees on a server

usage: akou jobs list [--status queued|running|done|failed|cancelled]   [--json]

      --status STATE  only the jobs in this state: queued, running, done, failed, cancelled
      --json          print the answer as JSON, errors included
  -h, --help          show this help
      --restart       if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou jobs list
example: akou jobs list --status failed --json
```

## vocab

```
akou vocab: The custom vocabulary: list, add, fix, remove, approve, reject, suggest, check, import, pass

usage: akou vocab list|add|fix|remove|approve|reject|suggest|check|import|pass … [-c CALL] [-w WS] [--json]

  -w, --workspace WS  the workspace's list
  -c, --call CALL     a call's own words instead of the workspace list (live, last or a call id)
      --unconfirmed   list: only the words waiting for your yes
      --dictation     list, approve, reject: the words fixed while dictating
      --heard A,B     add, fix: how the recognizer mishears it
      --no-decode     add: correct it when read, but do not bias the recognizer
      --note TEXT     add: a note kept with the entry
      --text TEXT     suggest: propose words from this text
  -k, --k N           suggest: at most N words
      --json          print the answer as JSON, errors included
  -h, --help          show this help
      --restart       if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou vocab list -w work
example: akou vocab list -c last --unconfirmed
example: akou vocab add Hetzner --heard hetzna,hetsner -w work
example: akou vocab add Kubernetes -c live
example: akou vocab fix Vercel --heard versal
example: akou vocab remove Hetzner -w work
example: akou vocab approve Hetzner -c last
example: akou vocab reject Hetsner -c last
example: akou vocab list --dictation
example: akou vocab approve Kubernetes --dictation
example: akou vocab suggest --text "we deploy on Hetzner with Terraform" -k 5
example: akou vocab check Hetzner
example: akou vocab import glossary.txt -w work
example: akou vocab pass last
```

## doctor

```
akou doctor: Check models, the helper, the token, the API, permissions and harness discovery

usage: akou doctor [--grant [GRANT]] [--json]

      --grant    on a terminal, ask the OS for the first missing grant, or the one named (mic, system-audio, accessibility), or open its settings pane
      --json     print the answer as JSON, errors included
  -h, --help     show this help
      --restart  if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou doctor
example: akou doctor --grant
example: akou doctor --grant system-audio
```

## config

```
akou config: Show, get, set or unset a setting (validated by the settings registry)

usage: akou config show | akou config get KEY | akou config set KEY VALUE | akou config set KEY - (the value on stdin; required for secrets) | akou config unset KEY   [--json]

      --json     print the answer as JSON, errors included
  -h, --help     show this help
      --restart  if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou config show
example: akou config get agent.summary_every_minutes
example: akou config set asr.threads 4
example: printf '%s' "$KEY" | akou config set provider.apiKey -
example: akou config unset asr.threads
```

## token

```
akou token: Where the API token is, or rotate it (the running app follows at once)

usage: akou token path | akou token rotate   [--json]

      --json     print the answer as JSON, errors included
  -h, --help     show this help
      --restart  if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou token path
example: akou token rotate
```

## models

```
akou models: The speech models: list, pull (download, checksummed), delete, or import from a folder

usage: akou models list | akou models pull [PRESET|MODEL] | akou models delete MODEL | akou models import DIR   [--json]
  PRESET is lite, fast, best, fusion or auto; MODEL is an id from `akou models list`.
  list, pull and import need no app running: an image build or an entrypoint pulls before the
  server starts. delete asks the running akou, which refuses the default model and one in use.

      --json     print the answer as JSON, errors included
  -h, --help     show this help
      --restart  if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou models list
example: akou models pull fast
example: akou models pull
example: akou models delete qwen3-asr-1.7b
example: akou models import /Volumes/usb/akou-models
```

## share

```
akou share: A read-only live link to the call

usage: akou share on|off|status [-c CALL] [--bind tailnet|lan|IP] [--notes] [--expires 3h] [--json]

  -c, --call CALL   live, last or a call id (default: live; `off` without it stops every share)
      --bind WHERE  tailnet, lan or an address (default: tailnet)
      --notes       share the notepad too
      --expires 3h  turn the link off after this long
      --json        print the answer as JSON, errors included
  -h, --help        show this help
      --restart     if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou share on --bind tailnet --expires 3h
example: akou share status
example: akou share off
```

## devices

```
akou devices: Microphones and outputs, with the ids --mic takes

usage: akou devices [--json]

      --json     print the answer as JSON, errors included
  -h, --help     show this help
      --restart  if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou devices
example: akou devices --json
```

## apps

```
akou apps: Apps with audio, with the ids --call app:ID takes

usage: akou apps [--json]

      --json     print the answer as JSON, errors included
  -h, --help     show this help
      --restart  if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou apps
example: akou apps --json
```

## self-update

```
akou self-update: Update the Linux CLI tarball

usage: akou self-update

      --json     print the answer as JSON, errors included
  -h, --help     show this help
      --restart  if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou self-update

not built yet: self-update exists only in the Linux CLI tarball (M4), which is not built yet
```

## keys

```
akou keys: Create, list, update or revoke the API keys of server mode and of the desktop app's network listener (no app needed)

usage: akou keys create --name NAME [--scope jobs|read|admin ...] [--callback-host HOST ...] | akou keys list | akou keys update ID --callback-host HOST ... | akou keys revoke ID   [--json]

      --name NAME           create: who the key is for, shown in the audit
      --scope S             create: jobs (default: submit and read its own jobs), read (every call, dictation and job, read only) or admin; repeat it for several
      --callback-host HOST  create, update: a host its callback URLs may name; repeat it, or `*` for any public host
      --json                print the answer as JSON, errors included
  -h, --help                show this help
      --restart             if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou keys create --name archive --callback-host archive.lan
example: akou keys create --name phone --scope jobs --scope read
example: akou keys list
example: akou keys update key_0123abcd --callback-host archive.lan --callback-host viewer.lan
example: akou keys revoke key_0123abcd
```

## admin

```
akou admin: Set the web UI's admin password in server mode, read from standard input

usage: akou admin set-password < password-file   [--json]

      --json     print the answer as JSON, errors included
  -h, --help     show this help
      --restart  if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou admin set-password < password.txt
```

## transcribe

```
akou transcribe: Transcribe an audio file on this akou, or on a server (AKOU_URL), and print the text

usage: akou transcribe FILE [--preset lite|fast|best|fusion|auto] [--language L] [--diarize] [--keyword WORD…] [--keywords-file PATH] [--priority N] [--json]

      --preset P            lite, fast, best, fusion, auto (default auto)
      --language L          a BCP-47 tag such as en or es-ES, or auto
      --diarize             label the speakers
      --keyword WORD        a name or term the recognizer should expect; repeat for more (at most 24 in all)
      --keywords-file PATH  more keywords, one per line
      --priority N          -10 to 10 (default 0); a higher job runs before every lower one queued
      --json                print the answer as JSON, errors included
  -h, --help                show this help
      --restart             if akou takes the connection and never answers, restart it first, even for a command that only reads

The desktop app on this machine transcribes the file itself, with no setting to turn on.
Long audio is cut at its pauses, so a long recording works, up to server.max_audio_minutes
(240). The command waits until the job ends; Ctrl-C cancels it.
The job then stays in `akou jobs list` for server.retain_days.
AKOU_URL sends the file to an akou server instead, with the key in AKOU_API_KEY or in the
file AKOU_API_KEY_FILE names; the server deletes the job once the text is printed.
Exit codes: 0 done (no speech prints nothing), 64 usage, 69 no akou to reach, 70 the job failed.

example: akou transcribe voice-note.ogg
example: akou transcribe call.m4a --preset best --language es --diarize
example: AKOU_URL=https://akou.example AKOU_API_KEY_FILE=~/.config/akou-key akou transcribe note.ogg
example: akou transcribe call.m4a --keywords-file terms.txt --priority 5
```

## dictate

```
akou dictate: Transcribe a clip through the dictation path, or start and stop a dictation

usage: akou dictate FILE [--engine auto|fast|best|live|remote] [--language L]   [--json]
       akou dictate start|toggle [--language L]   [--json]
       akou dictate stop|cancel   [--json]
       akou dictate --remote-test   [--json]

      --engine E     auto, fast, best, live, remote (default auto)
      --language L   a BCP-47 tag such as en or es-ES, or auto, for the clip or the session start opens; the fast engine detects it itself
      --remote-test  test dictation.remote.url with its key: mode, engine, accelerator, round trip
      --json         print the answer as JSON, errors included
  -h, --help         show this help
      --restart      if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou dictate note.wav
example: akou dictate note.wav --json
example: akou dictate toggle
example: akou dictate start --language es
example: akou dictate --remote-test
```

## dictations

```
akou dictations: The dictation history: list, show, retry or delete dictations

usage: akou dictations list [--since 24h] [-q TEXT] [--limit N]   [--json]
       akou dictations show ID   [--json]
       akou dictations retry ID --engine auto|fast|best|live|remote [--language L]   [--json]
       akou dictations delete ID | --all   [--json]

      --since 24h    only dictations from the last 90s, 5m or 1h
  -q, --search TEXT  only dictations whose text holds TEXT (any case)
      --limit N      at most N dictations (default 100)
      --all          with delete: every dictation
      --engine E     with retry: auto, fast, best, live, remote
      --language L   with retry: decode in this language (en, es); best and remote take it, fast detects its own
      --json         print the answer as JSON, errors included
  -h, --help         show this help
      --restart      if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou dictations list
example: akou dictations list --since 24h --json
example: akou dictations show d1
example: akou dictations retry d1 --engine best
example: akou dictations retry d1 --engine best --language es
example: akou dictations delete d1
```

## skill

```
akou skill: Install the akou skills into Claude Code's or Codex's skills folder and register the akou tools with it, or uninstall both

usage: akou skill install|uninstall [--harness claude|codex] [--dir DIR] [--json]

      --harness H  claude or codex (default: every one installed)
      --dir DIR    install into this skills folder instead
      --json       print the answer as JSON, errors included
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou skill install --harness claude
example: akou skill uninstall
```

## mcp

```
akou mcp: Serve MCP on stdin and stdout for an agent (a thin client of the local API)

usage: akou mcp [--read-only]

      --json       ignored: MCP already speaks JSON-RPC on stdout
      --read-only  list only the tools that change nothing; AKOU_MCP_READONLY=1 does the same
  -h, --help       show this help
      --restart    if akou takes the connection and never answers, restart it first, even for a command that only reads

AKOU_URL serves a remote akou instead of the app here; a plain http AKOU_URL to another machine is refused (the key would cross the network unencrypted) unless AKOU_ALLOW_HTTP=1.

example: akou mcp
example: akou mcp --read-only
```

## serve

```
akou serve: Run the akou server in the foreground (server mode, no window) until Ctrl-C

usage: akou serve

      --json     print the answer as JSON, errors included
  -h, --help     show this help
      --restart  if akou takes the connection and never answers, restart it first, even for a command that only reads

example: akou serve
```

## Door parity

| Action | CLI | API | MCP | Window |
| --- | --- | --- | --- | --- |
| Start recording | `start` | `POST /calls` | `akou_start` | `src/ui/app.ts` |
| Stop | `stop` | `POST /calls/:id/stop` | `akou_stop` | `src/ui/app.ts` |
| Pause and resume | `pause`, `resume` | `POST /calls/:id/pause`, `POST /calls/:id/resume` | `akou_pause`, `akou_resume` | `src/ui/app.ts` |
| Mute and unmute | `mute`, `unmute` | `POST /calls/:id/mute`, `POST /calls/:id/unmute` | `akou_mute`, `akou_unmute` | `src/ui/app.ts` |
| Restart | `restart` | `POST /calls/:id/restart` | `akou_restart` | `src/ui/app.ts` |
| Status | `status` | `GET /status` | `akou_status` | `src/ui/window.ts` |
| Read and follow the transcript | `tail`, `show`, `watch` | `GET /calls/:id/transcript`, `GET /calls/:id/events`, `GET /calls/:id/stream` | `akou_read`, `akou_get_call` | `src/ui/window.ts`, `src/ui/app.ts` |
| Follow the event log as JSON lines | `events` | `GET /calls/:id/events`, `GET /calls/:id/stream` | none: an agent is pushed the events by the plugin monitor (PG-K3), which runs it | none: the raw log is for programs; the window shows the call it describes |
| Wait for a stage after the call | `wait` | `GET /calls/:id/events` | none: an agent follows GET /calls/{id}/events or akou\_read; there is no akou\_wait (PG-S5) | none: the window shows each stage as it happens and never blocks on one |
| One call's record | none: `show` prints the transcript; no command prints the record itself | `GET /calls/:id` | none: the tools read it internally (akou\_vocab\_propose, akou\_enhanced\_put); none returns it | none: the window builds its view from the call list and the followed log |
| Context pack | `context` | `POST /calls/:id/context` | `akou_context` | `src/ui/ask.ts` |
| Ask | `ask` | `POST /calls/:id/ask` | `akou_ask` | `src/ui/window.ts` |
| Answer a question typed in the ask box, as the agent following the call | `answer` | `POST /calls/:id/asks/:ask/answer` | `akou_answer` | none: the window is where the user asks; the agent following the call answers, and the box shows it |
| Start the harness before a question | none: `akou ask` sends its question at once: there is no typing for the start to overlap | `POST /provider/warm` | none: an agent sends its question at once: there is no typing for the start to overlap | `src/ui/ask.ts` |
| Ask presets | `presets`, `ask` | `GET /presets` | none: the presets are MCP prompts, not tools: prompts/list and prompts/get (PG-M7) | `src/ui/ask.ts` |
| Search one call | `search` | `GET /calls/:id/search` | `akou_search` | none: find in the call is designed in docs/ux/WINDOW.md and not built |
| Name, merge and unmerge speakers | `name` | `POST /calls/:id/speakers`, `POST /calls/:id/speakers/merge`, `POST /calls/:id/speakers/unmerge` | `akou_name_speaker`, `akou_merge_speakers`, `akou_unmerge_speaker` | `src/ui/app.ts` |
| Add and read notes | `note` | `POST /calls/:id/notes`, `GET /calls/:id/notes` | `akou_add_note`, `akou_get_notes` | `src/ui/notepad.ts` |
| Edit and delete a note | `note` | `PATCH /calls/:id/notes/:nid`, `DELETE /calls/:id/notes/:nid` | `akou_edit_note`, `akou_delete_note` | `src/ui/notepad.ts` |
| Memory | `remember` | `POST /calls/:id/remember`, `DELETE /calls/:id/remember/:rid` | `akou_remember`, `akou_forget` | none: no row for it in docs/ux/WINDOW.md yet |
| Memo | none: CLI-28 designs it | `GET /calls/:id/memo`, `PUT /calls/:id/memo` | `akou_memo_get`, `akou_memo_put` | none: no memo pane is built |
| Vocabulary: add, propose, approve, reject, list | `vocab` | `GET /vocab`, `POST /vocab`, `POST /vocab/approve`, `POST /vocab/reject`, `GET /calls/:id/vocab`, `POST /calls/:id/vocab` | `akou_vocab_add`, `akou_vocab_propose`, `akou_vocab_approve`, `akou_vocab_reject`, `akou_vocab_list` | `src/ui/review.ts`, `src/ui/dictation-dictionary.ts` |
| Fix a line or a word once: the whole call reads it, a term is learned, a rewording noted | `vocab` | `POST /calls/:id/fix`, `POST /calls/:id/fix/undo`, `POST /calls/:id/fix/forget` | `akou_vocab_add` | `src/ui/app.ts` |
| Words fixed while dictating: review, accept, reject (DC-L5) | `vocab` | `GET /vocab`, `POST /vocab/approve`, `POST /vocab/reject` | `akou_vocab_list` | `src/ui/dictation-review.ts` |
| Vocabulary: remove a word | `vocab` | `DELETE /vocab/:term`, `DELETE /calls/:id/vocab/:vid`, `POST /vocab/restore` | none: no tool yet, and no design item names one | `src/ui/dictation-dictionary.ts` |
| Vocabulary: suggest and check | `vocab` | `POST /vocab/suggest`, `POST /vocab/check` | `akou_vocab_suggest`, `akou_vocab_check` | none: the window reviews proposed words; suggestions come from an agent or the CLI |
| Vocabulary pass over a finished call | `vocab` | `POST /calls/:id/vocab/pass` | none: no tool yet, and no design item names one | none: the window fixes a word on its line; the pass is left to the CLI and scripts |
| Import a vocabulary file | `vocab` | `POST /vocab/import` | none: no tool yet, and no design item names one | none: no control yet, and no design item names one |
| Enhance | `enhance` | `POST /calls/:id/enhance`, `GET /calls/:id/enhanced` | `akou_enhance` | none: hidden from the window on purpose; notes already written stay in the export and GET /calls/:id/enhanced |
| Agent-written notes | none: CLI-28 designs it | `GET /calls/:id/enhance/context`, `PUT /calls/:id/enhanced` | `akou_enhance_context`, `akou_enhanced_put` | none: an agent writes them; the export carries them, the window does not show them |
| Final pass | `finalize` | `POST /calls/:id/finalize` | `akou_finalize` | none: no run-again control yet (docs/ux/WINDOW.md) |
| Export | `export` | `POST /calls/:id/export` | `akou_export` | none: the hand-off runs by itself after every call; the window has no export control |
| Run the hooks again | `hooks` | `POST /calls/:id/hooks` | none: no tool yet, and no design item names one | none: no control yet, and no design item names one |
| List calls | `calls` | `GET /calls` | `akou_list_calls` | `src/ui/app.ts` |
| Rename a call | `calls` | `PATCH /calls/:id` | `akou_rename_call` | `src/ui/app.ts` |
| Trash and restore a call | none: missing: CLI-26 adds calls delete and calls restore | `DELETE /calls/:id`, `POST /calls/:id/restore` | none: missing: PG-M4 names move, delete and restore (CLI.md doors table) | `src/ui/app.ts` |
| Empty the trash: delete trashed calls for good, now | `calls` | `GET /trash`, `DELETE /trash` | none: deleting calls for good is the user's, behind a confirmation; PG-M4 names no tool for it | `src/ui/app.ts` |
| Change who spoke one line | none: missing: CLI-29 adds edit SEG --speaker | `PATCH /calls/:id/segments/:sid` | none: no tool yet, and no design item names one | none: missing: W4.10 adds the speaker picker on a line |
| List and add workspaces | `workspaces`, `workspace` | `GET /workspaces`, `POST /workspaces` | none: not one call's: akou\_start names the workspace and makes its folder, and akou\_list\_calls shows each call's | `src/ui/workspaces.ts` |
| Share a live link | `share` | `GET /share`, `POST /share`, `DELETE /share` | `akou_share_on`, `akou_share_off`, `akou_share_status` | `src/ui/app.ts` |
| Templates | `templates` | `GET /templates`, `GET /templates/:name` | `akou_template_list`, `akou_template_get` | none: the window always uses the automatic choice and has no Enhanced tab; scripts pick one through the API or --template |
| Settings | `config` | `GET /config`, `PATCH /config` | `akou_config_get` | `src/ui/settings-page.ts` |
| Speech models | `models` | `GET /models`, `POST /models/pull`, `POST /models/cancel`, `DELETE /models/:id`, `POST /models/import` | none: no tool: the Models page and `akou models` own downloads and deletes; akou\_status reports the models in use | `src/ui/models-card.ts`, `src/ui/models-page.ts`, `src/ui/live-picker.ts` |
| Choose the live transcript's model (asr.live) and its second pass (asr.review.\*), and see what a call runs | `config`, `start`, `models`, `status` | `PATCH /config`, `POST /calls`, `GET /models`, `GET /status` | `akou_status` | `src/ui/models-page.ts`, `src/ui/live-picker.ts`, `src/ui/app.ts` |
| Open the window | `open` | `POST /window` | `akou_open_window` | none: it is the window |
| Play the audio | none: playback happens in the window | `GET /calls/:id/audio/:part` | none: playback happens in the window | `src/ui/window.ts` |
| Quit | `quit` | `POST /quit` | none: left out on purpose (PG-M4 exclusions) | `src/main/window/shell.ts` |
| Import from hark-viewer | `import` | `POST /import/hark-viewer` | none: left out on purpose (PG-M4 exclusions) | none: a one-time migration; the CLI is enough |
| Devices and apps | `devices`, `apps` | `GET /devices`, `GET /apps` | `akou_devices` | `src/ui/dictation-mic.ts`, `src/ui/settings-page.ts`, `src/ui/call-picker.ts` |
| Update the CLI | `self-update` | none: the CLI replaces its own binary; not built yet | none: touches only akou's own folders or the terminal (docs/ux/CLI.md section 14) | none: the app's update notice is DK-U1 |
| What this akou is and can do | none: a program reads it before it offers presets; the CLI already knows its akou | `GET /server`, `GET /openapi.json` | none: the MCP server talks to the akou it was installed with | none: the window is the app itself |
| Transcribe a file as a job (server mode) | `transcribe`, `jobs` | `POST /jobs`, `GET /jobs`, `GET /jobs/:id`, `GET /jobs/:id/result`, `DELETE /jobs/:id`, `GET /events`, `POST /audio/transcriptions` | `akou_transcribe`, `akou_job_get`, `akou_jobs_list`, `akou_job_delete` | `src/ui/server-jobs.ts` |
| Translate a file into English (server mode) | none: a program asks for it: `task=translate` on POST /jobs, or OpenAI's endpoint | `POST /audio/translations` | none: akou\_transcribe takes `task: translate`, the same job through POST /jobs | none: the Jobs page lists translate jobs as any other job |
| Transcribe for Bazarr (server mode, SV-C3) | none: Bazarr calls akou's endpoint itself; `akou transcribe` already takes a file | `POST /asr`, `POST /detect-language` | none: an agent transcribes through the job tools; this door speaks Bazarr's dialect | none: Bazarr is the window: it saves the subtitle next to the video |
| Name or rename a job (server mode) | none: a program names the jobs it submits, at submit or with PATCH; `akou jobs list` shows the name | `PATCH /jobs/:id` | none: an agent reads its jobs by id; SI-7 names no rename tool, and a title is for the Jobs page | none: the Jobs page shows each job's name and finds jobs by it; the program that submitted a job names it |
| Download a kept recording (server mode) | none: the client that recorded keeps its own copy until the server keeps one | `GET /jobs/:id/audio` | none: an agent reads a job's text; the audio is for the client that recorded it | none: the Jobs page lists jobs; the recording plays in the client that made it |
| Live words while a client records (server mode) | none: a WebSocket for a client that records, such as a phone; `scripts/live-client.ts` is its test client | `GET /live` | none: a tool call cannot hold a socket open while audio streams | none: server mode's web UI records nothing; the desktop app's live words are its own |
| Run the server in the foreground (server mode) | `serve` | none: it starts the API, so the API cannot start it | none: an agent does not start a server; the image or a service manager runs it | none: server mode has no window |
| Which key is calling | none: the CLI on the box uses the app's own token, which is admin | `GET /keys/me` | none: the MCP server uses the app's own token, which is admin | none: the window is the user's own, in process |
| API keys (server mode) | `keys` | `GET /keys`, `POST /keys`, `DELETE /keys/:id` | none: made by the operator, on the box or on the Keys page, not by an agent (SV-K2) | `src/ui/server-keys.ts` |
| Change a key's callback hosts (server mode) | `keys` | `PATCH /keys/:id` | none: made by the operator, on the box, not by an agent (SV-K2) | none: the Keys page creates and revokes; changing hosts is the CLI's and the API's (SV-K7) |
| Transcribe a clip through the dictation path | `dictate` | `POST /dictations` | none: MCP reads dictation history only; no tool feeds audio in (DICTATION.md DC-G5) | none: the window dictates with the key into the app under the cursor, not from a file |
| Dictation history | `dictations` | `GET /dictations`, `GET /dictations/:id` | `akou_dictation_list`, `akou_dictation_get` | `src/ui/dictation-history.ts` |
| Retry a dictation with another engine | `dictations` | `POST /dictations/:id/retry` | none: MCP reads dictation history only; a retry runs an engine on the user's audio (DICTATION.md DC-G5) | `src/ui/dictation-history.ts` |
| Open a dictation in the draft box | none: the draft box is a window the user reads and presses Enter in; a script reads the text with akou dictations show | `POST /dictations/:id/insert` | none: an agent never inserts text: it would land in whatever app the user is looking at (DICTATION.md DC-G5) | `src/ui/dictation-history.ts` |
| A dictation's audio | none: the audio is for Retry and the page; a script reads GET /v1/dictations/{id}/audio | `GET /dictations/:id/audio` | none: MCP reads dictation history only, as text (DICTATION.md DC-G5) | none: the History page has no player; Retry decodes the audio in the app |
| Delete dictations | `dictations` | `DELETE /dictations/:id`, `DELETE /dictations` | none: MCP reads dictation history only; deleting it is the user's (DICTATION.md DC-G5) | `src/ui/dictation-history.ts`, `src/ui/dictation-page.ts` |
| Start, stop and cancel a dictation | `dictate` | `POST /dictation/start`, `POST /dictation/stop`, `POST /dictation/cancel` | none: an agent never starts a dictation: its text is typed into whatever app the user is looking at (DICTATION.md DC-G5) | `src/main/window/shell.ts` |
| Dictation status | none: the tray and the Dictation page show it; `akou dictate toggle` reads it to pick start or stop | `GET /dictation` | none: MCP reads dictation history only (DICTATION.md DC-G5) | `src/ui/dictation-page.ts` |
| Follow dictation events | none: a script reads `akou dictations list --json`; a live stream is for the page and the pill | `GET /dictation/stream` | none: MCP reads dictation history only (DICTATION.md DC-G5) | none: the pill gets the session over the window's RPC; the stream serves the browser page |
| Test the remote dictation engine | `dictate` | `GET /dictation/remote-test` | none: the remote's key and URL are the user's settings, which no tool touches (DC-G5) | `src/ui/dictation-remote.ts` |
| The admin password (server mode) | `admin` | none: set on the box that runs akou, in its config file (SERVER.md SV-U1) | none: set on the box that runs akou, not by an agent (SV-U1) | none: set on the box that runs akou, in its config file (SERVER.md SV-U1) |
| Token, skill, doctor and the MCP server | `token`, `skill`, `doctor`, `mcp` | none: touches only akou's own folders or the terminal (docs/ux/CLI.md section 14) | none: touches only akou's own folders or the terminal (docs/ux/CLI.md section 14) | none: touches only akou's own folders or the terminal (docs/ux/CLI.md section 14) |
