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

# Regional infrastructure

> Keep STT, LLM, and TTS services close to your users, with separate settings for model gateways, workers, and media.

Regional infrastructure is where each part of a call runs: the edge that
receives the caller's audio, the worker, and every model service the worker
waits on. Each one is its own setting.

Where your models run matters as much as where you deploy your agent. A nearby
worker still waits on distant speech and reasoning services. Review the whole
path from the caller to STT, the LLM, and TTS, for every provider you use.

On this page:

* [Quickstart](#quickstart) - the one setting for speech
* [Why model proximity matters](#why-model-proximity-matters) - where the time goes
* [Choose a location for every model](#choose-a-location-for-every-model) - one review per role
* [Separate the regional settings](#separate-the-regional-settings) - four locations, four controls
* [Choose a speech gateway](#choose-a-speech-gateway) - the 13 SLNG world parts
* [Place the worker near your users and models](#place-the-worker-near-your-users-and-models) - `deployment_region`
* [Troubleshooting](#troubleshooting) - what the compiler refuses

## Quickstart

On LiveKit and Pipecat, set `params.world_part` on each SLNG `listen` or
`speak` model to choose its gateway:

```yaml agent.yaml theme={null}
models:
  listen:
    transcriber:
      provider: slng
      model: "deepgram/nova:3"
      params:
        world_part: eu-north
  speak:
    voice:
      provider: slng
      model: "deepgram/aura:2"
      voice: "aura-2-thalia-en"
      params:
        world_part: eu-north
```

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

That is the speech half. The worker has its own region, set in `targets.yaml`,
and the two do not have to match. The rest of this page is which location each
part of the call has, and how to choose it.

## Why model proximity matters

A voice turn crosses several network boundaries: the caller sends audio through
a media or telephony edge, the worker sends it to STT, the worker calls the LLM
and tools, and TTS produces the audio that returns to the caller. Long trips
between these services add delay throughout the conversation, even when the
models themselves are fast.

Start with where your users are. Keep the media edge, worker, and model services
close to them and to one another where your providers offer that choice. Apply
the same review to tools and other services the agent waits on. Moving only the
worker leaves any long trips to remote models in place.

Use geography as a starting point, then measure the time from the caller
finishing a sentence to hearing the first reply from your users' locations.
Network routes, model availability, and load can change which choice is fastest.
Compare both typical calls and slow calls; a regional endpoint does not change
the model's own processing time.

## Choose a location for every model

The same review applies whether you use SLNG or bind a provider directly.
Choose each model separately, including fallback models where configured:

| Model role                              | Where distance adds delay                                                      | What to check                                                                                       |
| --------------------------------------- | ------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------- |
| [Speech to text](/models/stt), `listen` | Audio must reach the transcriber and its transcript must return to the worker. | The provider's streaming endpoint, the model's availability there, and final transcript latency.    |
| [Reasoning model](/models/llm), `think` | Every reply and tool decision waits on a model request.                        | The endpoint or deployment serving the LLM and its time to first token with your prompts and tools. |
| [Text to speech](/models/tts), `speak`  | Text must reach the voice model and the first audio must return.               | The regional endpoint, availability of your model and voice, and time to first audio.               |

Unmute supports direct speech providers such as Deepgram, Cartesia, ElevenLabs,
and Soniox, and reasoning providers such as OpenAI, Anthropic, and Mistral. The
linked model pages list the providers supported by each target. Regional
settings depend on the provider, model, account, and framework integration;
there is no shared region parameter for all of them.

For a direct provider, check its current documentation for regional endpoints
or deployments, then use the settings supported by the selected integration.
Do not copy another provider's parameter names. Some services select their
location automatically or offer no regional choice. Measure the route you
actually use before deciding whether to change providers or model deployments.

## Three region settings

| Setting             | Written on                                       | Accepted values                                                                                                                                              | What it moves                                            |
| ------------------- | ------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------- |
| `params.world_part` | SLNG `listen` and `speak` models on code targets | `us-east`, `us-west`, `br`, `eu-west`, `eu-north`, `gb`, `za`, `il`, `jp`, `sg`, `id`, `in`, `au`                                                            | The speech gateway endpoint                              |
| `params.world_part` | SLNG Context Router `think` models               | `us-east`, `us-west`, `br`, `eu-west`, `eu-north`, `gb`, `za`, `il`, `jp`, `sg`, `id`, `in`, `au`                                                            | The router endpoint                                      |
| `deployment_region` | Each target in `targets.yaml`                    | LiveKit: `us-east`, `eu-central`, `ap-south`. SLNG: the same 13 world parts listed above. Pipecat: one platform region name, forwarded without a value check | The agent worker on code targets; call placement on SLNG |

SLNG speech, routing, and deployment now share region names. LiveKit keeps its
own worker names. Each setting is still independent of the others. None alone guarantees
data residency: model providers, media, tools, traces, and storage have their
own locations. A nearby speech gateway does not prove where its model runs.
LiveKit's compute names come from its
[agent region list](https://docs.livekit.io/deploy/admin/regions/endpoints/#agent-deployment-regions).

<ParamField path="listen/speak.params.world_part" type="string">
  Accepts the speech gateway values in the table. Omit to use the plugin's
  default endpoint. An empty or unknown value is refused. Do not combine it
  with `params.base_url` or `params.slng_base_url`.
</ParamField>

<ParamField path="think.params.world_part" type="string" required>
  Accepts the same 13 world parts as speech. Required on a Context Router
  think binding; omission is refused. It selects the router endpoint independently.
  The old `world_part_override` key is refused; use `world_part`.
</ParamField>

## Separate the regional settings

Each part of the call has its own location:

| Location                   | What runs there                                           | How you choose it                                                         |
| -------------------------- | --------------------------------------------------------- | ------------------------------------------------------------------------- |
| Media or telephony ingress | The first platform edge that receives the caller's audio. | Platform region controls and carrier settings.                            |
| Worker region              | The generated LiveKit or Pipecat process.                 | `deployment_region` in `targets.yaml`.                                    |
| Model service              | The provider serving STT, the LLM, or TTS.                | That provider's supported endpoint or deployment settings, per model.     |
| Model gateway              | An API that routes requests to a model service.           | The gateway's own location setting; SLNG speech uses `params.world_part`. |

Setting one row does not set the others. A gateway location also does not by
itself guarantee where the underlying model processes data. Tools, tracing,
and storage keep their own locations too.

LiveKit configures [realtime region pinning](https://docs.livekit.io/deploy/admin/regions/region-pinning/)
separately from [agent deployment regions](https://docs.livekit.io/deploy/admin/regions/agent-deployment/).
For Pipecat Cloud WebSocket telephony, Unmute derives the regional endpoint
from `deployment_region`; that endpoint must match the worker's region. See
[Pipecat's regions guide](https://docs.pipecat.ai/pipecat-cloud/guides/regions).
Carrier routing remains a separate choice.

## Choose a speech gateway

**SLNG provides 13 regional speech gateways through one model setting.** It is
set per model, and it gives both speech roles the same configuration shape
across the two frameworks.

<ParamField path="params.world_part" type="world part code">
  The SLNG speech gateway an SLNG `listen` or `speak` model connects through.
  One of the 13 values below. Set it on each model separately. Omitting it keeps
  the existing default URL.
</ParamField>

Unmute turns the value into the host `{world_part}.api.slng.ai` in generated
services. For the `eu-north` in the quickstart above, it emits
`slng_base_url="eu-north.api.slng.ai"` on LiveKit and
`base_url="eu-north.api.slng.ai"` on Pipecat for both speech models. The plugin
receives the host without a scheme or path; Unmute consumes
`world_part` rather than passing it to the plugin.

This setting changes generated SLNG speech services on LiveKit and Pipecat.
Choose the worker's `deployment_region` separately. The SLNG hosted target
keeps its own deployment settings.

### Available SLNG world parts

All 13 world parts below work for SLNG `listen` and `speak` models on LiveKit
and Pipecat. Set the world part on each model separately.

| World part | Geography             | Gateway host           |
| ---------- | --------------------- | ---------------------- |
| `us-east`  | Eastern United States | `us-east.api.slng.ai`  |
| `us-west`  | Western United States | `us-west.api.slng.ai`  |
| `br`       | Brazil                | `br.api.slng.ai`       |
| `eu-west`  | Western Europe        | `eu-west.api.slng.ai`  |
| `eu-north` | Northern Europe       | `eu-north.api.slng.ai` |
| `gb`       | United Kingdom        | `gb.api.slng.ai`       |
| `za`       | South Africa          | `za.api.slng.ai`       |
| `il`       | Israel                | `il.api.slng.ai`       |
| `jp`       | Japan                 | `jp.api.slng.ai`       |
| `sg`       | Singapore             | `sg.api.slng.ai`       |
| `id`       | Indonesia             | `id.api.slng.ai`       |
| `in`       | India                 | `in.api.slng.ai`       |
| `au`       | Australia             | `au.api.slng.ai`       |

Omitting `world_part` keeps the existing default URL.

### SLNG reasoning uses the same world parts

For a `think` model with `provider: slng`, the
[Context Router](/optimization/context-router) serves the same 13 world parts as
the table above, under the same key: `params.world_part`. So `eu-north` on a
speech binding and `eu-north` on a think binding are the same place, and a
package can keep listening, thinking and speaking in one world part. The LLM
behind the router keeps its own provider settings.

SLNG deployment uses these same 13 region names. The location of each service
is still chosen separately.

## Place the worker near your users and models

Set the worker location in `targets.yaml`, using each platform's own region
names:

<ParamField path="deployment_region" type="platform region name">
  Where the generated LiveKit or Pipecat worker runs. Written per target in
  `targets.yaml`, in that platform's own region names. Pipecat accepts one.
  LiveKit accepts one region as a scalar or several as a list.
</ParamField>

```yaml targets.yaml theme={null}
targets:
  livekit:
    provider: livekit
    version: "1.8.1"
    sdk_language: python
    deployment_region: eu-central

  pipecat:
    provider: pipecat
    version: "1.10.0"
    deployment_region: eu-central
```

The worker region and model gateway codes do not need to match. For example,
a worker in `eu-central` can call SLNG speech through `eu-north.api.slng.ai`.
Choose nearby locations from the platform's current
[LiveKit](https://docs.livekit.io/deploy/admin/regions/agent-deployment/) or
[Pipecat](https://docs.pipecat.ai/pipecat-cloud/guides/regions) region list, then
measure the full call path.

### One worker region or several

Pipecat accepts one `deployment_region` per target. A second Pipecat region is a
second target and agent name.

LiveKit accepts either one region as a scalar or several regions as a list:

```yaml targets.yaml theme={null}
targets:
  livekit:
    provider: livekit
    version: "1.8.1"
    sdk_language: python
    deployment_region:
      - eu-central
      - us-east
```

Unmute emits one LiveKit create command per listed region. The deployments keep
one dispatch name, so LiveKit may send a caller to another declared region when
the nearest deployment is at capacity. For strict worker locality, use separate
agent names and explicit dispatch. See LiveKit's
[multi-region deployment guidance](https://docs.livekit.io/deploy/admin/regions/agent-deployment/#multi-region-deployments).

Adding worker regions leaves the model settings as authored. Review the model
endpoints each deployment will call so that a nearby worker also has a short
path to its STT, LLM, and TTS services.

## Troubleshooting

### The compiler refuses a `world_part` value

An empty, non-string, or unknown value is refused. The old speech values `na`,
`eu`, and `ap` are refused too. There is no automatic mapping from the old
broad areas.

**Fix:** choose one of the 13 values in
[the table above](#available-slng-world-parts) explicitly.

### The compiler refuses `world_part` next to a URL

`params.base_url` and `params.slng_base_url` cannot be combined with
`params.world_part`.

**Fix:** remove the explicit URL or the world part.

### The router refuses a `world_part_override`

The router used to take four names of its own, `eu`, `us`, `india` and
`indonesia`, under a key of its own. It takes the 13 world parts now, under
`params.world_part`, like speech.

**Fix:** rename the key and write a world part. See
[SLNG reasoning uses the same world parts](#slng-reasoning-uses-the-same-world-parts).

### A nearby worker is still slow

Setting one row of the table above does not set the others, and moving only the
worker leaves any long trips to remote models in place.

**Fix:** review the model endpoints each deployment calls, then measure the full
call path rather than the worker's own region.

## Where to go next

<Columns cols={2}>
  <Card title="Optimizing your agent" icon="gauge-high" href="/optimization/overview">
    Measure what the caller waits for.
  </Card>

  <Card title="Reasoning model" icon="brain" href="/models/llm">
    Choose the model that decides what to say.
  </Card>

  <Card title="Speech to text" icon="mic" href="/models/stt">
    Choose the model that listens to the caller.
  </Card>

  <Card title="Text to speech" icon="volume-2" href="/models/tts">
    Choose the model that speaks to the caller.
  </Card>

  <Card title="LiveKit Cloud" icon="cloud" href="/deploy/livekit-cloud">
    Deploy one worker region or several.
  </Card>

  <Card title="Pipecat Cloud" icon="cloud" href="/deploy/pipecat-cloud">
    Deploy one worker region per target.
  </Card>
</Columns>