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#

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.