—— Why SignalWire ——
Everyone else stitched two stacks together. We built one.
SignalWire is the only control plane where Voice AI and telephony run on the same real-time media engine; built by the team behind FreeSWITCH.

The category argument · PUC
CPaaS, UCaaS, and CCaaS are each half a platform
Programmable Unified Communications is what you get when one company owns the call, the channels, and the programming model. Nobody else built it because nobody else owned the media engine to build it on.
CPaaS
INCOMPLETE
APIs without the interaction
Stateless message-passing. You compose primitives, but the call itself is somebody else's problem.
UCaaS
INCOMPLETE
A finished product you can't reshape
Configurable, not programmable. The seams are closed; the experience is the vendor's, not yours.
CCaaS
INCOMPLETE
CC logic bolted to a phone tree
Agents, queues, and IVRs but no first-class programmable surface for the call, the channel, or the AI.
STATEFUL
Calls are first-class objects, not event streams.
UNIFIED
Voice + video + messaging + AI in one model.
ELASTIC
Scale across 30+ AZs without rewiring routes.
OWNED
We built it. We run it. From the SBC up.
The category argument · Voice AI
The AI middleware layer is a temporary stack
The orchestration vendors sit on top of carriers they don't own and models they don't host. They charge a tax for the privilege of stitching the media engine together. That layer disappears when somebody finally embeds AI inside the media engine.
The orchestration stack
FOUR LAYERS, FOUR VENDORS
Your application
You
AI orchestration
Vapi · Retell
Real-time rooms
LiveKit
Carrier / SIP / PSTN
Result: latency you can't tune. Governance scattered across four vendors. A surcharge on every minute. A stack with no owner when it breaks.
Platform
ONE VENDOR · ONE STACK
Your application
Control plane: SWML, Agents, Datasphere, PGI
AI kernel: embedded in the media path
Media engine: SIP / PSTN / WebRTC / media
Result: architecture-driven latency. Governance as a platform property. No surcharge on minutes the orchestrator didn't generate. One vendor, one answer. We wrote the code, so we fix it.
The orchestration tax
Voice AI middleware adds a margin on every minute, then routes it through a media engine they don't own. It's a temporary stack: the moment AI is embedded in the media engine, the middleman has nothing left to broker.

The architecture
Media engine. AI kernel. Control plane.
Owning all three is the whole argument. Latency becomes architectural. AI becomes embedded. Governance becomes structural. You can't bolt this on afterwards as it has to be built from the SBC up.
01
Latency is architectural
No network hop between the LLM and the audio. ~1,200ms typical, not 2.5–4s.
02
AI is embedded
STT, LLM, TTS, and speech-to-speech all live in the kernel, not bolted to the side.
03
Governance is structural
Tool calls scoped to call state, not prompt-engineered. PGI enforces it at every step.
What this lets you do
Capabilities competitors can't match
When you own the media engine, the AI kernel, and the control plane, certain capabilities aren't features, they're consequences. These are the four that matter.
01
Stateful interactions across every channel
SIP, WebRTC, PSTN as one programming model. State follows the call, not the channel. You write the logic once; the platform makes it work everywhere.
02
Voice AI with architectural latency
The kernel and the audio share a process. No queue, no hop, no orchestration tax. ~1,200ms typical end-to-end. It's measurable, reproducible, open-source-verifiable.
03
AI governance as a platform property
Prompt-engineering is not engineering. PGI (Programmable Governance Interface) scopes which tools an agent can call at each step. The runtime enforces it, not the prompt.
04
Voice, video, messaging, and AI through one control plane
One contract. One bill. One vendor, one answer. We wrote the code, so we fix it. The control plane is what makes the channels feel like one product instead of four integrations.
20+
Years of innovation
2,700+
Companies on the platform
2.7B
Minutes + messages annually
99.95%
Platform uptime
How we think
Tenets, not tagline
The page is supposed to give you our POV. Here it is, unvarnished. If any of these don't sound right to you, we probably aren't the right vendor.
01
Prompt and pray is not engineering.
Stochastic glue between deterministic systems is a hack, not a platform. Governance has to live in the runtime, not the prompt.
02
AI governance is architectural, not a feature.
You can't add it later by editing a system prompt. It's either a property of the platform or it's a marketing claim.
03
Communications needs a control plane.
Routes, sessions, state, channels, and AI all need to be programmable through one contract or they'll be programmable through none.
04
Owning the media engine is what makes AI feel real.
The reason conversational AI feels slow is the network hops nobody talks about. Embed the kernel; the latency disappears.
05
The orchestration layer is temporary.
Middleware that brokers other vendors' media engines lasts exactly until one of those vendors absorbs it. We absorbed it ourselves.

