Brisvox vs Pipecat: a Rust alternative for phone and browser voice agents

Brisvox is an alternative to Pipecat for phone and browser voice agents. In the measured runs both systems used the same agent file and the same provider services. On 4 vCPU / 4 GB, Brisvox held 250 concurrent calls within the latency SLO and Pipecat 1.12.0 held 1. Fake provider servers were used for capacity, real providers for latency.

Pipecat facts checked on . Measured against Pipecat 1.12.0 only; newer Pipecat releases were not measured.

Last updated:

What is different in the architecture?

Brisvox is one Rust process with one isolated async session per call, and its models run on a dedicated thread pool. An agent is a TOML or YAML file plus tools in Python, TypeScript or Rust. Pipecat is a Python framework (pipecat-ai), and its documentation describes one session per process or container (Pipecat: running bots in production).

What was measured against Pipecat 1.12.0?

Capacity, memory and voice-to-voice latency, with the same agent file on both systems. The Pipecat side is a Pipecat 1.12.0 bot in the repository (bench/pipecat_baseline) that speaks the same websocket protocol and is measured by the same client with the same definition of voice-to-voice.

Measured here Brisvox Pipecat 1.12.0 Result files
Concurrent calls within the latency SLO (p95 voice-to-voice at most 1110 ms), 4 vCPU / 4 GB. Median, runs in brackets 250 (260, 250, 220) 1 (1, 1, 0) 4 vCPU, SLO runs
Most concurrent calls with no failed call and no lost turn (any latency), 4 vCPU / 4 GB 430 (430, 480, 400) 10 (10, 10, 10) 4 vCPU, max runs
Server memory at that maximum, 4 vCPU / 4 GB (PSS summed over the container’s processes) 753 MB at 430 calls 2.4 GB at 10 calls 4 vCPU, max runs
Concurrent calls within the latency SLO, 8 vCPU / 8 GB 470 (480, 460, 470) 10 (10, 5, 10) 8 vCPU, SLO runs
Most concurrent calls with no failed call and no lost turn, 8 vCPU / 8 GB 780 (740, 780, 800) 10 (10, 20, 10) 8 vCPU, max runs
Server memory at that maximum, 8 vCPU / 8 GB 1.3 GB at 780 calls 3.3 GB at 10 calls 8 vCPU, max runs
Per call at the 4 vCPU / 4 GB maximum: memory and CPU, idle baseline included 1.8 MB, 0.007 cores 239.9 MB, 0.137 cores 4 vCPU, max runs
Voice-to-voice on real providers, English, p50 / p95 (5 concurrent calls, 100 turns, Deepgram Aura voice; Windows, public internet) 1.85 s / 2.88 s 1.97 s / 4.35 s Live run
From this project's own benchmark harness. Capacity and memory rows: fake providers with fixed latencies, Linux cloud containers, 16 and 17 October 2026. Latency row: real providers, one Windows machine, 14 October 2026. Method and caveats

How do the documented features compare?

Documented, Brisvox Pipecat
Language Rust engine; your agent in Python or TypeScript (SDKs on PyPI and npm) or in Rust Python (pipecat-ai 1.12.0) pipecat-ai on PyPIpipecat-ai/pipecat
License MIT or Apache-2.0 BSD-2-Clause pipecat-ai/pipecat
Runtime model One process, one isolated async session per call, models on a dedicated thread pool Documented as one session per process or container Pipecat: running bots in production
Needs a media server No: WebSocket, Twilio and Telnyx built in; WebRTC and SIP are cargo features No for WebSocket and SmallWebRTC; the Daily and LiveKit transports use those vendors’ infrastructure Pipecat: transports
Telephony Twilio and Telnyx media streams, SIP trunk listener, DTMF, transfer Twilio, Telnyx, Plivo, Exotel serializers; no SIP stack of its own found in the pages read (inferred) Pipecat: transports
Turn detection Smart Turn v3.2 (ONNX, on device) with an adaptive policy Smart Turn v3 (8 MB int8) Pipecat: Smart Turn overviewpipecat-ai/smart-turn
Turkish First class, with its own quality notes Listed by Smart Turn pipecat-ai/smart-turn
Interruptions Turn epochs; the context keeps only the text actually played Cancels LLM and TTS, flushes audio, commits only the played text; a minimum-words turn-start strategy and a Krisp backchannel filter Pipecat: interruptions
Tools read_only and side_effect kinds, idempotency keys, never speculative; written in Rust, Python or TypeScript Parallel calls by default, async tools, per-tool timeouts, cancel on interruption; MCP not checked Pipecat: function calling
Speech-to-speech OpenAI Realtime, Gemini Live Several pipecat-ai/pipecat
Overload handling Admission control and graceful drain built in None found in the docs; autoscaling guidance Pipecat: running bots in production
Hosted cloud None, self-host only Optional Pipecat Cloud Pipecat: running bots in productionPipecat Cloud: sizing
Vendor sizing guidance None; see the measured rows Pipecat Cloud profile of 0.5 vCPU / 1 GB per session Pipecat Cloud: sizing
What each project's own documentation and repository said on 14 October 2026. Not benchmarks. "Not stated" and "inferred" are marked as such in the research notes, where every fact carries its URL.

Can I keep my Pipecat clients?

Brisvox accepts RTVI, the protocol of Pipecat's client SDKs, so those clients can connect to a Brisvox server. How to connect one is in docs/RTVI.md. That document covers clients only; this page makes no claim about moving server-side Pipecat code.

How do the two handle turn detection and interruptions?

Both use Smart Turn, an open end-of-turn model: Brisvox runs Smart Turn v3.2 on device with an adaptive policy, and Pipecat's documentation lists Smart Turn v3 as its default stop strategy. On interruption, Pipecat's documentation says it cancels the LLM and TTS, flushes audio and commits only the played text; Brisvox does the same job with turn epochs and played-text truncation, and adds idempotency rules for tools.

In the live run, Pipecat sent more than one LLM request in 56 of 100 turns. The cause was not investigated. One configuration difference is a candidate: 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.

What does Pipecat document that Brisvox does not have?

From Pipecat's own documentation, as read on 14 October 2026:

Caveats on these numbers

  • Capacity runs used fake providers with fixed latencies on Linux cloud containers. They measure each framework and its provider clients, not the providers.
  • The latency run used real providers on one Windows machine over the public internet, with 100 turns per system. The median gap is within the LLM provider's own variance.
  • Pipecat ran as this project's benchmark bot with one worker process per vCPU, not as a deployment tuned by the Pipecat maintainers.
  • The benchmark is this project's own. No independent comparison of the two was found.

The full method, the run conditions and every result file