> ## Documentation Index
> Fetch the complete documentation index at: https://unmute.ai/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Unmute compiles to exactly three targets. Pipecat and LiveKit are code targets: compile writes a Python project you run. SLNG is a hosted target: compile writes a deployment body and SLNG runs the agent, so it has no `unmute dev`. Those three are the only values `provider` accepts in `targets.yaml`. Deepgram and ElevenLabs appear in these docs as model vendors, which is not the same thing as a target, and `slng` is both.
> The Go structs in `internal/spec` and `internal/ir` are the schema truth. Check a field against them, or run `unmute validate`, rather than against what you remember.

# CLI reference

> The command tree, exit codes, warnings, version, and shell completion.

```text expandable wrap theme={null}
$ unmute --help
Author-once, portable voice agents.

Usage:
  unmute [flags]
  unmute [command]

Available Commands:
  compile     Compile a v1 agent package to its resolved target artifacts.
  completion  Generate the autocompletion script for the specified shell
  deploy      Compile a package and push it to SLNG.
  dev         Compile, run the agent locally, and talk to it in the browser.
  help        Help about any command
  init        Scaffold a new v1 agent package.
  manifest    Save organization contracts on this computer.
  pull        Fetch each SLNG-hosted tool's definition into the package.
  resources   List the tools, MCP servers and phone numbers your SLNG organisation offers.
  skill       Install the coding-agent skill into a project.
  validate    Validate a v1 agent package against its targets.

Flags:
  -h, --help      help for unmute
  -v, --version   version for unmute

Use "unmute [command] --help" for more information about a command.
```

## The six commands

| Command                               | What it does                                              |
| ------------------------------------- | --------------------------------------------------------- |
| [`init`](/reference/cli/init)         | scaffold a new package                                    |
| [`validate`](/reference/cli/validate) | check a package against its targets                       |
| [`pull`](/reference/cli/pull)         | fetch each SLNG-hosted tool's definition into the package |
| [`compile`](/reference/cli/compile)   | write the compiled project for each target                |
| [`dev`](/reference/cli/dev)           | compile, run locally, and talk to the agent               |
| [`deploy`](/reference/cli/deploy)     | validate, compile and push a package to SLNG              |

The first four take you from nothing to a voice you can talk to on your own
machine. `deploy` is the one that puts an agent somewhere else, and it is SLNG
only: a livekit or pipecat target compiles to a project that platform deploys
with its own tool.

## Saved company rules

| Command                                      | What it does                                 |
| -------------------------------------------- | -------------------------------------------- |
| [`manifest create`](/reference/cli/manifest) | create a reusable manifest with guided setup |
| [`manifest edit`](/reference/cli/manifest)   | edit a saved manifest with guided setup      |
| [`manifest use`](/reference/cli/manifest)    | choose the default for future agents         |

`init` uses the saved default automatically. Add `--manifest <name>` for direct
selection, or `--from-manifest` to open a picker for one new agent.
For a coding assistant, `init <agent> --manifest <name> --draft` creates an
unfinished package without prompts. The skill reads the copied rules, completes
the use case, then validates and compiles it. Follow the
[draft quickstart](/reference/cli/init#quickstart) for commands and a copyable
assistant brief.

## Two commands off that path

| Command                                 | What it does                                                                |
| --------------------------------------- | --------------------------------------------------------------------------- |
| [`resources`](/reference/cli/resources) | list the tools, MCP servers and phone numbers your SLNG organisation offers |
| [`skill`](/reference/cli/skill)         | install the Unmute skill so a coding assistant can build agents for you     |

Neither reads or writes a package. `resources` reads your SLNG organisation and
changes nothing there, so it is the command to run before you write a
`builtin:` or `mcp:` tool and have to spell a name exactly. `skill` makes no
network call at all: the skill ships inside the binary.

`help` and `completion` come from the command framework.

## Running unmute with no arguments

In a terminal, `unmute` with no command opens an interactive console. Outside a
terminal, for example when the output is piped, it prints the help above.

That is the root command on its own. The commands below it have their own
no-argument behaviour, and it is a different thing.

## Running a command with no package

`validate`, `compile`, `deploy`, `dev` and `pull` take the package directory as
an **optional** argument. Leave it out and the package is the current directory, so you can `cd`
into an agent and work there:

```sh theme={null}
cd my-agent
unmute validate
unmute dev
```

Naming a directory still works, and still wins:

```sh theme={null}
unmute validate my-agent
```

The current directory must hold `agent.yaml` itself. No parent directory is
searched, so a run from inside `build/` cannot rewrite the package above it:

```text wrap theme={null}
unmute: validate: no agent.yaml in /Users/you/projects
  run `unmute validate` from inside an agent package, or name one: `unmute validate <package-dir>`
```

`init` is the exception: its argument is the name of the package to create, and
with no name in a terminal it opens the interactive console instead.

## Version

```sh theme={null}
unmute --version
```

It prints one line: the release, the commit it was built from, and that
commit's date. All of it is stamped in at build time. `-v` is the short form.

## Exit codes

| Code | Meaning               |
| ---- | --------------------- |
| `0`  | the command succeeded |
| `1`  | the command failed    |

There are no other exit codes today.

## Warnings

Warnings go to standard error and **do not** change the exit code. A command
that prints warnings and exits 0 succeeded:

```text theme={null}
warning: livekit: environment variables referenced but not declared in secrets: SIP_TRUNK_HOSTNAME (connections/twilio_sip.yaml environment sip_address)
```

Errors are printed to standard error too, prefixed with `unmute:`, and exit 1:

```text theme={null}
unmute: dev examples/salon-concierge: target instance "nope" is not declared
```

## Shell completion

```sh theme={null}
unmute completion zsh
```

```text theme={null}
$ unmute completion --help
Generate the autocompletion script for unmute for the specified shell.
See each sub-command's help for details on how to use the generated script.

Usage:
  unmute completion [command]

Available Commands:
  bash        Generate the autocompletion script for bash
  fish        Generate the autocompletion script for fish
  powershell  Generate the autocompletion script for powershell
  zsh         Generate the autocompletion script for zsh

Flags:
  -h, --help   help for completion

Use "unmute completion [command] --help" for more information about a command.
```

Each subcommand's own help explains where to install the script on your system.

## Where to go next

<Card title="unmute init" icon="terminal" href="/reference/cli/init">
  Start with the scaffold.
</Card>
