Gradium’s $70M seed puts real-time AI voice where it belongs: on the latency problem

Gradium, a new Paris startup spun out of Kyutai, has raised a hefty $70 million seed round to build ultra-low-latency AI voice models. For a company founded in September 2025, that's an unusually large opening bet. It also says something useful about where voice AI is headed.

The founder is Neil Zeghidour, a Kyutai cofounder and former Google DeepMind researcher. The round is led by FirstMark Capital and Eurazeo, with backing from Xavier Niel, DST Global Partners, Eric Schmidt, and others.

The pitch is easy enough to summarize: multilingual AI voice, high accuracy, natural conversation. The harder part is the one that matters. Speed. Gradium is going after voice systems that can respond on something close to human conversational timing without falling apart on coherence or expression.

That matters because most voice agents still feel slow and mechanical. They pause too long, interrupt awkwardly, or drag the user into a stop-and-start rhythm. The gap between a speech interface and an actual conversation is, at this point, mostly a latency problem.

Why this round stands out

A $70 million seed is huge. In this case, it also tracks with the work involved. Low-latency voice is a systems problem as much as a model problem. It takes expensive inference infrastructure, audio data, model training, streaming pipelines, and a lot of tuning that never shows up in polished demos.

The market is already crowded. OpenAI, Anthropic, Meta, Mistral, ElevenLabs, and plenty of open-source projects are all pushing into voice. Gradium isn't walking into an empty category. It's going after a narrow and painful target that a lot of incumbents still haven't nailed: full-duplex, real-time conversation that keeps working under load.

That's a sensible place to compete.

Text models can survive a pause. Voice can't. If an agent takes half a second too long to answer, people feel it immediately. If it waits for the speaker to fully finish before it does anything, the exchange stiffens up. Human conversation is messy. People overlap, interrupt, acknowledge, hedge, restart. Voice AI has to survive that.

The technical bar is higher than most demos suggest

A decent voice demo can hide a lot. Production systems can't.

To feel responsive, the system has to process live audio, infer intent before the speaker is completely done, start planning a reply, and synthesize speech fast enough that the pause sounds natural. All of that has to fit inside a tight latency budget.

A rough target for something that feels conversational looks like this:

• capture + VAD: 20 to 60 ms
• ASR first partials: 50 to 120 ms
• NLU/response planning: 30 to 100 ms
• TTS onset: 40 to 80 ms
• network jitter: 20 to 60 ms

If you want the first spoken response to land under about 200 ms, every stage has to stream early and avoid blocking on the rest of the pipeline. That's hard. It usually rules out a simple "speech to text, text into LLM, text into TTS" chain where each component politely waits for the previous one to finish.

The whole thing has to be incremental.

That changes the design across the stack.

Streaming ASR needs stable partial transcripts, not just good final transcripts. Endpointing has to be sharp. Barge-in handling has to work, so the system can detect when a user interrupts and recover cleanly. TTS has to start from stable prefixes and still adapt mid-utterance if the model changes course. Full-duplex audio needs echo cancellation and sane fallbacks for bad browser audio behavior.

Plenty of voice companies talk about natural conversation. Fewer will show you their P95 time-to-first-syllable.

Where Gradium could differentiate

The interesting part of Gradium's pitch is the focus on audio language models, not another wrapper around existing speech APIs.

That points to a stack built for streaming from the start. Likely ingredients include:

• streaming ASR using transducer-style models, chunked attention, or similar low-latency approaches
• speculative decoding or early-exit heuristics in the language layer
• token-by-token or frame-synchronous speech generation
• multilingual acoustic modeling so each added language doesn't blow up complexity
• inference-level optimizations such as quantization, kernel fusion, CUDA graphs, and FlashAttention

This is infrastructure work. That's exactly why it matters.

The bottleneck in real-time voice is often orchestration, not raw model quality. Once you have thousands of concurrent sessions, GPU memory pressure, KV cache handling, batching strategy, and queue behavior start shaping the product as much as the model architecture does. Teams usually want large batches for LLM efficiency and tiny batches for low-latency TTS. Those incentives conflict. Someone has to decide which tail latencies matter most.

A company built around speed from day one has an edge over one trying to bolt voice onto a text-first inference stack.

Multilingual from day one is ambitious, and useful

Gradium says it's starting with English, French, German, Spanish, and Portuguese. That's a practical set, especially for customer support, sales, field operations, and European deployments.

But multilingual voice is never just a translation problem. It brings harder issues around pronunciation, code-switching, prosody, and accent handling. A model can post a strong word error rate and still sound off in ways users catch instantly. Coarticulation across languages, natural pauses, pitch movement, and local speech habits matter more than a lot of text-heavy teams expect.

There's also a business angle. If Gradium can keep latency low across several languages without maintaining a pile of separate models, serving economics improve. Shared phoneme or acoustic representations can help. So can on-the-fly language ID. The trade-off is obvious: multilingual compression can shave off language-specific nuance. Whether Gradium avoids that will matter.

What engineers should watch

If you're evaluating real-time voice platforms, don't stop at MOS scores or sample clips. Ask for operating numbers.

The useful ones are dull and revealing:

• P50, P95, and P99 time to first audio
• ASR partial stability
• barge-in recovery rate
• duplex behavior under packet loss and jitter
• concurrency limits per GPU
• latency impact of switching voices or languages
• regional deployment options and data retention defaults

For browser-based products, transport choices matter too. WebRTC is usually the right fit for interactive audio because it's built for low-latency streaming and ugly network conditions. gRPC or HTTP/2 can work well for server-side streaming, but browser voice UIs live or die on tail behavior, not average throughput.

And if you're plugging an LLM into a voice system, don't let the model chew on every turn like it's writing an essay. A lot of the better voice systems use a lighter planner that can commit to an opening phrase quickly while a larger model fills in the rest. That can be the difference between something that feels live and something that feels delayed.

Safety gets harder when the voice sounds good

As these systems improve, voice safety becomes a product design problem.

That means guardrails around cloning, similarity thresholds, consent workflows, and clear provenance. Watermarking and other inaudible markers are worth watching, though none of them are magic. If Gradium pushes into enterprise or regulated markets, customers will also want logging, audit trails, privacy controls, and region-specific processing for GDPR and EU AI Act compliance.

Being based in Paris and tied to Kyutai could help. European buyers tend to care about where inference runs and how data is handled. That won't decide the product on its own, but it's a real advantage if the company offers strong EU-hosted deployment and clear evaluation.

Voice is turning into a performance engineering problem

For the last year, a lot of AI product teams treated voice as an add-on. Get decent transcription, wire in an LLM, pipe text into a speech model, ship a demo. That phase is ending.

The next winners are likely to be the teams that treat voice as a latency-sensitive distributed system, with all the ugliness that comes with that. Scheduling. Queue design. AEC. Endpointing. Partial hypotheses. GPU memory tuning. Browser constraints. Fallback behavior. It's less glamorous than model benchmarks, but it's where product quality actually lives.

Gradium's seed round is a bet that this layer can support a standalone company. That seems right.

If the startup can deliver sub-200 ms, multilingual, expressive voice at production scale, a lot of current "AI agents" will look unfinished. If it can't, the market will keep teaching the same lesson: voice is easy to demo and hard to get right.