--- LiveKit Alternative ---

# Rooms Are for Video. Calls Need a Phone Company.

LiveKit handles video rooms well. When the use case is voice AI answering phone calls, the architecture needs native telephony, not a WebRTC bridge.

< 1.2s
typical AI response latency

0
bridge hops on SignalWire

1-2.5s
added latency from SIP-to-WebRTC bridge

2,000+
companies on the platform

--- The Problem ---

## A video conferencing model forced onto phone calls

### Two platforms, two bills, two failure modes

LiveKit for media processing, plus a separate CPaaS for phone numbers. Two contracts, two SLAs, two support teams. When the call state diverges between systems, debugging requires checking both.

### Every call creates a video conference room

A bilateral phone call gets room infrastructure designed for multi-party video. The caller becomes a 'participant.' The AI agent 'joins' the room. Audio flows through WebRTC track subscriptions.

### Transfers mean migrating between rooms

Transferring a call moves a participant from one room to another instead of using standard SIP transfer primitives. LiveKit's SIP REFER took nine months to ship and remains fragile.

### Bridge latency developers call 'unbearable'

In GitHub Issue #3685, a developer reported that latency becomes 'quite unbearable' when applying LiveKit agents to inbound calls via Twilio. Others measured 1 to 2.5 seconds from the SIP-to-WebRTC bridge.

## Build a Voice AI Agent

Python

TypeScript

Go

Java

Ruby

PHP

Perl

C++

C#

Rust

```python
from signalwire import AgentBase
from signalwire.core.function_result import FunctionResult

class SupportAgent(AgentBase):
    def __init__(self):
        super().__init__(name="Support Agent", route="/support")
        self.prompt_add_section("Instructions",
                              body="You are a customer support agent. \nGreet the caller and resolve their issue.")
        self.add_language("English", "en-US", "rime.spore:mistv2")

@AgentBase.tool(name="check_order")
    def check_order(self, order_id: str):
        """Check the status of a customer order.\n        Args:\n            order_id: The order ID to look up\n        """
        return FunctionResult(f"Order {order_id}: shipped, ETA April 2nd")

agent = SupportAgent()
agent.run()
```

## The architectural difference

### LiveKit (Room-Based)

- SIP trunk receives call from external CPaaS
- Room created dynamically for each call
- Caller becomes a room participant
- AI agent joins the room as another participant
- Audio flows through WebRTC track subscriptions
- Transfer moves participants between rooms

### SignalWire (Call-Based)

- Call arrives at SignalWire (the phone company)
- AI agent answers the call directly
- Audio flows through the native media stack
- Transfer uses standard telephony primitives
- State lives in the call object, not a room
- One platform, one bill, no external CPaaS

## Platform comparison

| Capability             | LiveKit                                           | SignalWire                                 |
|------------------------|--------------------------------------------------|-------------------------------------------|
| Native PSTN            | No (requires an external CPaaS)                  | Yes                                       |
| Phone numbers          | US only, inbound only                           | Global, inbound + outbound                 |
| SIP transfers          | SIP REFER (9 months to ship, fragile)           | Cold, warm, blind, attended               |
| Call abstraction       | Room with participants                           | First-class call object                   |
| State management       | Manual (closed as 'Not Planned')                | Built-in shared data layer                |
| Media transport        | SIP-to-WebRTC bridge                            | Native SIP/PSTN, no bridge                |
| Pricing model          | LiveKit + CPaaS provider                         | One platform, one bill                    |
| Agent SDK              | 8+ coordinated packages                          | pip install signalwire-agents             |
| IMS compatibility      | Breaks on Session Timers                         | Full support (FreeSWITCH heritage)        |

## Who should consider switching

### Voice AI on phone calls, not browser sessions

Teams building AI agents that handle inbound or outbound phone calls where native SIP and PSTN matter more than WebRTC rooms.

### Reliable transfers in production

Organizations that need cold, warm, blind, and attended transfers to work without SIP REFER fragility or room migration.

### One vendor instead of two

Developers who want telephony and AI processing from a single platform instead of managing LiveKit plus a CPaaS provider.

### Sub-second latency without bridge overhead

Teams where 1 to 2.5 seconds of extra bridge latency is unacceptable. SignalWire's media stack has zero bridge hops for telephony.

## Migrate from LiveKit in four steps

1. ### Install the SDK
   pip install signalwire-agents. One package replaces eight LiveKit packages plus a CPaaS provider.

2. ### Define your agent
   Inherit AgentBase, set prompts, add tools with Python decorators or YAML. Under 20 lines for a production agent.

3. ### Configure your numbers
   Port existing numbers or provision new ones. Global coverage, inbound and outbound, from a single platform.

4. ### Route incrementally
   Point specific numbers at SignalWire agents while keeping other traffic on existing infrastructure. No all-or-nothing migration.

When LiveKit is the right choice

Multi-party video sessions, browser-first WebRTC applications, and use cases where the rooms model is the right abstraction. This page is about voice AI on phone calls, where the requirements are different.

Frequently Asked Questions

## FAQ

### Do I need to rewrite my agent logic?

Agent logic (prompts, tools, business rules) translates directly. The SignalWire SDK uses Python decorators and YAML definitions. The platform handles telephony, not your code.

### Can I keep using my STT and TTS providers?

Yes. STT, TTS, and LLM providers are configured at the platform level. Bring your own API keys or use SignalWire's integrated providers.

### What about latency compared to LiveKit?

SignalWire's typical AI response latency is 800-1200ms with no bridge overhead, as low as 600ms with speech-to-speech voice models. LiveKit adds 1 to 2.5 seconds from the SIP-to-WebRTC bridge, per developer reports.

### Is SignalWire open source?

The Python agents SDK is open source on GitHub. The platform itself is commercial infrastructure built on FreeSWITCH, which the SignalWire team created.

### What does it cost?

Voice AI at $0.16 per minute, flat rate. One bill from one vendor. No separate CPaaS charges, no hidden markup chain.

## Sigmond Runs on SignalWire

A voice and video AI agent built on the SignalWire SDK, wired to a live knowledge base, able to see what you show him. Build the same thing on voice, phone, WhatsApp, or SIP, or an entire white-label platform with SignalWire as the network underneath.

## Call recording

This call is recorded. Audio and transcripts are used to improve our AI and customer support experience, and aren't shared or sold to third parties.

## Rooms are great for video. Calls need a phone company.

Native telephony, sub-second AI latency, and one platform instead of two.