—— PROGRAMMABLE UNIFIED COMMUNICATIONS
THE PROBLEM
What look like telecom problems are actually architecture problems
Maintaining call state in your application layer is what fails at scale — not the network. The CPaaS hands you raw events and leaves the rest to you.
When the machinery fails
your code maintains all of this
01
State synchronization
// you maintain
02
Audio routing
// you maintain
03
Error recovery
// you maintain
04
Protocol negotiation
// you maintain
05
WebSocket management
// you maintain
06
Vendor SDK integration
// you maintain
07
Transcript buffering
// you maintain
08
TTS routing
// you maintain
09
Turn tracking
// you maintain
10
Barge-in handling
// you maintain
11
Session tracking
// you maintain
12
Transfer logic
// you maintain
13
Compliance logging
// you maintain
14
Codec transcoding
// you maintain
15
Reconnect handling
// you maintain
16
Race condition handling
// you maintain
17
Event ordering
// you maintain
18
Timeout handling
// you maintain
19
Retry logic
// you maintain
20
Call state reconstruction
// you maintain
21
Conference bridging
// you maintain
22
Recording management
// you maintain
23
DTMF handling
// you maintain
24
Escalation handling
// you maintain
25
Latency monitoring
// you maintain
Side by side
CPaaS and SignalWire are built differently
THE SOLUTION

HOW IT WORKS
Three principles that make the call self-aware
01
Calls are stateful objects that carry their own context
History, tool results, and transfer lineage live inside the call, persisted by the platform. You read state; you never rebuild it.

02
Resources are addressable & composable
A phone number, an AI agent, a queue, a video room: each is an addressable resource. The ingress protocol doesn't constrain routing.
03
AI runs inside the call, not alongside it
The AI runs as a state machine of steps you define. At each step it sees only the tools and data you allow. This is System-Directed AI: the state machine controls the model, not the other way around.
See it IN PRODUCTION
Talk to Sigmond
A voice AI that answers questions about SignalWire over WebRTC

Tap to talk to a live agent
800–1200
ms
per min/ AI runtime
~500
ms
Turn detection
5 > 1
Vendor stack consolidated to one platform
0
State machines you build or maintain

THE OUTCOME
When the platform owns the call, you get the outcomes
Instruct calls mid-flight
Reach a call by ID and redirect, transfer, or hand it to an agent. No webhook round-trip.
AI can't go off script
The model sees only the tools and data you scope to each step. It can't act outside what you allow.
One platform, not five vendors
Voice, AI, transcription, and call control run on one runtime, instrumented and billed as one system.
Calls carry their own context
A transfer carries the caller's identity and history with it, so the next agent already knows who's calling and why.
Low-latency AI
The AI kernel runs in the media path, not across vendor hops, for ~800–1200ms round trip latency.
Multi-protocol ingress
The platform normalizes PSTN, SIP, WebRTC and WhatsApp into one call before your code touches it, so you route every caller the same way.
Native observability
The platform records every step, tool call, and decision the agent made, and why.


FAQS
What is Programmable Unified Communications?
Programmable Unified Communications is a communications architecture where the platform owns the call state, lifecycle, and routing, and your code controls behavior through a programmable API surface. Unlike CPaaS, which treats a call as a transaction your application must track, PUC treats a call as a persistent object the platform manages.
The result is that state management, transfer logic, session tracking, and AI governance stop being things you rebuild on every project. Whether you're deploying an AI voice agent, a contact center, or a complex multi-channel flow, voice, video, messaging, and AI run on one substrate. The platform handles the infrastructure complexity; your code handles the business logic.
How is SignalWire different from a traditional CPaaS?
CPaaS delivers events and expects your application to maintain state. SignalWire owns the state, lifecycle, and routing of every interaction.
With a CPaaS, your application is the glue between telephony, AI, and business logic. With SignalWire, the platform is that glue. Transfers preserve context. AI is governed deterministically. You don't need a five-vendor stack to ship a voice AI product.
Why does my voice AI lose context on transfer?
Because with traditional CPaaS, context lives in your application layer, not in the call itself. When a call transfers, the new leg has no memory of what happened on the previous one unless your application explicitly passes it, and that handoff is fragile.
On SignalWire, context moves with the call because the platform owns it. Transfer history, conversation context, tool results, they're all part of the call object, not your application's responsibility to preserve.
What is a communications control plane?
A control plane is the governance layer that sits above the media path and owns routing, state, and lifecycle decisions. In networking and infrastructure ( Kubernetes, SD-WAN) control planes are standard. Communications has never had one until now.
Traditional CPaaS pushes that responsibility onto your application. Every team building on CPaaS ends up writing the same invisible machinery: session tracking, transfer logic, compliance logging, AI governance. SignalWire's control plane is the layer that was always missing: it handles AI call routing, state ownership, and lifecycle decisions so your application doesn't have to.
Why is my voice AI response latency so high?
Most voice AI stacks route audio through multiple separate vendors (telephony, STT, LLM, and TTS), each adding network hops and processing time. The compounded latency of that architecture is 2-4 seconds, which is long enough to feel broken to a caller.
SignalWire embeds the AI kernel directly in the media processing pipeline. STT, inference, and TTS are coordinated inside the media engine with millisecond-level timing. End-to-end response latency is 800-1200ms, and as low as 600ms with speech-to-speech models.
Can I use SignalWire with my existing LLM?
Yes. SignalWire is model-agnostic. You can connect your existing LLM through the tool invocation layer. When the AI needs your backend, the call routes to your code, you return a result, and the platform handles the rest.
You don't need to re-engineer your LLM integration to add voice. SignalWire wraps around your existing AI logic and handles the telephony, state, and media complexity that voice adds.
Can SignalWire replace my entire voice AI stack?
Yes. SignalWire is designed to be the single AI telecom platform for voice, video, messaging, and AI agents. STT, LLM orchestration, TTS, call control, conferencing, recording, and compliance logging all run on one platform. It is purpose-built for AI call center deployments where state, latency, and governance cannot be an afterthought.
The practical result is one vendor, one SDK, one billing relationship, and one observability surface instead of four. Teams that have built on multi-vendor stacks typically consolidate onto SignalWire to eliminate the integration and maintenance overhead those stacks produce.

