Benchmarks: Brisvox against Pipecat 1.12.0, measured
In capacity runs on cloud containers (AMD EPYC 9655P, 16 and 17 October 2026), Brisvox held 250 concurrent calls within a p95 voice-to-voice latency of 1110 ms on 4 vCPU and 4 GB, where Pipecat 1.12.0 held 1 under the same limit. Both systems talked to fake provider servers with fixed latencies, so these numbers measure the engine and its provider clients, not the providers.
Data as of . Capacity runs: 16 and 17 October 2026. Live run: 14 October 2026. Compared version: Pipecat 1.12.0. LiveKit Agents was not measured.
Last updated:
Read this first
- Every figure on this page comes from a result file committed under
bench/results/. Each file starts with the command that produced it and a description of the machine. - Capacity runs used fake providers. They speak the real Deepgram and OpenAI-compatible protocols over TLS with fixed latencies, so the numbers include each system's provider client code, TLS and both on-device models, but not the providers' own variance.
- The live run is one evening on one Windows machine over the public internet, 100 turns per system. Absolute numbers carry noise.
- Engine overhead is a Windows run over mock providers. It shows how much time the engine adds, not what a live call feels like.
- This is the project's own harness. No independent third-party density comparison of these systems was found (research notes).
How many concurrent calls does one container hold?
Within a p95 voice-to-voice latency of 1110 ms, Brisvox held 250 calls on 4 vCPU / 4 GB and 470 on 8 vCPU / 8 GB (median of three runs); Pipecat 1.12.0 held 1 and 10. With no failed call and no lost turn at any latency, Brisvox held 430 and 780; Pipecat held 10 and 10. Fake providers, real Silero VAD and Smart Turn models on every call.
250 concurrent calls, Brisvox Pipecat 1.12.0: 1
430 concurrent calls, Brisvox Pipecat 1.12.0: 10
470 concurrent calls, Brisvox Pipecat 1.12.0: 10
780 concurrent calls, Brisvox Pipecat 1.12.0: 10
Most concurrent calls with p95 voice-to-voice at most 1110 ms (the fake providers’ own 860 ms plus 250 ms). One 4 vCPU / 4 GB container on AMD EPYC 9655P, median of 3 runs: Brisvox 250 (260, 250, 220), Pipecat 1.12.0 1 (1, 1, 0). Both run their own provider clients against fake providers over TLS, with Silero VAD and Smart Turn on every call. How it was measured
Most concurrent calls with no failed call and no lost turn, at any latency. One 4 vCPU / 4 GB container on AMD EPYC 9655P, median of 3 runs: Brisvox 430 (430, 480, 400), Pipecat 1.12.0 10 (10, 10, 10). Both run their own provider clients against fake providers over TLS, with Silero VAD and Smart Turn on every call. How it was measured
Most concurrent calls with p95 voice-to-voice at most 1110 ms (the fake providers’ own 860 ms plus 250 ms). One 8 vCPU / 8 GB container on AMD EPYC 9655P, median of 3 runs: Brisvox 470 (480, 460, 470), Pipecat 1.12.0 10 (10, 5, 10). Both run their own provider clients against fake providers over TLS, with Silero VAD and Smart Turn on every call. How it was measured
Most concurrent calls with no failed call and no lost turn, at any latency. One 8 vCPU / 8 GB container on AMD EPYC 9655P, median of 3 runs: Brisvox 780 (740, 780, 800), Pipecat 1.12.0 10 (10, 20, 10). Both run their own provider clients against fake providers over TLS, with Silero VAD and Smart Turn on every call. How it was measured
| Container and limit | Brisvox | Pipecat 1.12.0 | LiveKit Agents | Result files |
|---|---|---|---|---|
| 4 vCPU / 4 GB. Within the latency SLO | 250 (260, 250, 220) | 1 (1, 1, 0) | Not measured | Brisvox, Pipecat |
| 4 vCPU / 4 GB. No failed call, no lost turn | 430 (430, 480, 400) | 10 (10, 10, 10) | Not measured | Brisvox, Pipecat |
| 8 vCPU / 8 GB. Within the latency SLO | 470 (480, 460, 470) | 10 (10, 5, 10) | Not measured | Brisvox, Pipecat |
| 8 vCPU / 8 GB. No failed call, no lost turn | 780 (740, 780, 800) | 10 (10, 20, 10) | Not measured | Brisvox, Pipecat |
On these cores a single Pipecat call already answers at a p95 of about 1.05 to 1.1 s, about 200 ms above the providers' floor, against 10 to 30 ms for Brisvox. Its SLO number is therefore decided by per-turn latency more than by load: one of its three 4 vCPU runs missed the 1110 ms limit at one call by 4 ms.
What stops each system: Pipecat ran one worker process per vCPU with Silero and Smart Turn loaded in each, and ran out of memory at 20 calls in 4 GB. With 8 GB it lost turns at 20 calls in two of three runs. Brisvox is bound by CPU: twice the container gave about 1.9 times the calls.
How much memory and CPU does a call use?
At maximum load on 4 vCPU / 4 GB, the Brisvox server used 753 MB for 430 calls, and Pipecat 1.12.0 used 2.4 GB for 10 calls. Per call, idle baseline included: 1.8 MB and 0.007 cores for Brisvox, 239.9 MB and 0.137 cores for Pipecat. Same fake-provider runs as above.
| Container | Brisvox | Pipecat 1.12.0 |
|---|---|---|
| 4 vCPU / 4 GB, server memory at the maximum | 753 MB at 430 calls | 2.4 GB at 10 calls |
| 8 vCPU / 8 GB, server memory at the maximum | 1.3 GB at 780 calls | 3.3 GB at 10 calls |
| Per call at the 4 vCPU maximum | 1.8 MB, 0.007 cores | 239.9 MB, 0.137 cores |
What happens to latency as the load grows?
Latency stays at the providers' floor until a system runs out of CPU or memory, then crosses the SLO within a step or two. The number that matters is where that happens.
Latency as the load grows
Voice-to-voice per load step, 8 vCPU / 8 GB container, one run per system (the median run).
- Brisvox, p95
- Brisvox, p50
- Pipecat 1.12.0, p95
- SLO, 1110 ms
Brisvox: at the providers' floor up to about 480 calls
780 calls: no failed call, no lost turn,
p95 3.7 s at that load
Pipecat: turns lost at 20 calls
in this run, and in two of three
Concurrent calls
How fast is voice-to-voice on real providers?
Over 5 concurrent calls and 100 turns per system, the median voice-to-voice time was 1.85 s for Brisvox and 1.97 s for Pipecat 1.12.0, and the p95 was 2.88 s against 4.35 s. The run was on a Windows development machine over the public internet, one evening, and the LLM provider's own variance is as large as the median gap (126 ms).
| Voice-to-voice, English | Turns | p50 | p90 | p95 | p99 |
|---|---|---|---|---|---|
| Brisvox | 100 | 1846 ms | 2209 ms | 2876 ms | 5199 ms |
| Pipecat 1.12.0 | 100 | 1972 ms | 2980 ms | 4348 ms | 6141 ms |
| Stage, p50 / p95 in ms | Brisvox | Pipecat |
|---|---|---|
| STT final after the end of speech | 300 / 363 | 455 / 505 |
| LLM first token (OpenRouter included) | 931 / 1984 | 889 / 3483 |
| TTS first audio (Deepgram Aura) | 220 / 416 | 251 / 265 |
- Same agent file, same providers. Deepgram nova-3 (STT), OpenRouter openai/gpt-6-luna with reasoning effort none pinned to one upstream (LLM), Deepgram Aura aura-2-thalia-en (TTS). 10 blocks of 10 turns per system, strictly alternating, so both saw the same provider conditions.
- Medians are close, tails are not. The LLM first token took about the same time on both. Pipecat sent more than one LLM request in 56 of 100 turns, which is where its tail comes from. The cause was not investigated; it is consistent with a turn ended at a pause inside the utterance.
- One setting was not equal. The same nominal 100 ms of silence before the VAD stop is 3 Silero windows (96 ms) in Pipecat and 4 (128 ms) in Brisvox, so Pipecat decides about 32 ms earlier at every turn end.
- The STT final arrived earlier through Brisvox because its Finalize runs at the VAD stop instead of waiting for the provider's own endpointing.
- An earlier run with a Cartesia voice, one call at a time and 30 turns, gave 1.69 s against 2.03 s at the median.
The breakdown by stage and the routing check are in the "Live comparison with real providers" section of docs/LATENCY.md.
How much time does the engine itself add?
The engine's own added time is 0.089 ms at p95 from the end of turn to the LLM request, against a budget of 3 ms. The three budgeted stages are met by one to two orders of magnitude. Measured on the production pipeline over mock providers behind the real websocket transport, 60 latency turns and 30 barge-ins, Windows.
| Stage | p50 | p95 | Budget at p95 |
|---|---|---|---|
End of turn to LLM request turn_end_to_llm_request | 0.051 ms | 0.089 ms | 3 ms, met |
First TTS audio to transport tts_audio_to_transport | 0.035 ms | 0.064 ms | 2 ms, met |
Barge-in decision to Clear applied interrupt_to_clear | 0.012 ms | 0.022 ms | 1 ms, met |
From the same run: about 1.0 MiB of memory per call on the production pipeline with 8 calls alive at once, of which roughly half is the Smart Turn audio ring and its analysis snapshot.
More results
In-process load, reference pipeline
N simulated calls at once in one process, real time, 3 turns per call, over mocks. Not a capacity limit: the host had 32 cores and the process used under half a core.
| Calls | Answered | Overhead p50 | Overhead p99 | CPU cores | RSS per call |
|---|---|---|---|---|---|
| 100 | 300/300 | 0.077 ms | 0.842 ms | 0.28 | 142 KiB |
| 300 | 900/900 | 0.130 ms | 1.965 ms | 0.47 | 133 KiB |
| 500 | 1500/1500 | 0.173 ms | 1.675 ms | 0.37 | 132 KiB |
Speculative LLM start
The LLM request can start at a candidate end of turn and be committed only when the turn really ends. Speculation helps only when the last interim transcript at the VAD stop already equals the final one; otherwise it costs a full extra request per turn and gains nothing.
| Speculation | Turns | Voice-to-voice p50 | Extra LLM requests per turn |
|---|---|---|---|
| Off | 120/120 | 923 ms | 0.00 |
| On, STT interims that already hold the full text | 120/120 | 782 ms | 0.00 |
| On, STT interims a word short of the final | 120/120 | 925 ms | 1.00 |
Run conditions
| Condition | Capacity and memory | Live voice-to-voice |
|---|---|---|
| Dates | 16 and 17 October 2026 | 14 October 2026, one evening |
| Hardware | Linux containers on AMD EPYC 9655P (Zen 5), limited to 4 vCPU / 4 GB and 8 vCPU / 8 GB, limits checked in the container's own samples | One Windows development machine, public internet |
| Build | Release builds, one system at a time | |
| Providers | Fake providers in a container of their own: STT final 150 ms after 300 ms of endpointing, LLM first token 350 ms, TTS first audio 150 ms. Real Deepgram and OpenAI-compatible protocols over TLS (bench/fake_providers) | Deepgram nova-3 (STT), OpenRouter openai/gpt-6-luna with reasoning effort none pinned to one upstream (LLM), Deepgram Aura aura-2-thalia-en (TTS) |
| On-device models | Silero VAD and Smart Turn v3.2 on every call, on both systems | |
| Brisvox | brisvox-server with its Rust adapters; admission control off for the ramp | The same agent file as Pipecat |
| Pipecat | A Pipecat 1.12.0 bot with DeepgramSTTService, OpenAILLMService and DeepgramTTSService, one worker process per vCPU, on the same websocket protocol and agent file | The same bot, same providers and models |
| Load and sample | A ramp of concurrent calls from a load generator in its own container; 3 runs per cell on fresh containers | 5 concurrent calls, 10 blocks of 10 turns per system, strictly alternating |
| Measured by | The same client with the same definition of voice-to-voice: the first non-silent agent audio sample leaving the transport, minus the ground-truth end of the caller's speech | |
What these numbers do not show
- Not real provider behaviour under load. Fake providers answer with fixed latencies and never rate-limit. Your providers' limits and variance apply on top.
- Not a tuned Pipecat deployment. Pipecat ran as this project's benchmark bot, not as a deployment tuned by the Pipecat maintainers, and only version 1.12.0 was measured.
- Not LiveKit Agents. It was not part of these runs. Nothing here says Brisvox is faster or denser than LiveKit Agents.
- Not your hardware. The Smart Turn model is heavy on memory bandwidth (about 200 MB of memory traffic per analysis), so on a machine with little memory bandwidth it can stop Brisvox from scaling with cores before the CPU does. Size capacity on server hardware, or measure it on the target host.
- Not an independent benchmark. The harness, the Pipecat baseline and the fake providers are in the repository so that anyone can check them.
Reproduce it
The capacity comparison runs locally in Docker containers with the same limits. The harness, its options and the metric definitions are in the results README.
git clone https://github.com/bilal07karadeniz/brisvox && cd brisvox
PROVIDERS=fakes MODELS=1 bench/capacity_linux.sh bench/results/README.md lists every result file. docs/LATENCY.md discusses the numbers section by section. The book's benchmark chapter has the definitions. docs/TESTING.md explains how the engine is proven correct.