> ## 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.

# Deploy to SLNG

> Deploy a package to SLNG, update the existing agent, and manage its credentials.

Deploy your package as a managed SLNG agent and test it in the browser.
Unmute turns your authored files into a deployment body. SLNG runs the agent,
so this route needs no Docker image or Python project.

On this page:

* [Quickstart](#quickstart) - the native deployment command
* [Choose the target](#1-choose-the-target) - region and supported package features
* [Select the organisation](#2-select-the-organisation) - authentication and destination
* [Supply credentials](#3-supply-credentials) - model keys and tool secrets
* [Preview and deploy](#4-preview-and-deploy) - files, checks and identity
* [Verify the agent](#5-verify-the-agent) - a complete browser interaction
* [Every later deploy](#every-later-deploy) - update the same agent
* [Secrets-only updates](#secrets-only-updates) - add, replace and remove values
* [Advanced](#advanced) - hosted tools and optional integrations
* [Troubleshooting](#troubleshooting) - symptoms and fixes
* [Where to go next](#where-to-go-next) - related guides

## Quickstart

For a new package, run this from the directory that will contain `my-agent`:

```sh Terminal theme={null}
unmute init
```

In the console:

1. Enter `my-agent` as the name.
2. Open **Identity → Target** and select **SLNG**.
3. Open **Behavior → Advanced → Advanced target settings → Deployment region** and enter one supported [SLNG region](/targets/slng#targets-yaml).
4. Return to **Create agent**, review the package and confirm.

The region field is labelled optional in the console, but SLNG requires it.
This path creates a package without code-target turn settings. A saved
organisation manifest may restrict the choices; see
[manifest-based initialization](/reference/cli/init#1-choose-the-contract).

Already have a package declaring a `slng` target? Start here. Run these commands
from the directory containing `my-agent`:

```sh Terminal theme={null}
brew install slng-ai/tap/voiceai
voiceai login --profile production
unmute deploy my-agent --target slng --profile production --dry-run
unmute deploy my-agent --target slng --profile production
```

The profile name `production` is your local label for a credential. Use your
own name. Before deploying, check the organisation shown by the preview and
supply any missing resources it names.

A successful deploy prints the agent ID. Open that agent in the SLNG dashboard
and choose **Test → Web session**. The sections below explain each step.

## 1. Choose the target

Merge this target into an existing `targets.yaml`. `eu-north` is one example;
choose a supported region that serves your models and language.

```yaml targets.yaml theme={null}
targets:
  slng:
    provider: slng
    deployment_region: eu-north
```

<ParamField path="provider" type="string" required>
  Set to `slng`. The surrounding target name selects this build with `--target`
  and names its directory under `build/`.
</ParamField>

<ParamField path="deployment_region" type="string or one-item list of strings" required>
  Exactly one [SLNG region](/targets/slng#targets-yaml). There is no default.
  Omission, an unknown region and multiple regions are refused.
</ParamField>

The package needs a name, one entry agent, a prompt, a fixed greeting, and
bindings for reasoning, speech recognition and speech generation. Keep those
in `agent.yaml` and the prompt files it references.

SLNG owns runtime versions, capacity and turn detection. Omit target `version`,
`pins`, `sdk_language`, `connection` and `warm_instances`. Tasks, handoffs and
package-local Python are unavailable on this target. See the
[complete target limits](/targets/slng#what-a-slng-package-may-not-ask-for).

### Choose models and their region

Set model bindings under `models.think`, `models.listen` and `models.speak` in
`agent.yaml`. A target can override an existing binding by name. See
[model configuration](/reference/agent-yaml#models) for the authored shape.

The SLNG driver joins a provider and model with `/`, unless the model already
contains `/`. It forwards each binding's `params` into that component's
provider options. It does not test model availability or provider option
support offline.

Use SLNG's [model discovery instructions](https://docs.slng.ai/examples/agents-config#finding-models)
to select models available to your organisation, language and region. The
[Unmute model pages](/models/stt) explain the bindings and target differences.
Provider defaults apply to omitted options; an accepted package can still fail
when a provider receives its first request.

`deployment_region` selects the hosted agent's region. An upstream model's
inference location is a separate provider setting. Choosing a hosting region
does not move that provider's inference service.

## 2. Select the organisation

Install the [voiceai CLI](https://docs.slng.ai/sdks/cli) and sign in with an API
key from the destination organisation. The login prompt keeps the key out of
your command history:

```sh Terminal theme={null}
voiceai login --profile production
voiceai --profile production whoami
```

Unmute needs a `voiceai` release that supports checked, resolved pushes.
It checks that capability before pushing and gives upgrade guidance if it is
missing. `voiceai 0.1.18` supports this flow. No Python SDK version is yours
to install for this target.

<Warning>
  Environment keys override the selected profile. Unmute reads `SLNG_API_KEY`,
  then `VOICEAI_API_KEY`, then the profile. It also loads the package's `.env`
  and `.env.local`. Remove unintended deployment keys from those files and
  your shell when using a profile. Check the preview's organisation before deploying.
</Warning>

There is no separate Unmute project selector for SLNG. The credential selects
the organisation, and `--profile` selects a saved credential when no environment
key overrides it. Use the same profile for every command below.

## 3. Supply credentials

These settings have different owners:

| Setting                       | Where it belongs                                                                                            |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------- |
| SLNG deployment key           | Local `voiceai` profile or deployment environment                                                           |
| Model provider key            | SLNG's [Bring Your Own Key page](https://docs.slng.ai/dashboard/byok), when using your own provider account |
| Hosted tool or MCP credential | Organisation Vault, under the exact required name                                                           |
| Shared non-secret text        | A Vault variable, where the target supports it                                                              |
| Per-call input                | An authored [variable](/build/variables) supplied at session start                                          |
| Worker connection settings    | SLNG manages them; this target emits no environment file                                                    |

Model credentials registered through BYOK are separate from tool secrets.
Choose a supported model in the organisation; putting its provider key in a
local `.env` file does not configure managed-agent BYOK.

The generated `build/slng/README.md` lists the Vault requirements visible to the
compiler. Deployment also checks credentials required by published tools and
MCP servers. A declaration names a requirement; it does not supply its value.
See [Credentials](/build/credentials) and [the SLNG Vault](/targets/slng#the-vault).

Create a missing tool secret by name and enter its value at the hidden prompt:

```sh Terminal theme={null}
voiceai --profile production secret create SERVICE_API_TOKEN
voiceai --profile production secret get SERVICE_API_TOKEN
```

Replace `SERVICE_API_TOKEN` with a name in your package's requirements.
The read command reports metadata, including `has_value`, without displaying
the value. Vault writes require an organisation admin.

For a batch, prepare a private file containing only required tool credentials:

```dotenv runtime.secrets.env — placeholders; replace before use theme={null}
SERVICE_API_TOKEN=replace-with-the-service-token
```

```sh Terminal theme={null}
voiceai --profile production secret create --secrets-file runtime.secrets.env
```

Keep the file outside `build/` and out of source control. Do not upload an
entire development environment or the deployment key as a tool secret.
A real `unmute deploy` can also offer to fill missing Vault entries with your
consent; a dry run cannot fill them.

## 4. Preview and deploy

You can inspect the generated files before any account checks:

```sh Terminal — from the directory containing my-agent theme={null}
unmute validate my-agent --target slng
unmute compile my-agent --target slng
```

Both commands work offline. Compilation writes `agent.json`, `README.md` and
`compile-report.json` into `my-agent/build/slng/`. The report lists checks
that need the live account. Edit the authored package and compile again;
generated files are replaced.

Deploy from the same parent directory, passing the authored package path:

```sh Terminal theme={null}
unmute deploy my-agent --target slng --profile production --dry-run
unmute deploy my-agent --target slng --profile production
```

`deploy` validates and compiles again automatically. It resolves hosted tool
names and MCP selections in the chosen organisation, checks the resolved
contracts, and pushes that checked body. It writes a `deploy-report.json`
beside the generated files when it reaches the push stage.

A dry run changes no remote state. A real run may refresh MCP discovery or
create Vault entries with your consent before a later check fails. Its report
records those changes. The agent is written only after its required checks pass.

The deployed name joins the package name and target name: package `my-agent`
with target `slng` deploys as `my-agent-slng`. SLNG assigns a separate agent ID.
The report records that ID, but Unmute stores no deployment lockfile: later
pushes resolve the name again. Find the resource with:

```sh Terminal theme={null}
voiceai --profile production agents list
```

Do not post `build/slng/agent.json` with `voiceai agents create`. The compiled
body still contains names that deployment must resolve to platform identifiers.

## 5. Verify the agent

Open the deployed agent in the dashboard and choose **Test → Web session**.
Fill required call inputs, allow microphone access, and start the session.
See [SLNG's test panel](https://docs.slng.ai/dashboard/agent-infra#test-your-agent).

Say a short question and wait for a relevant answer. If the package uses a
tool, exercise one safe tool interaction and check the result. A greeting
proves audio output; a response to your question also checks input and reasoning.

Use the returned agent ID and call ID to read the call. Replace the angle-bracket
placeholders before running:

```sh Terminal theme={null}
voiceai --profile production agents calls list <agent_id> --json
voiceai --profile production agents calls get <agent_id> <call_id> --json
```

Check the transcript, tool results and any `call_end_reason`. A completed push
proves that the platform accepted the configuration. A completed interaction
is the deployment smoke check; application-specific tests still come next.

## Every later deploy

Change your authored prompt, model bindings, configuration or tool references,
then preview and update with the same target and profile:

```sh Terminal theme={null}
unmute deploy my-agent --target slng --profile production --dry-run
unmute deploy my-agent --target slng --profile production
```

Unmute regenerates the body on each run. There is no image to rebuild and no
secrets file required on update. Existing Vault values remain in the Vault.

A push replaces the agent configuration. Fields edited only in the dashboard
can be overwritten, and tool references removed from the package are detached.
Read the preview's removals. Hosted tools resolve to their latest published
versions on each deploy; a committed code-target mirror does not pin them here.

The same deployed name updates the existing agent. If the name is ambiguous,
pass `--agent-id <agent_id>`. The ID remains the same on update. An unchanged
push creates no version. Test a fresh session after each change; Unmute offers
no worker restart or rolling-update controls for this managed runtime.

For rollback, SLNG's [Versions tab](https://docs.slng.ai/dashboard/agent-infra#versions)
can restore a saved version after showing its checks. Bring the authored package
back into agreement before the next deploy, which would replace that restored
configuration again.

### Renaming the agent

Changing the package or target name creates a different deployment name.
It can create a second agent and leave the first running. Integrations holding
the old ID keep reaching the old agent. Inspect `agents list` and update those
integrations deliberately; a rename is not a migration.

## Secrets-only updates

For an existing Vault name, update its value without compiling or deploying:

```sh Terminal theme={null}
voiceai --profile production secret create SERVICE_API_TOKEN --overwrite
voiceai --profile production secret get SERVICE_API_TOKEN
```

The first command prompts for the replacement. Omit `--overwrite` when adding
a new name. If it already exists, the CLI asks before replacing it; a
non-interactive run refuses without overwrite consent.

For a file, `--secrets-file runtime.secrets.env --overwrite` adds new entries
and replaces listed existing entries. It does not remove entries omitted from
the file. List metadata with `voiceai --profile production secret list`.

SLNG resolves tool credentials at execution time, so changing an existing
Vault value needs no agent rebuild. Check a fresh tool interaction after
rotation; do not assume an active call has refreshed every credential.

To remove a secret, use the dashboard's Vault page. The CLI has no delete
command. SLNG blocks deletion while active configurations or calls still
reference it. Remove the use first, deploy that change if needed, then delete.
See [Vault management](https://docs.slng.ai/dashboard/vault).

Replacing a stored value does not create or revoke its provider key. Do those
operations in the provider's account. For model credentials, use
[BYOK rotation](https://docs.slng.ai/dashboard/byok#rotating-a-key).

## Advanced

### Reuse tools and shared code

Start with supported package declarations. For external services, reference
published [hosted tools](/build/tools/hosted) or select named
[MCP tools](/build/tools/mcp) from your organisation.

The SLNG target publishes no tool code and refuses `local:` and `webhook:`
tool bodies. It has no package-local Python imports, shared-module packaging,
custom Dockerfile, dependency override or lifecycle hook. Publish and maintain
the tool on SLNG, or choose LiveKit or Pipecat when the package must own Python.

A hosted tool needs no local mirror for this target. `unmute pull` is for a
package that also compiles to a code target, where that mirrored tool runs.

### Receive phone calls

Configure a carrier connection through
[SLNG Telephony](https://docs.slng.ai/dashboard/telephony), then attach the
inbound trunk when `unmute deploy` offers it or in the agent's Telephony tab.
The attachment does not change the carrier's routing.

Inbound calls supply no web-session input payload. Give required injected
inputs valid defaults or leave those arguments for the model to collect.
Call the number and inspect the new SLNG call record. Outbound calling needs
its own outbound connection; an inbound attachment does not enable it.

### Create a session for your own client

Save this complete request body, filling any required call inputs in `arguments`:

```json session.json theme={null}
{"arguments": {}, "participant_name": "tester"}
```

```sh Terminal theme={null}
voiceai --profile production agents web-sessions create <agent_id> --file session.json
```

The result contains `livekit_url` and `livekit_token` for your client.
Treat the token as a credential. This command requests a session; it opens no
browser and does not prove a worker joined. Keep deployment keys on your server.

## Troubleshooting

| Symptom                                  | Cause                                                              | Fix                                                                                           |
| ---------------------------------------- | ------------------------------------------------------------------ | --------------------------------------------------------------------------------------------- |
| The preview names the wrong organisation | An environment key overrides the profile                           | Check the package's `.env` files and shell keys, then preview again with the intended profile |
| A second agent appears                   | The package name, target name or destination changed               | Find both with `agents list`; restore the intended name and select the correct ID             |
| `agent ambiguous`                        | More than one agent matches the name                               | Pass `--agent-id <agent_id>` after checking the destination                                   |
| `vault missing`                          | A required secret is absent or exists as a variable                | Create the exact case-sensitive name with the required Vault kind                             |
| A hosted tool is missing                 | The organisation has no published tool with that name              | Publish it in SLNG or change the authored reference                                           |
| `--require-resolved` is refused          | The installed CLI lacks checked pushes                             | Upgrade `voiceai` using the install instructions above                                        |
| `AGENT_MODEL_UNAVAILABLE`                | The organisation, region or language cannot use the selected model | Choose a compatible model using SLNG's model selector and update the package                  |
| The greeting plays but input is absent   | The client is muted or its microphone is blocked                   | Allow microphone access, unmute and check for caller text in the transcript                   |
| A call ends with a component error       | STT, LLM, TTS or a tool failed at runtime                          | Read the call details, fix that component's credentials or options, then test again           |
| No phone call appears in SLNG            | Carrier routing failed before the agent started                    | Check the number's routing and inbound connection                                             |

A dry run may report an unusable MCP snapshot. A real deploy can refresh it
once and recheck it. A local-module error belongs to a LiveKit or Pipecat
build: SLNG does not execute the package's Python files.

## Where to go next

<CardGroup cols={2}>
  <Card title="Going live" icon="cloud-upload" href="/deploy/going-live">
    The package-to-deployment workflow across targets.
  </Card>

  <Card title="unmute deploy" icon="terminal" href="/reference/cli/deploy">
    Every flag and deployment check.
  </Card>

  <Card title="The SLNG target" icon="boxes" href="/targets/slng">
    Model bindings, Vault references and target limits.
  </Card>

  <Card title="Credentials" icon="key" href="/build/credentials">
    Declare names and supply values separately.
  </Card>
</CardGroup>