# Latency Benchmark

## Every Vendor Hop Costs You 200ms

Most platforms measure one step and call it latency. Full roundtrip is what callers feel: sentence ends, AI responds. That gap decides whether they stay or hang up.

< 1.2s  
typical AI response latency  
1  
platform for the full AI pipeline  
2.7B  
minutes processed  
40%  
more abandonment above 1.2s

## The Problem

### Bolt-on pipelines stack latency at every boundary

### Six hops between caller and AI

PSTN to telephony, WebSocket, your server, STT, LLM, TTS, then back through the chain. Each hop adds 50 to 300ms.

### Partial metrics hide the real number

STT-to-first-token and TTS time-to-first-byte each measure one step. Neither measures how long a caller waits between finishing a sentence and hearing the AI.

### Optimization cannot eliminate architecture

Switching to a faster provider saves time on one hop but does not remove the other network boundaries.

### Streaming helps, but boundaries remain

Streaming reduces batch delays, but each stream still crosses a network boundary. Processing inside one engine remains faster.

## Build a Voice AI Agent

### Supported Languages
- Python
- TypeScript
- Go
- Java
- Ruby
- PHP
- Perl
- C++
- C#

```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. "
                                  "Greet 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.
        Args:
            order_id: The order ID to look up
        """
        return FunctionResult(f"Order {order_id}: shipped, ETA April 2nd")

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

## Multi-Vendor Pipeline vs. Single Engine

### Bolt-On Pipeline
- Six or more network boundaries per conversational turn
- Independent queues and timing behavior at every vendor
- Partial metrics hide the full caller roundtrip
- State and cancellation cross asynchronous service boundaries
- Optimization lowers individual hops but cannot remove them

### SignalWire
- One media engine orchestrates the full pipeline
- STT streams concurrently while the caller is speaking
- Cancellation and barge-in occur at the audio layer
- Typical full-roundtrip response stays below 1.2 seconds
- No application-layer orchestration hop
- LLM and TTS coordination happens inside the engine

## Inside One Engine

### How SignalWire Achieves Sub-Second Response

- Call arrives at the media engine  
  The platform owns the audio stream, call state, and timing from the first packet.

- STT streams concurrently  
  Speech recognition begins while the caller is still speaking instead of waiting for a separate application hop.

- LLM inference runs in parallel  
  The AI kernel coordinates context and inference without an external orchestration server between the model and the call.

- TTS generates audio inside the engine  
  Synthesized audio returns directly to the caller with audio-level barge-in and cancellation control.

## 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.

## Measure the full roundtrip yourself.

Run the same conversation on your current stack and on SignalWire. Compare what your callers actually experience.