Customer proof
The teams running real traffic through this
These are the teams running real production traffic through SignalWire, from healthcare platforms to AI-native startups to contact-center operators.
Heritage
Built by the team that built FreeSWITCH
Twenty years of real-time voice infrastructure. The same engine powers Apple, Amazon, Zoom, and millions of servers worldwide. The people who wrote it built the media engine underneath SignalWire.
Telecom insiders, refined for cloud-native developers. That's not marketing; it's how latency works.
FROM FREESWITCH TO THE CONTROL PLANE
2005
Anthony Minessale starts FreeSWITCH
The open-source telephony engine that becomes the media engine.
2017
SignalWire founded by the core team
Cloud-native, programmable, the same engine modernized.
2020
PUC platform — voice, video, messaging, SIP
One control plane across every channel.
2023
AI kernel — STT + LLM + TTS in-process
The media engine gets a brain.
2026
Speech-to-speech, same kernel
No pipeline. Just the model and the audio.

FAQS
What is SignalWire?
SignalWire is a programmable communications platform built on a real-time media engine we own: voice, video, messaging, SIP, and Voice AI through one control plane. We were founded by the FreeSWITCH team and run the same engineering lineage end-to-end.
What is PUC, and why does it matter?
PUC (Programmable Unified Communications) is the category we built. CPaaS gives you APIs without owning the interaction. UCaaS gives you a finished product you can't reshape. PUC gives you both: a programmable surface that owns the call, the channels, and the AI underneath them.
What makes SignalWire a Voice AI platform?
The AI kernel is embedded in the media path, not bolted on top. STT, LLM, TTS, and speech-to-speech all run inside the media engine. That's why typical conversational latency is around 1,200ms and why governance is a property of the runtime instead of a system prompt.
How is SignalWire different from Twilio?
Twilio exposes APIs over a media stack they don't fully own. We own the media engine, the AI kernel, and the control plane. It gives you one stack, one contract, one programming model across every channel. For a side-by-side, see signalwire.com/compare/twilio-alternative.
How is SignalWire different from Vapi, Retell, or LiveKit?
Those vendors orchestrate other companies' stacks (Vapi, Retell) or own great rooms-and-video infrastructure without the carrier-grade phone media engine (LiveKit). We own the entire media engine they orchestrate or borrow from. The orchestration layer is a temporary stack; we removed it ourselves.
Who built SignalWire?
The team that built FreeSWITCH, the open-source real-time voice engine that powers Apple, Amazon, Zoom, and millions of servers worldwide. Founded in 2017 by Anthony Minessale and the core FreeSWITCH engineers.
How does SignalWire's AI governance work?
Governance is enforced by the runtime, not the prompt. PGI (Programmable Governance Interface) scopes which tools an agent can call at each step. The runtime enforces it, not the prompt.The audit trail is structural. Prompt-and-pray is not engineering and we don't treat it as such.
Is SignalWire a CPaaS?
No. CPaaS describes platforms that expose programmable APIs on top of someone else's media engine. We built our own media engine and embedded AI inside it. PUC is the category that captures what we actually are.


