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

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

Container and limitBrisvoxPipecat 1.12.0LiveKit AgentsResult 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
Median of three runs, with each run in brackets.

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.

ContainerBrisvoxPipecat 1.12.0
4 vCPU / 4 GB, server memory at the maximum753 MB at 430 calls2.4 GB at 10 calls
8 vCPU / 8 GB, server memory at the maximum1.3 GB at 780 calls3.3 GB at 10 calls
Per call at the 4 vCPU maximum1.8 MB, 0.007 cores239.9 MB, 0.137 cores
Memory is PSS (proportional set size: a page shared by several processes is split between them), summed over the server container's processes, from its cgroup samples every 2 s.

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

Brisvox stays at the providers' floor, about 860 ms, up to about 480 calls, and holds 780 with no failed call and no lost turn (p95 about 3.7 s at that load). Past its maximum the p95 stays near 3.7 s: turns whose Smart Turn verdict comes too late end on the 3 s fallback silence. In production, admission control refuses new calls before that point; it was off for this ramp. Files: Brisvox run 2, Pipecat run 1

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, EnglishTurnsp50p90p95p99
Brisvox1001846 ms2209 ms2876 ms5199 ms
Pipecat 1.12.01001972 ms2980 ms4348 ms6141 ms
Same client and the same definition for both. All 200 turns were answered; no failed call on either side.
Stage, p50 / p95 in msBrisvoxPipecat
STT final after the end of speech300 / 363455 / 505
LLM first token (OpenRouter included)931 / 1984889 / 3483
TTS first audio (Deepgram Aura)220 / 416251 / 265
Each system's own timers. The two systems' timers are not measured from the same point, so the STT row is not a share of the gap.
  • 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.

Stagep50p95Budget at p95
End of turn to LLM request turn_end_to_llm_request0.051 ms0.089 ms3 ms, met
First TTS audio to transport tts_audio_to_transport0.035 ms0.064 ms2 ms, met
Barge-in decision to Clear applied interrupt_to_clear0.012 ms0.022 ms1 ms, met
The worst barge-in clear of the 30 was 0.669 ms, one scheduling delay. Source: bench/results/v2v-sim.md

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.

CallsAnsweredOverhead p50Overhead p99CPU coresRSS per call
100300/3000.077 ms0.842 ms0.28142 KiB
300900/9000.130 ms1.965 ms0.47133 KiB
5001500/15000.173 ms1.675 ms0.37132 KiB
Source: bench/results/sim-baseline.md

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.

SpeculationTurnsVoice-to-voice p50Extra LLM requests per turn
Off120/120923 ms0.00
On, STT interims that already hold the full text120/120782 ms0.00
On, STT interims a word short of the final120/120925 ms1.00
Production engine over mock providers on a paused clock, deterministic per seed, real speech fixtures. Source: bench/results/speculation-fixtures.md

Run conditions

ConditionCapacity and memoryLive voice-to-voice
Dates16 and 17 October 202614 October 2026, one evening
HardwareLinux 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 samplesOne Windows development machine, public internet
BuildRelease builds, one system at a time
ProvidersFake 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 modelsSilero VAD and Smart Turn v3.2 on every call, on both systems
Brisvoxbrisvox-server with its Rust adapters; admission control off for the rampThe same agent file as Pipecat
PipecatA Pipecat 1.12.0 bot with DeepgramSTTService, OpenAILLMService and DeepgramTTSService, one worker process per vCPU, on the same websocket protocol and agent fileThe same bot, same providers and models
Load and sampleA ramp of concurrent calls from a load generator in its own container; 3 runs per cell on fresh containers5 concurrent calls, 10 blocks of 10 turns per system, strictly alternating
Measured byThe 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.

Capacity, local Docker
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.