---
title: Twilio makes Turn Detection available to everyone: your Conversation Relay voice agent can finally stop interrupting people who pause to think
url: https://hernandez.systems/en/articles/twilio-makes-turn-detection-available-to-everyone-your-conversation-relay-voice-agent-can-finally
lang: en
type: TechArticle
section: Bots
published: "2026-11-16T15:34:16+00:00"
modified: "2026-11-17T15:01:09+00:00"
publisher: Osky Networks
image: https://oskydj.sfo3.cdn.digitaloceanspaces.com/calamardo/whatsapp_bot/2026-11-16/e161-portada-c2600ecb.png
alternate_es: https://hernandez.systems/es/articulos/twilio-libera-turn-detection-para-todos-tu-agente-de-voz-en-conversation-relay-ya-puede-dejar
---

# Twilio makes Turn Detection available to everyone: your Conversation Relay voice agent can finally stop interrupting people who pause to think

> Twilio launched Turn Detection for Conversation Relay in general availability: its own model that tells a pause to think apart from the real end of a sentence. It's enabled with turnDetection="true", requires no WebSocket changes, and isn't suitable for PCI or HIPAA flows.

Twilio [announced on November 13](https://www.twilio.com/en-us/changelog/general-availability--smart-turn-detection-for-conversationrelay) the general availability of **Turn Detection** for Conversation Relay, its layer for connecting a language model to a phone call without fighting with the audio. It's a Twilio-built model that decides when the caller has really finished speaking, instead of waiting for a silence timer to run out. If you have a voice agent answering the phone at a restaurant, a doctor's office, or tech support, this is the setting that tackles its most visible flaw: **interrupting people mid-sentence**. And it turns on with a single attribute in your TwiML.

## The problem: silence can't tell if you're done

Anyone who has tried a voice agent knows the scene. You say "I'd like a table for…", you stop for half a second to count how many people are coming, and the bot is already asking "for how many people?". You keep talking, so does it, and the call turns into a badly refereed tennis match.

The [Twilio documentation](https://www.twilio.com/docs/voice/conversationrelay/turn-detection) explains where this comes from: by default, Conversation Relay lets the silence detected by the speech-to-text (STT) provider close the turn. And a silence threshold, Twilio says, can't tell someone who has finished from someone who is pausing to think or dropping filler words like "uh" or "um", so false interruptions show up. [Twilio's blog on interruptions](https://www.twilio.com/en-us/blog/insights/ai-voice-agent-interruption-handling) sums it up in three failures: a pause mid-thought looks like the end of a turn, a loud noise looks like speech, and background noise sometimes prevents full silence from ever happening.

Until now the knob you had was `speechTimeout`: raise it so the bot doesn't jump in early and accept that the conversation feels slow, or lower it and put up with the interruptions. A blanket that's too short either way.

## What Turn Detection does

According to the [official guide](https://www.twilio.com/docs/voice/conversationrelay/turn-detection), Turn Detection replaces that silence-based decision with a machine learning model built by Twilio that:

- **Evaluates the caller's audio, not the transcript**, in real time, to decide whether they've completed their turn or are pausing mid-sentence.
- **Runs inside Twilio's media stack**, alongside the STT. That's why it works with all the speech-to-text providers and models that Conversation Relay supports, with one exception (below).
- **Only changes when the turn ends.** It doesn't touch how Conversation Relay detects someone interrupting the agent while it's speaking; that remains in the hands of `interruptible` and `interruptSensitivity`.

When the model decides the turn is over, Conversation Relay sends the `prompt` message with `last: true` without waiting for the STT timer to expire. [The changelog](https://www.twilio.com/en-us/changelog/general-availability--smart-turn-detection-for-conversationrelay) pitches it as "semantics-aware": it distinguishes between someone who has finished and someone who stopped to think.

![Comparison: with a silence timer the agent interrupts during the pause; with Turn Detection it waits and responds at the real end of the sentence](https://oskydj.sfo3.cdn.digitaloceanspaces.com/calamardo/whatsapp_bot/2026-11-16/e161-diagrama-640e9b50.png)

## How to turn it on

It's a new attribute on the `<ConversationRelay>` noun. Its default value is `false`, so **nothing changes in your calls until you enable it** ([TwiML reference](https://www.twilio.com/docs/voice/twiml/connect/conversationrelay)):

```xml
<Response>
  <Connect>
    <ConversationRelay
      url="wss://tu-servidor/ws"
      turnDetection="true"
    />
  </Connect>
</Response>
```

According to Twilio, **you don't need to touch your WebSocket server**: you keep receiving the same `prompt` messages and treat `last: true` as the end of the turn, just like before. The only thing that changes is the moment that `last: true` arrives. Since it's configured call by call, you can try it on a single number or on a fraction of your calls before turning it on for all of them.

### Knowing where the turn stands

If your application wants more detail, for example to start warming up the LLM's response while the person is still talking, you can request the turn state inside the `prompt`:

```xml
<ConversationRelay
  url="wss://tu-servidor/ws"
  turnDetection="true"
  includeInPrompt="turn-state"
  partialPrompts="true"
/>
```

With that, each `prompt` carries a `turnState` field. The [WebSocket messages reference](https://www.twilio.com/docs/voice/conversationrelay/websocket-messages) defines three values:

| Value | What it means | When it arrives |
|---|---|---|
| `start` | The person started speaking | With `last: false`, only if `partialPrompts="true"` |
| `interim` | They're still talking; the transcript is partial | With `last: false`, only if `partialPrompts="true"` |
| `end` | They finished their turn | With `last: true` |

Heads up on one detail: the [changelog announcement](https://www.twilio.com/en-us/changelog/general-availability--smart-turn-detection-for-conversationrelay) talks about `includeInPrompt="turnState"` and `StartOfTurn`, `EagerEndOfTurn`, and `EndOfTurn` events. The technical documentation, on the other hand, asks for `includeInPrompt="turn-state"` (the **only supported value**, according to the TwiML reference) and uses `start`, `interim`, and `end`. My take: if you're going to write code, go by the documentation, which describes the WebSocket contract, and validate against a real call before tying your logic to a name. I haven't tested it; this comes from Twilio's official documentation.

## The two knobs for fine-tuning

The guide describes two attributes for adjusting the behavior ([Turn Detection](https://www.twilio.com/docs/voice/conversationrelay/turn-detection)):

- **`speechTimeout`**: the maximum silence allowed before closing the turn even if the model hasn't marked it as finished. It's your safety net. It ranges from 600 to 5,000 milliseconds and, if you don't set it, it uses 1,500.
- **`eotThreshold`**: the confidence the model needs to consider the turn finished. It accepts 0.5 to 0.9 and defaults to 0.8. Higher means more patient; lower means quicker to answer.

My practical take: start with the defaults and adjust `eotThreshold` for your case. A bot that takes order or tracking numbers, where people dictate in chunks with pauses (one of the examples Twilio gives), can handle a high threshold. A bot with short questions like "yes or no?" feels better answering quickly.

And don't confuse `speechTimeout` with total silence. Twilio's [best practices](https://www.twilio.com/docs/voice/conversationrelay/best-practices) make clear that this timer only starts when the person speaks: if they never say anything, Conversation Relay doesn't send any `prompt`. For someone who goes mute, your application has to keep its own timer and ask "are you still there?".

## What it doesn't do and where not to use it

- **It isn't PCI or HIPAA compliant.** The [documentation](https://www.twilio.com/docs/voice/conversationrelay/turn-detection) says so explicitly: Turn Detection is not PCI compliant or a HIPAA-eligible service, and it asks you not to use `turnDetection` in flows subject to those regulations. If your agent takes card data or health information, that flow sticks with the usual silence-based approach or another solution. This contrasts with Conversation Relay in general, which according to the [TwiML reference](https://www.twilio.com/docs/voice/twiml/connect/conversationrelay) can be HIPAA-eligible when properly configured.
- **Deepgram Flux does its own thing.** If you use `transcriptionProvider="Deepgram"` with `speechModel="flux"`, Conversation Relay skips Twilio's model and uses Flux's built-in turn detection, even if you have `turnDetection="true"`. You can still ask for `includeInPrompt="turn-state"`. [Twilio's blog](https://www.twilio.com/en-us/blog/insights/ai-voice-agent-interruption-handling) explains that Flux merges transcription and end-of-turn into a single model; the news today is that you no longer need to marry an STT provider to get semantic detection.
- **It goes through Twilio's AI terms.** Using it means accepting their predictive and generative AI features addendum, like the rest of Conversation Relay.
- **The announcement doesn't mention an additional cost.** [Twilio's US voice pricing page](https://www.twilio.com/en-us/voice/pricing/us) lists Conversation Relay at 0.07 dollars per minute and doesn't show a separate line for Turn Detection. Twilio also hasn't published metrics on how much it reduces interruptions; before bragging about improvements, measure your own.

## What changes for bot builders

For anyone with a voice agent built on Conversation Relay, this is about the cheapest thing you'll see this year: one attribute in the TwiML, zero changes to the WebSocket, and the chance to try it call by call. If you already had `speechTimeout` inflated to 2,000 or 3,000 milliseconds so the bot wouldn't step on anyone, now you can let the model decide and keep the timer only as a backup.

My take: end-of-turn detection is what separates a voice agent that feels like a person from one that feels like a bank's phone switchboard. Every provider is putting in its own semantic model (Deepgram with Flux, now Twilio with its own), and the fact that Twilio's works independently of the STT lets you choose speech recognition by language or price without losing the smart detection. For Spanish-language bots, where filler words and long pauses are a national sport, it's worth testing with real calls and not with the English demo.

What's still unknown: Twilio gave no accuracy or latency figures for the model, nor did it say how it behaves per language. You'll only find that out by measuring.

## Sources

- [Twilio Changelog: General Availability: Smart Turn Detection for Conversation Relay (November 13, 2026)](https://www.twilio.com/en-us/changelog/general-availability--smart-turn-detection-for-conversationrelay)
- [Twilio Docs: Turn detection for Conversation Relay](https://www.twilio.com/docs/voice/conversationrelay/turn-detection)
- [Twilio Docs: TwiML Voice &lt;ConversationRelay&gt;](https://www.twilio.com/docs/voice/twiml/connect/conversationrelay)
- [Twilio Docs: Conversation Relay WebSocket Messages](https://www.twilio.com/docs/voice/conversationrelay/websocket-messages)
- [Twilio Docs: Best practices for Conversation Relay](https://www.twilio.com/docs/voice/conversationrelay/best-practices)
- [Twilio Blog: How to handle real-time interruptions in your AI voice agent](https://www.twilio.com/en-us/blog/insights/ai-voice-agent-interruption-handling)
- [Twilio: Programmable Voice pricing in the United States](https://www.twilio.com/en-us/voice/pricing/us)
