> ## 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.
# SLNG Execution Layer
> A scaffolded package binds SLNG speech models by design, and those models run on SLNG's Execution Layer.
The SLNG Execution Layer is the layer SLNG's own speech models run on. It aims
at the two things a voice call is judged on: how fast it answers, and what it
costs per turn.
`unmute init` binds SLNG for listening and speaking, and every shipped example
does the same. That is a decision, not a placeholder. Bind SLNG for a speech
role and you are on that layer.
Unmute does not measure any of this. Everything on this page is SLNG's published
description of its own system, linked so you can read the source.
On this page:
* [What this means for your package](#what-this-means-for-your-package) - the binding you already wrote
* [What the Execution Layer is](#what-the-execution-layer-is) - routing instead of calling everything
* [The STT Performance Layer](#the-stt-performance-layer) - the stage on the way in
* [TTS Path Optimization](#tts-path-optimization) - the stage on the way out
* [The third role](#the-third-role) - thinking, which you opt into
## What this means for your package
Nothing you have to write. The layer sits behind the SLNG models you already bound:
```yaml agent.yaml theme={null}
models:
listen:
transcriber:
provider: slng
model: "deepgram/nova:3"
speak:
voice:
provider: slng
model: "deepgram/aura:2"
voice: "aura-2-thalia-en"
```
One `SLNG_API_KEY` covers both. If you bind a different vendor for either role, you
are on that vendor's own path instead, and none of the above applies. The lists of
what else each target can construct are on
[speech to text](/models/stt) and [text to speech](/models/tts).
To select an SLNG speech gateway, set `params.world_part` on each
binding. [Regional infrastructure](/optimization/regional-infrastructure) shows
the YAML and explains the separate model, worker, and media regions.
## What the Execution Layer is
Rather than sending every turn through every model, the layer routes each turn to
the path that can serve it, and avoids the inference calls it does not need. SLNG's
own framing is that "a 16-turn voice call makes 48 model calls", and that at "1M
calls per month, that is 48M inference calls".
Two stages of it matter to a package you build here.
Figures below are SLNG's, published for the Execution Layer as a whole, and
are not measurements Unmute took. Source:
[docs.slng.ai/execution-layer](https://docs.slng.ai/execution-layer), read
2026-08-14.
| What SLNG reports | Their figure |
| --------------------------- | ----------------------------- |
| end-to-end latency per turn | "39% reduction" |
| total pipeline cost | "53% reduction" |
| call completion rate | "Zero dropped, zero downtime" |
## The STT Performance Layer
The first stage, which routes incoming audio to the transcription model best suited
to it, per turn, based on the caller's context: language, location, environment.
SLNG lists noise cancellation across audio types, voice activity detection across
multiple speakers, language routing across models, and diarization for transcription
metadata.
SLNG marks this stage `PRIVATE BETA` and says "The behavior described here is being
rolled out gradually." That is their status for their feature, quoted as published
on 2026-08-14 at
[docs.slng.ai/execution-layer/stt-performance-layer](https://docs.slng.ai/execution-layer/stt-performance-layer).
Read it before you plan around this stage.
## TTS Path Optimization
The other stage, on the way out. Instead of generating audio for every request, it
"serves from cache when possible and synthesizes only when genuinely new". In SLNG's
words: "When audio has been produced before for the same request, it is served
instantly, with no upstream model call and no provider billing. When it has not, it
is generated, and the result is available for future requests."
SLNG makes no numeric claim for this stage on its own, and describes the saving as
structural rather than measured: "Cost decreases structurally. As coverage grows,
fewer turns hit the upstream model." Read as published on 2026-08-14 at
[docs.slng.ai/execution-layer/tts-path-optimization](https://docs.slng.ai/execution-layer/tts-path-optimization).
Which is worth knowing when you write a greeting: a line every caller hears is the
kind of output this stage is built for.
## The third role
Everything above is about listening and speaking. Thinking has its own SLNG path,
the [Context Router](/optimization/context-router), and it is the one place where the
optimisation is something you opt into rather than something already behind the
binding. It caches the turns your agent has answered before and serves them
without calling your model, so a repeat it judges cacheable comes back in roughly
a tenth of the time. It decides which turns those are, so some repeats still take
the model path. You keep your own model and your own provider.
It is a different trade from the two above. Speech optimisation costs you
nothing and changes nothing you write. The router asks you for a `think`
binding change, a stable cache id, and the decision to send your upstream
credentials inline. The page explains all three.
## Where to go next
The optimization you opt into: cache repeated turns on the `think` role.
The full catalog, with languages and regions.
Every vendor each target can use for listening.
Choose the speech gateway, model region, and worker region.