Robotics · Live streaming · Voice AI · Inference · Netcode

Real-time infrastructure for physical and multimodal AI.

One QUIC transport and one C++ runtime carry robot control, live video, phone calls and model output on a single connection.

Measured, not modelled

One runtime. Real hardware. Real numbers.

Robot teleoperation63live sessions on one CPU core, at 40 ms p95 round trip and 100% deliveryMeasured · relay on GCE c4-highcpu-8, real NIC, run to saturation
Voice24,000concurrent calls on one 8-vCPU server, every packet delivered, at 52% CPUMeasured · G.711, same box and harness: pion 22,000 at 83% CPU · Asterisk 4,000 · FreeSWITCH 1,000
Live streaming1,500live 1080p viewers on one 8-vCPU server, full bitrate, 0 lostMeasured · RTMP ingest → relay on GCE c4-highcpu-8 → SDK viewers, 9 Gbps out at 61% CPU
Inference53 msto first audio from Qwen3-TTS 1.7B on one RTX A5000 (p50; p95 76 ms)Measured · our run of Coval's open method, public test set · same model on the board: Nari Labs 63 ms, Baseten 104 ms

Every figure comes from a benchmark we can rerun in front of you.

Running today
Contact centre · MalaysiaA live contact centre runs on our runtime, on-prem, through a white-label partner.In production
Voice-AI platform · IndiaReal inbound phone calls reach its AI agents through our Mumbai SIP edge.Pilot
Voice-agent companyIts own voice agent is being integrated on our transport.Integration under test
one box · 8 cores
voiceinferencewebrtcsiproboticsgames
01 · The substrate

It starts with one packet.

A single unit of your data, on the wire.

One live connection.

That packet is one of thousands on a single connection.

One core.

Every core runs its own connections, full tilt.

122,367★

messages/second on one 8-core box, and improving. 36,732 concurrent connections at 0.4% CPU.

One substrate.

Every box, every modality, on the same transport.

AI
TV
noise
caller
coworker
02 · Voice AI

It starts with one sample.

A scrap of sound, captured the instant it's spoken.

Which becomes speech.

Words on the wire, in real time.

A live call.

Caller, model, agent: one pipe, both directions.

It hears the whole room.

The line tells the caller from the TV, a coworker, or background noise, and listens to the right one.

Thousands of calls at once.

On every provider, with first-class barge-in.

OpenAI RealtimeGemini LiveElevenLabsAnthropicDeepgram
Explore in detail →
03 · Interactive live

It starts with one camera.

A teacher, a seller, a match: RTMP or WHIP in.

Frames, the moment they exist.

Media-over-QUIC sends each frame as soon as it is made, not in 6-second chunks.

One relay, every viewer.

Fan-out at the edge, with a fallback to HLS on Safari.

1,500

live 1080p viewers on one 8-vCPU server, nothing lost.

RTMPWHIPMoQHLS fallback
Explore in detail →
04 · Inference

It starts with one token.

A single piece of the answer, fresh off the model.

A stream off the GPU.

Tokens leave the GPU and start arriving immediately.

Straight to your client.

Point your OpenAI-compatible client at the line. Nothing in your app changes.

First token, fast.

Same SSE wire your client already speaks. The moment a token exists, your app has it.

Explore in detail →
meet.example.com/abc-xyz
you
alex
jordan
sam
05 · Browser · WebRTC

Audio, video, text and control.

Four modalities, in one place.

Each on its own lane.

A stall in one never blocks another. No head-of-line blocking.

All on one connection.

One line, nothing to glue together.

On your transport.

Your path end to end, no plugins, no native app.

Explore in detail →
06 · SIP · Telephony

It starts with one call.

A carrier hands you an inbound call.

Then straight to your agent.

Media rides QUIC direct to the agent, no extra hops in the path.

Pull a human onto the line.

Listen, whisper, or take over, all over the same connection, without rerouting the call.

One call, the whole wallboard.

Fan it out to every supervisor and dashboard, live.

TwilioPlivoVobizTeleCMITata IMSAudiocodes
Explore in detail →
07 · Robotics

One robot, in control.

Onboard autonomy stays on its own network.

Its data, in realtime.

A live mirror of everything it senses.

Up to the cloud.

Reaches the cloud over QUIC. Observe from anywhere.

500

live tracks per shard at 50 fps, zero loss.

ROS 2ZenohMQTTDDS
Explore in detail →
08 · Games · Netcode

A player acts.

Input rides its own fast lane, as datagrams.

Two lanes, one session.

Fast state as datagrams, chat and events on reliable streams.

Even behind a firewall.

Players whose network blocks game ports still connect, on port 443.

Every player, in sync.

Tick-aligned state, lobby and matchmaking included.

UnityWeb · WebTransport
Explore in detail →
Seven workloads converge on one substratevoicestreaminginferencewebrtcsiproboticsgames
09 · One substrate

Seven workloads. One substrate.

Every branch flows back into the same transport line.

7

workloads, one transport. Add a workload, not a stack.

Inference

Serving that respects the GPU.

