One QUIC transport and one C++ runtime carry robot control, live video, phone calls and model output on a single connection.
Every figure comes from a benchmark we can rerun in front of you.
A single unit of your data, on the wire.
That packet is one of thousands on a single connection.
Every core runs its own connections, full tilt.
messages/second on one 8-core box, and improving. 36,732 concurrent connections at 0.4% CPU.
Every box, every modality, on the same transport.
A scrap of sound, captured the instant it's spoken.
Words on the wire, in real time.
Caller, model, agent: one pipe, both directions.
The line tells the caller from the TV, a coworker, or background noise, and listens to the right one.
On every provider, with first-class barge-in.
A teacher, a seller, a match: RTMP or WHIP in.
Media-over-QUIC sends each frame as soon as it is made, not in 6-second chunks.
Fan-out at the edge, with a fallback to HLS on Safari.
live 1080p viewers on one 8-vCPU server, nothing lost.
A single piece of the answer, fresh off the model.
Tokens leave the GPU and start arriving immediately.
Point your OpenAI-compatible client at the line. Nothing in your app changes.
Same SSE wire your client already speaks. The moment a token exists, your app has it.
Explore in detail →Four modalities, in one place.
A stall in one never blocks another. No head-of-line blocking.
One line, nothing to glue together.
A carrier hands you an inbound call.
Media rides QUIC direct to the agent, no extra hops in the path.
Listen, whisper, or take over, all over the same connection, without rerouting the call.
Fan it out to every supervisor and dashboard, live.
Onboard autonomy stays on its own network.
A live mirror of everything it senses.
Reaches the cloud over QUIC. Observe from anywhere.
Input rides its own fast lane, as datagrams.
Fast state as datagrams, chat and events on reliable streams.
Players whose network blocks game ports still connect, on port 443.
Tick-aligned state, lobby and matchmaking included.
Every branch flows back into the same transport line.
workloads, one transport. Add a workload, not a stack.
Inference runs on the same connection as your audio, video and robot control, so the model knows the moment its answer stops mattering.
A caller hangs up, a deadline passes, or the user talks over the agent. The transport carries that signal to the model and the generation stops. You stop paying for tokens nobody will hear.
Written in C++. It saves the attention state of a conversation and loads it back on the next turn, so the model does not compute the same prompt twice.
The same cache works for vision-language models. A robot that asks several questions about one task gets its first answer about twice as fast.
The router reads live cache and load metrics from Triton and TensorRT-LLM, and picks a GPU on that data. OpenAI-compatible API, your model, your GPUs.
We serve open-weight text-to-speech and speech-to-text models on our own C++ engine. Every number below is from one GPU: an RTX A5000 that rents for $0.27 an hour, or an H100 where we say so.
| Model | Ours | On the Coval board |
|---|---|---|
| Qwen3-TTS 1.7B | 53 / 76 | Nari Labs 63 / 91 · Baseten 104 / 132 |
| Fish Audio S2-Pro (open weights)Different releases (S2-Pro vs S2.1 Pro). Fish Audio Research License: non-commercial. | 52 / 103 | Fish Audio's hosted S2.1 Pro 352 / 477 |
| Fish Audio S1-mini (open, 0.5B)Different model sizes. CC-BY-NC-SA: non-commercial. | 147 / 195 | Fish Audio's hosted S1 (4B) 398 / 515 |
Coval's public prompt set; the board uses a private one. Our GPU was about 16 ms from the test client.
| Model | Ours | On the Coval board |
|---|---|---|
| Whisper large-v38-bit (w8a8) build with a distil-large-v3 draft model | H100 64 / 122A5000 103 / 206 | Baseten 112 / 248 · Together 108 / 232 |
| Parakeet TDT 0.6B v3WER 5.9 % on our clips | H100 42 / 62A5000 49 / 75 | Together 49 / 139 |
| Parakeet TDT 0.6B v2 | H100 36 / 52A5000 46 / 77 | Not listed |
Our seed-0 sample of the board's 7 test sets, 50 clips each. The client was a cloud VM about 10 ms from the GPU. Each GPU served only our test; the hosts on the board are shared services.
p50 / p95. These are our own runs of Coval’s open benchmark method, not entries on the Coval leaderboard; board figures were read on 14 October 2026. We do not compare accuracy with the board, because the test clips differ.
We time what the robot sees: it sends its camera frames, waits for the next action, and counts every request that gets no answer. Every number below ran over our production relay.
Our own runs on 17 and 18 October 2026. A request with no answer counts as a failure; nothing is dropped from the totals. Each round trip is timed on the robot, by its own clock.
Voxtral-4B-TTS on our engine and on vLLM-Omni, on the same RTX A5000 with 64 calls at once. Ours starts to speak in about 60 ms (p50). vLLM-Omni takes more than 6 s.
Some models start each reply with a tenth of a second of near-silence. Our server now skips it, so Fish S1-mini is audible about 42 ms after the request and Voxtral about 43 ms, at one call.
Qwen3-ASR 1.7B, the most accurate of the four English models we serve (WER 3.67 % on the seven English test sets that Coval uses), sends partial text while the caller is still talking. One RTX A5000 holds 64 live English streams.
The π0.5 (DROID) vision-language-action model runs inside our serving stack, on our C++ runtime. One action chunk takes about 27 ms on an RTX PRO 6000.
We built our own VPN, remote desktop and tunnel on the same transport that carries robots, video and voice. We run them every day, so the runtime is tested by long, ordinary use, not only by benchmarks. You can use them too.
IP over QUIC. Sessions survive a change of network, and traffic on port 443 looks like ordinary HTTPS. Two-factor sign-in and per-user entitlements. Desktop clients for Windows, macOS and Linux.
Screens go through a relay you host, so pixels never leave your infrastructure. Frames carry priority and expiry, and sessions survive roaming. Attended or unattended.
A self-hosted alternative to ngrok and frp. One command gives a local service with no public IP a stable public URL, with token and IP policy at the edge instead of in your app.
Nine language SDKs, from the browser to embedded devices, plus a ROS 2 middleware binding for robots.
Async client, drop-in for the realtime API. Packages are shared during your pilot.
Browser + Node, with a helper for browser media over your transport.
Bare-metal bindings to the core. Zero-copy frame handoff.
# realtime voice in 6 lines from clutchcall import Session s = Session(provider="openai-realtime") async for ev in s.connect("+1..."): if ev.bargein: s.cancel() # instant play(ev.audio)
Coming from another transport? The migration guide maps your existing calls onto the substrate one site at a time.
Read the migration guide →Six weeks on your real traffic, with success criteria we agree in writing. The pilot fee is credited to your first month if you continue.
Production is priced per concurrent channel per month, with telephony passed through. On-prem is licensed per node. We quote against your workload after a 30-minute call.
Teams whose product breaks when the network is slow: voice-AI agents on phone lines, interactive live video (classes, live commerce, watch-alongs), robot teleoperation, and model serving that streams to users. All of them run on the same QUIC transport and the same C++ runtime. Each use case has its own page with its own numbers and questions; start with the one closest to your product.
No. The substrate speaks the interfaces you already use: a drop-in shim for OpenAI Realtime and a SIP listener for voice, RTMP and WHIP ingest for live video, a ROS 2 middleware binding for robots, and an OpenAI-compatible SSE endpoint for inference. Idiomatic SDKs in 9 languages are there when you want native types.
TCP delivers bytes in order, so one lost packet stalls everything behind it on the connection: your agent's audio waits behind a text message, a video frame waits behind a control command. QUIC streams are independent, so a lost packet delays only its own stream. QUIC also survives a change of network (Wi-Fi to mobile) without a new handshake. For background, read Chrome's announcement of HTTP/3 and IETF QUIC.
WebTransport ships in Chrome and Edge today. Safari and Firefox still trail, and some corporate proxies block UDP. Every client has a fallback: voice falls back to WebSocket over HTTPS with the same agent and the same interruption path, and the live-video player falls back to HLS, then MP4. You lose QUIC's benefits on that one client, and nothing else changes.
Every engagement starts with a paid 6-week pilot on your real traffic, with success criteria we agree in writing. The pilot fee is credited to your first month if you continue. Production is priced per concurrent channel per month for voice, with telephony passed through, and against delivered viewer-minutes for live video. On-prem is licensed per node. We quote against your workload after a 30-minute call.
Yes. The core is a single statically-linked binary plus a Redis. It runs in your own racks, including air-gapped sites where the model worker is also local. Hosted and self-hosted tenants run the same wire protocol, so behaviour matches.
Python, TypeScript, Go, Rust, Java, C#, Swift, Kotlin, and C++, with the same API shape and idiomatic types per language. They all wrap one C++ core via FFI, so a wire-protocol fix in the core ships to every SDK on rebuild. Python and TypeScript see the most use; the others run against a polyglot smoke matrix on every release.
We do not hold SOC 2 or HIPAA certification today. For regulated buyers we deploy on-prem, in your own data centre or cloud account, so audio, video and robot data stay inside your infrastructure. Hosted pilots run in a single region we agree with you. We do not train models on customer data.
It starts with a 30-minute call to map your current stack and agree the success criteria. We then connect your carrier, encoder, robot or model, and run the 6-week pilot on real traffic. Setup time depends on your integration; we give you a date on the first call.
ClutchCall is built by Throughgen Innovations Private Limited. We write the runtime, the transport and the GPU cache ourselves, in C++, at the systems level. It is not a wrapper around someone else's API.
New to QUIC? Our free academy teaches networking from the ground up: layers, DNS, NAT, latency, then TCP versus QUIC and Media-over-QUIC, with hands-on labs.
Designed and wrote the C++ runtime, the transport and the edge network. Leads the company and works directly with every pilot customer.
Leads go-to-market and product strategy. An interdisciplinary researcher, with a minor planet named after him.