100x More Reliable Voice Agents
SLNG.ai introduces Unmute, an open declarative standard for voice agents, addressing platform lock-in and the limitations of current agent architectures. It proposes a shift from LLM-centric, sequential pipelines to declared execution with structural guarantees, enabling portable, cost-effective, and robust voice agents by breaking down complex interactions into modular, context-aware steps. This approach minimizes token usage, enhances determinism, and improves agent reliability compared to traditional single-prompt designs.
Luke and Nico from SLNG.ai introduced Unmute, an open declarative standard for voice agents, released under an MIT license. They highlight a significant problem in the voice agent ecosystem: platform lock-in. Currently, building an agent on platforms like ElevenLabs, VAPI, Retell, or Bolna, or even open frameworks like Pipecat or LiveKit, ties the agent’s IP to that specific platform, making portability difficult or impossible without significant re-engineering.
Unmute challenges three common, yet fundamentally flawed, assumptions about voice agents:
1. Voice agents are not sequential turn-taking pipelines
Contrary to popular belief, voice agents are concurrent, multimodal, real-time systems capable of listening, reasoning, retrieving, speaking, and interrupting simultaneously. The critical question isn’t which model to use in a sequence, but which resource (e.g., a frontier model, cached audio, compliance-approved disclosure, or specific compute region) the agent should leverage at any given moment. Unmute aims to compose these resources around the caller, use case, and rules, ensuring agents aren’t rewritten when infrastructure changes.
2. The LLM should not be the decision-making spine
Many current voice agents rely on the LLM to manage tool calls, data flow, step transitions, and failure handling, leading to unpredictable, expensive, and ungovernable behavior. Unmute proposes declared execution where these processes are explicitly defined and enforced by a compiled package. The LLM is then relegated to an optional resource that must earn its place, only being called when truly necessary. This approach allows a single Unmute package to compile and deploy across various platforms like Pipecat Cloud, LiveKit Cloud, or Slang.
3. The choice isn’t rigid IVR or a long prompt followed by hope
The current paradigm forces a choice between inflexible IVR systems and overly complex, single-prompt agents that often fail in production. Unmute introduces determinism as a dial, allowing granular control turn by turn. For example, a regulatory disclosure can be locked as deterministic, while an open-ended objection can remain generative within the same call. Non-determinism becomes a controlled resource rather than the unreliable foundation of the system.
The Problem with Single-Prompt Agents
Nico elaborates on why single-prompt agents break down: they send the entire prompt—containing all rules, tools, and context—to the model at every turn. This leads to excessive token usage, models going off-topic, selective rule adherence, and immense difficulty in debugging failures. The core issue is that the prompt is not a structural specification; it’s just instructions.
Unmute’s Solution: Structural Guarantees and Declared Execution
Unmute advocates for splitting work into smaller, context-specific steps, providing the LLM with only the necessary information at any given time. This approach, demonstrated with a “salon agent” example, shows significant benefits:
- Salon Example Comparison: A single-prompt salon agent (10 tools, all rules in one prompt) was compared against a split-agent version (concierge with one tool, separate complaint specialist). The single-prompt version consumed more than double the tokens for the same conversation and exhibited higher latency and more turns. The split version, despite having more total text across its multiple prompts, only sends relevant context at each step, drastically reducing token usage, turns, and latency.
- Cost Efficiency: The key insight is that while the combined text of split prompts might be greater, only the active prompt segment is sent to the model per turn. This means less cost; a query about opening hours doesn’t incur the cost of the entire refund policy.
- Structural Enforcement: Unmute replaces hopeful instructions with structural guarantees. For instance, a booking step is only presented to the model after a confirmed customer number exists, making a booking without confirmation structurally impossible, not merely unlikely.
- Prefetching and Efficiency: Agents often waste early call time gathering information they could already know. Unmute enables prefetching data (e.g., customer details from the carrier) before the greeting, effectively skipping turns and reducing interaction friction. A tool that takes no arguments is considered an indicator of poor design, as its output could have been pre-seeded.
- Typed Variables and Scoped Access: Unmute introduces typed variables with declared scope. Each value is defined once, preventing duplication and ensuring it appears in exactly one relevant prompt. If a value is incorrectly placed (e.g., a phone number in the greeting prompt), it triggers a build error. Tools receive injected values directly, preventing the LLM from attempting to retype or misinterpret them. This ensures data integrity and reduces model hallucinations.
Live Build and Deployment
The presentation includes a live demonstration where a problem is described in a single paragraph, a new skill is installed, Claude Code generates the Unmute package, and then unmute compile and unmute dev commands are used to deploy a working voice agent locally. This highlights the ease of building structurally sound agents with Unmute.
Ultimately, Unmute represents a paradigm shift: define the agent once (its behavior, tools, integrations, and policies), then compile it to any chosen runtime (Pipecat Cloud, LiveKit Cloud, or Slang). This ensures that the agent remains version-controlled IP, decoupled from underlying infrastructure changes, fostering true portability and maintainability.