TIL: Flux natively knows when a caller finishes speaking

Flux turn detection replaces the guesswork of external voice activity detection with model-native EndOfTurn events. No silence timers, no separate VAD module, just a WebSocket config parameter that tells your voice agent exactly when the caller stopped speaking.

Deepgram’s Nova models work fine for straight transcription but they don’t know when someone has finished talking. You need a second system for that. Usually a voice activity detector paired with a silence timeout, plus custom code to smooth over the edge cases where the VAD fires early or the caller pauses to think.

I built enough of those adapters to know the pattern. They’re fiddly, they break in noisy environments, and they all need per-deployment tuning. Flux turn detection is baked into the model itself.

How to configure Flux turn detection?

You pass three optional parameters when opening the WebSocket to Deepgram’s /v2/listen endpoint:

• eot_threshold controls how confident the model needs to be before firing EndOfTurn. Default 0.7, range 0.5 to 0.9. Lower values respond faster but risk false ends. Higher values wait longer.
• eot_timeout_ms sets a max silence duration before the model forces an EndOfTurn. Default 1000 ms. Acts as a safety net when confidence alone isn’t enough.
• eager_eot_threshold enables the speculative pattern. When set, Flux emits EagerEndOfTurn early so you can start LLM inference before the speaker has definitely stopped. If they resume, TurnResumed tells you to cancel.

That’s it. Three values in the WebSocket query string. No separate VAD service, no silence-detection microservice, no per-environment calibration.

What do the Flux events look like?

The events arrive as structured messages over the same WebSocket. An EndOfTurn message includes the confirmed transcript, the channel index, and a confidence score. The turn_state field tells you what happened during that turn: StartOfTurn, Update, EagerEndOfTurn, TurnResumed, or EndOfTurn.

Here’s what an EndOfTurn event looks like:

{
  "type": "Results",
  "channel": {"alternatives": [{"transcript": "I want to book a flight", "confidence": 0.98}]},
  "turn_state": "EndOfTurn"
}

Your agent code switches on turn_state. StartOfTurn means someone started speaking (good for barge-in detection). EndOfTurn means the utterance is complete (send to the LLM). The transcript in EndOfTurn is the final, stable version. You don’t need to reconcile partials.

Does Flux turn detection work with the voice agent frameworks?

Pipecat and LiveKit Agents both have first-class support for Flux events. Pipecat maps EndOfTurn to UserStoppedSpeakingFrame and exposes event handlers like on_end_of_turn. LiveKit’s STT plugin for Deepgram routes Flux turn events into the agent’s state machine. If you’re using either framework, the Flux integration is a model string change, not a pipeline rewrite.

Why does model-native turn detection matter?

The external VAD approach has a fundamental problem. The VAD doesn’t know what the ASR is doing. It fires on audio level alone, which means it triggers on background noise, clears throat sounds, and the tail end of words the ASR hasn’t finished processing yet. Flux couples the two. The same model that transcribes the audio also decides when the turn ends. There’s no coordination gap.

The measurable difference shows up in false interruptions. Flux’s Coval benchmark showed around 30% fewer false barge-ins compared to a Nova-3 pipeline with external VAD. And the latency win compounds. Because EndOfTurn arrives with the final transcript already computed, the pipeline doesn’t waste time waiting for a separate VAD module to confirm silence.

FAQ

What is Flux turn detection? Flux turn detection is Deepgram’s model-native approach to knowing when a caller finishes speaking. Instead of using a separate voice activity detector plus silence timers, the Flux model emits structured EndOfTurn events over the WebSocket stream. The turn_state field tells your agent exactly what happened.

How do I enable Flux turn detection? Use the flux-general-en or flux-general-multi model on Deepgram’s /v2/listen WebSocket endpoint. The turn detection runs automatically. Tune it with eot_threshold, eager_eot_threshold, and eot_timeout_ms query parameters.

What’s the difference between EndOfTurn and EagerEndOfTurn? EndOfTurn is the confirmed signal that the speaker has stopped. EagerEndOfTurn is a speculative signal that lets you start LLM processing early. If the speaker continues, TurnResumed fires and you cancel the speculative work. The transcript in EndOfTurn is guaranteed to match the preceding EagerEndOfTurn unless a TurnResumed happened.

Is Flux turn detection better than external VAD? For voice agents, yes. Flux’s integrated approach eliminates the coordination gap between a separate VAD and the ASR model. Benchmarks show fewer false interruptions and lower end-to-end latency compared to external VAD pipelines.