Inference runs on the same connection as your audio, video and robot control, so the model knows the moment its answer stops mattering.

Cancel propagation

The GPU stops when the user does.

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.

Three triggers · caller · deadline · newer turn
ClutchKV

Our own KV cache for vLLM.

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.

Follow-up turn 129 ms vs 353 ms recompute · 2.7× · identical tokens
Vision for robots

Faster answers about the scene.

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.

Qwen2.5-VL-3B · first token 144 ms → 69 ms with a shared task prompt
KV-aware routing

Each request goes to the right GPU.

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.

Least-cache and least-busy strategies across pooled GPUs
Speech models

Open speech models, fast on one card.

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.

Text to speech53 msto first audio, Qwen3-TTS 1.7B (p50; p95 76 ms)Same model on the board: Nari Labs 63 / 91 ms · Baseten 104 / 132 ms
Speech to text42 msfrom end of speech to final transcript, Parakeet TDT 0.6B v3 on one H100 (p50; p95 62 ms)RTX A5000: 49 / 75 ms · same model on the board: Together 49 / 139 ms
Calls per card64concurrent Qwen3-TTS calls on one RTX A5000, release-qualifiedFish S1-mini 144 · Fish S2-Pro 40 (non-commercial weights) · card at $0.27/hr
Hindi76 msto final Hindi transcript, IndicConformer 600M (p50; p95 103 ms)WER 13.1 % vs Qwen3-ASR 14.7 %, Whisper large-v3 29.0 % · 60 FLEURS clips, client near the GPU
Text to speech · time to first audio, ms · RTX A5000
ModelOursOn the Coval board
Qwen3-TTS 1.7B53 / 76Nari 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 / 103Fish 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 / 195Fish 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.

Speech to text · end of speech to final transcript, ms · streaming
ModelOursOn the Coval board
Whisper large-v38-bit (w8a8) build with a distil-large-v3 draft modelH100 64 / 122A5000 103 / 206Baseten 112 / 248 · Together 108 / 232
Parakeet TDT 0.6B v3WER 5.9 % on our clipsH100 42 / 62A5000 49 / 75Together 49 / 139
Parakeet TDT 0.6B v2H100 36 / 52A5000 46 / 77Not 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.

Robot control

The whole control loop, measured live.

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.

Relay round trip7.7 msp99.9, robot → relay → responder → relay → robot (p50 4.6 ms)40 KB observation, 50 a second · a stand-in answers in place of the model · 20,000 round trips per run, 0 failures · our production relay in Mumbai, robot and stand-in in the same metro
Across cities64 msp99.9, robot and GPU host in Noida, over our relay in Mumbai (p50 46 ms)56 KB π0.5 observation (3 camera images + prompt) · a stand-in answers in place of the model · 20,000 round trips, 0 failures · robot and GPU host on separate machines
π0.5 control step82 msp99.9, camera frames in, action chunk out, π0.5 on one RTX PRO 6000, same Noida → Mumbai path (p50 71 ms)p50: model 26.6 ms · network 44.5 ms · 8-bit weights (W8A16) · 20,000 steps, 0 failures, none over 200 ms

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.

Against vLLM-Omni

First audio in 60 ms, not 6 seconds.

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.

Voxtral int8 vs vLLM-Omni 0.30.0 · 64 calls · CC BY-NC 4.0 model: non-commercial
Leading silence, removed

Audible in about 42 ms.

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.

Server-side, on the GPU host · not a Coval-method number · the speech itself is unchanged
Live partial transcripts

64 streams per card, text every half second.

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.

Partial every 0.4–0.5 s · partial lag p50 461 ms · 82 % GPU at 64 streams
Robot policies

π0.5 in about 27 ms.

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.

8-bit weights (W8A16) · model time, p50 26.6 ms, p99.9 26.8 ms over 20,000 chunks · passes the agreement gate against the reference model
Proof products

Utilities that prove the runtime.

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.

VPN

A VPN that keeps latency flat under load.

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.

Measured vs Quincy · RTT under load 0.51 ms vs 14.69 ms · 38% less CPU per GB at 4 cores
QuickDesk

Remote desktop on your own relay.

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.

Windows · macOS · Linux · Android
Tunnel

Public endpoints for private services.

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.

HTTP · TCP · UDP · self-host or cloud
Drop-in SDKs

Ship on the substrate in an afternoon.

Nine language SDKs, from the browser to embedded devices, plus a ROS 2 middleware binding for robots.

py

Python

Async client, drop-in for the realtime API. Packages are shared during your pilot.

ts

TypeScript

Browser + Node, with a helper for browser media over your transport.

++

C++ / Rust

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 →
Pricing

Start with a paid pilot.

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.

FAQ

Questions builders ask.

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.

Company

A deep-tech company, built in Mangaluru, Karnataka.

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.

Co-founderAshwin Kallaje

Designed and wrote the C++ runtime, the transport and the edge network. Leads the company and works directly with every pilot customer.

Co-founderSwasthik Padma

Leads go-to-market and product strategy. An interdisciplinary researcher, with a minor planet named after him.