# Before You Buy a Faster Voice, Find Where Your Phone Agent's Pause Comes From

> A faster speech engine targets the smallest slice of a phone agent's pause. Measure real calls first; the end-of-turn wait and in-turn model work often have more room to shrink.

**Published:** November 18, 2026
**Author:** PSEEDR
**Category:** enterprise
**Content tier:** free
**Accessible for free:** true
**Editorial format:** analysis
**News quality eligible:** true
**Source count:** 14
**Word count:** 4732

**Read time:** 22 min  


**Canonical URL:** https://pseedr.com/enterprise/before-you-buy-a-faster-voice-find-where-your-phone-agents-pause-comes-from

![A telephone handset with an audio waveform that breaks into a silent gap, beside the words 'Faster Voice? Find the Pause'.](https://storage.googleapis.com/pseedr-content/assets/article-covers/before-you-buy-a-faster-voice-find-where-your-phone-agents-pause-comes-from.07da06bb.png)

---

*Vendors now pitch speech engines that start talking in under 100 milliseconds. On a phone call, that is one of four waits a caller hears, and in Twilio’s starting latency budget and one small measured trace it is the smallest. Measure real calls first: the end-of-turn wait and the work the model does inside the turn often have more room to shrink.*

<div class="section" aria-label="Companion video" style="margin:1.5rem 0 2rem">

## Watch the full analysis (16:01)

<div style="position:relative;width:100%;aspect-ratio:16/9">

<div class="iframe">

<div id="player">

</div>

<div class="player-unavailable">

# An error occurred.

<div class="submessage">

Unable to execute JavaScript.

</div>

</div>

</div>

</div>

[Watch the full analysis (16:01) on YouTube](https://www.youtube.com/watch?v=2ZRXV92RUvo) · [Watch the Short (0:57)](https://www.youtube.com/shorts/iRqWfc2vcpM)

Join the discussion: [LinkedIn](https://www.linkedin.com/feed/update/urn:li:share:7529030580307537920/) · [X](https://x.com/PSEEDR/status/2123264404078882958)

</div>

On November 3, 2026, the AWS Machine Learning Blog published a guide to [building ultra-low-latency voice AI applications on AWS](https://aws.amazon.com/blogs/machine-learning/building-ultra-low-latency-voice-ai-applications-on-aws/) with Cartesia, an AWS partner. Its headline numbers sit at the two ends of the speech pipeline. The post says Cartesia’s Sonic text-to-speech model delivers its “first audio byte in approximately 90ms”, and that Sonic and the Ink speech-to-text model are both “optimized for sub-100ms first-byte latency.” These are vendor figures. The post says the models run in production inside Amazon Connect, but it gives no independent measurement and no end-to-end figure for a phone call.

For a team running an AI agent on phone lines, an offer like this raises a practical question. When callers say the agent feels slow, should the speech engine be the part they replace?

Hrishi Amravatkar, founder and CEO of [Mighto AI](https://mighto.com), builds for callers who will not wait. Mighto runs outbound voice agents that phone local service vendors to collect and negotiate quotes for homeowners and property managers, “so our callers are busy contractors who hang up if the agent pauses too long,” he said in a written response to PSEEDR. Before Mighto, he said, he led “the team behind Amazon Alexa’s agentic workflows.” The lesson he brought over “is that callers judge a voice agent by the gap after they stop talking, not by how smart the answer is.”

That gap is made of several waits. The system has to decide that the caller has finished, the language model has to produce its first words, the speech engine has to produce its first sound, and the audio has to cross the network in both directions. In Twilio’s starting latency budget and in one small measured trace, speech generation is among the smallest and steadiest of these waits. The larger and more variable delays tend to come from the end-of-turn wait, the work the model does inside the turn, and the hosting decisions that set the network path. Which one dominates depends on the stack, so the first job is to find out where your own pause comes from.

## The pause callers actually hear

Latency figures are easy to compare and easy to mismatch, so start with the definition. Twilio’s [guide to core latency in AI voice agents](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents), published November 17, 2025, measures the **mouth-to-ear turn gap**. This gap “begins when the user stops speaking and ends when the agent’s reply reaches their ear.” It includes the audio’s trip across the phone network or the internet. A narrower **platform turn gap** counts only the time spent inside the agent platform. Twilio notes that many vendor benchmarks measure only internal processing. A component number, such as a speech engine’s time to first byte, is narrower still: it measures one stage on one side of the turn.

For a straightforward cascaded agent, Twilio’s launch targets are a median mouth-to-ear gap of 1,115 ms, with an upper limit of 1,400 ms. For the platform gap, the targets are 885 ms and 1,100 ms. Twilio calls these “starting benchmarks, not a statement of best-possible performance,” set as of November 2025. Twilio sells voice connectivity and a managed orchestration service for these agents, so these are a vendor’s planning numbers, not independent measurements.

People in conversation leave much shorter gaps. A 2009 study by [Stivers and colleagues in PNAS](https://pmc.ncbi.nlm.nih.gov/articles/PMC2705608) measured responses to yes-or-no questions in videotaped, informal conversations across 10 languages. It found “a general avoidance of overlapping talk and a minimization of silence between conversational turns.” The most common response gap was 0 ms and the mean across languages was about 208 ms, with each language’s average within about 250 ms of that mean. These were face-to-face conversations between people, not phone calls with an agent. The study shows how short human gaps are. It does not say at what delay a caller hangs up, and none of the sources reviewed for this article sets such a threshold.

The network alone can use up part of the margin. The ITU’s [G.114 recommendation](https://www.itu.int/rec/T-REC-G.114/index.html) on one-way transmission time (05/2003) sets a one-way delay of 400 ms as the ceiling for general network planning. It adds that “highly interactive tasks (e.g., many voice calls, interactive data applications, video conferencing) can be affected by much lower delays.”

Builders also describe how callers react to silence. Muh Mozamil, founder of [Ai Plexis](https://aiplexis.com), builds AI voice agents that answer calls for service businesses. In a written response to PSEEDR, he said that “waiting for full silence before responding adds a full second of dead air, which callers read as a bad connection.” That is his description of how callers behave, not a measured figure.

Human conversation runs on gaps of about 0.2 seconds. Twilio’s starting target for a phone agent is about 1.1 seconds. That leaves close to a second that a team can try to win back. The question is which part of it they can actually move.

## Four parts of one pause, and the one on sale is the smallest

A cascaded voice agent passes each turn through speech-to-text, a language model and text-to-speech. Seen from the caller’s side, the gap has four parts:

1.  **The end-of-turn wait.** This is the time from the caller’s last syllable to the system’s decision that the turn is over. Twilio counts it as part of the speech-to-text stage, where it says transcription and end-of-turn detection run roughly in parallel.
2.  **The model’s first token.** This is the time until the language model emits the first words of a reply, plus any tool calls the model has to make before it can answer.
3.  **The speech engine’s first audio.** This is the time until the text-to-speech engine produces the first byte of sound.
4.  **The network, in both directions.** PSEEDR’s reading of Twilio’s definition is that the network is crossed twice. The caller’s last syllable has to reach the agent before the wait can start, and the reply has to travel back before the caller hears it. Hops between services inside the platform add to this.

Twilio’s component targets give a sense of scale.

| Stage | Twilio median target | Twilio upper limit |
|----|----|----|
| Speech-to-text, including end-of-turn detection | 350 ms | 500 ms |
| Language model time to first token | 375 ms | 750 ms |
| Text-to-speech time to first byte | 100 ms | 250 ms |

An illustrative figure in the guide adds about 40 ms for audio to reach the media edge, 30 ms of buffering, 25 ms of decoding and about 10 ms for each hop between services.

One public trace gives measured numbers for a similar pipeline. In [a March 15, 2026 Hugging Face post](https://huggingface.co/blog/dvalle08/voice-agent-latency-playbook), Diego Fernando Valle Ortiz traced 36 turns across five sessions. His stack used Deepgram Nova 3 for speech recognition, Ministral 3B served through Ollama, Pocket TTS, and LiveKit Agents over WebRTC. For the 23 simple turns that made no tool calls, he reported these figures:

| Stage                              | Median (p50) | 95th percentile (p95) |
|------------------------------------|--------------|-----------------------|
| End-of-utterance delay             | 554 ms       | 858 ms                |
| Language model time to first token | 566 ms       | 2,246 ms              |
| Text-to-speech time to first byte  | 243 ms       | 296 ms                |
| Perceived latency                  | 1,392 ms     | 3,384 ms              |

This is a small sample from one stack. It ran over a WebRTC connection rather than a phone line, and his perceived-latency figure leaves out network transit. Here it serves as an example of how far medians and tails can differ, not as typical values.

In both breakdowns, speech generation is the smallest or the steadiest slice, and that limits what a faster voice can do. Against Twilio’s 100 ms target, an engine that met Cartesia’s claimed 90 ms would save about 10 ms. In the Hugging Face stack, swapping a 243 ms first byte for 90 ms would cut about 150 ms from a 1,392 ms median, if the vendor figure held under the same conditions. It would do nothing about the 2,246 ms tail in the model stage. These are PSEEDR’s calculations from the cited figures, not test results.

Twilio itself warns against choosing on this number alone. Its guide cautions that “a faster system can be subjectively worse and feel slower if the voice is less expressive,” and advises: “don’t chase the lowest number, pick the model that feels right, even if it costs a few extra milliseconds.”

This conclusion holds only if your own trace looks like these, and it might not. A self-hosted speech engine can run slower than its specification. The AWS post itself notes that “higher batch size improves GPU utilization but adds first-byte latency.” A provider in a distant region can also add delay. If your trace shows speech generation as a large slice, move it up the list.

Amravatkar sees the time split in a similar way. He said that “end-of-turn detection and the language model’s first token are the parts you control most; the phone network adds a floor you can’t engineer away, so we spend effort on the model hop and on not over-waiting for the caller to finish.”

## Waiting for the caller to finish is a setting, not a law

Twilio’s guide names the part that is usually largest: “End-of-turn detection is usually the long pole in the tent because systems are tuned to avoid false positives.” The reason is an asymmetry in the cost of mistakes. If the system takes a natural pause for the end of a turn, the agent interrupts the caller, which Twilio says “feels far worse than a little extra latency.” So end-of-turn settings include padding. That padding becomes dead air on every turn, including turns where the caller had obviously finished.

The simplest detectors cannot tell a pause from an ending. A voice activity detector “only picks up on when someone is speaking,” LiveKit wrote in [a December 2024 post](https://livekit.com/blog/using-a-transformer-to-improve-end-of-turn-detection). The post gives an example: if someone says “I understand your point, but…”, a silence-based detector “would call this an end of turn, but a human would most likely keep listening.” Twilio says most fixed silence thresholds default to about 500 ms, and that lowering them is risky for this reason.

What matters for a team is that someone chose this wait, and someone can change it. Defaults vary widely across products:

- LiveKit Agents’ [turn handling options](https://docs.livekit.io/reference/agents/turn-handling-options/) set a default minimum endpointing delay of 0.5 s and a maximum of 3.0 s, in fixed mode. With LiveKit’s audio turn detector, values left unset default to 0.3 s and 2.5 s.
- Deepgram’s [streaming endpointing](https://developers.deepgram.com/docs/endpointing) is on by default at 10 ms of silence and accepts other values, such as 300 or 500 ms.
- Delays can stack. In LiveKit’s STT mode, the minimum delay is applied “after the STT end-of-speech signal, and therefore in addition to the STT provider’s endpointing delay.” A team that uses a provider’s endpointing and also keeps a framework default can pay for both without noticing.

In the Hugging Face trace, the measured end-of-utterance delay sat near the 0.5-second default endpointing delay. The author read this as confirmation that turn detection was working as configured. In that trace, the end-of-turn wait was mostly just the configured value.

Newer detectors replace the fixed timer with a model that reads the transcript or the audio. LiveKit’s end-of-utterance model is a 135M-parameter transformer based on SmolLM v2. LiveKit uses its predictions “to dynamically shorten or extend the VAD silence timeout.” LiveKit reported that, compared with voice activity detection alone, the model cut unintentional interruptions by 85%. It wrongly judged a turn unfinished 3% of the time, and inference took about 50 ms. These are LiveKit’s own 2024 figures for an English-only model. The framework now defaults to a newer audio turn detector. The AWS post makes a similar claim for Cartesia’s Ink, which it says uses “semantic understanding to distinguish between mid-sentence pauses and true conversation boundaries.”

Smarter detection fails in its own way. Twilio notes that when the model wrongly believes the caller is still speaking, the agent waits until the silence timeout fires. This can happen with inaccurate transcripts, degraded call quality, accents or unusual speaking patterns. The guide gives a diagnostic worth keeping: “A common sign of suboptimal smart endpointing is a discrete jump in the tail of your latency distribution that is roughly aligned with your endpointing silence timeout.”

Mozamil’s account describes this trade-off in practice. “The biggest win for us was streaming speech recognition with fast turn detection,” he said. His team kept barge-in on so that a caller can interrupt the agent, “and we tuned the silence threshold per line quality rather than using one default.” He named the cost: “a threshold that is too eager cuts people off mid-sentence, so we test on real calls, not in a quiet room.” His response gave no date, no threshold values and no cut-off rate. It describes a practice and is not evidence of a measured improvement. It does match how the documentation says these systems behave. Phone audio is noisier than a quiet test room. One example in LiveKit’s [turns documentation](https://docs.livekit.io/agents/logic/turns/) uses a realtime model’s server-side detection with a higher voice activity threshold, 0.7, “for noisy phone audio” and a 400 ms silence window.

Barge-in matters because it makes a wrong guess cheaper. Twilio’s guide says endpointing can be set more aggressively if the system can abort gracefully. That means clearing the outgoing audio buffer, aborting the language model stream, cancelling open tool requests and cleaning up the conversation history. On a Twilio Media Streams connection, the [`clear` message](https://www.twilio.com/docs/voice/media-streams/websocket-messages) “empties all buffered audio.” That message is what lets an agent stop talking when the caller starts again.

Frameworks already support tuning by line. In LiveKit, a running session can change its endpointing values, and the change applies from the next turn. A dynamic mode, available only in Python, adapts the delay within the configured range based on the session’s pause statistics. The tools exist. What the documents do not say is which signals should set the value for a given line.

## Give the live model less to do

The model’s share of the pause behaves differently. In the Hugging Face trace, the median time to first token for simple turns was 566 ms, close to the median end-of-turn wait. The 95th percentile was not close: 2,246 ms. Turns that needed a tool were slower still. Deciding to call a tool took 913 ms at the median and 4,428 ms at the 95th percentile. The first tool execution took 208 ms at the median and 2,359 ms at the 95th percentile. The author links part of this to context size. The first model pass carries the whole conversation plus the tool definitions, and time to first token tended to rise as conversations grew longer. Two traces from deep in multi-turn conversations reached 2.4 s and 6.8 s.

This pattern points at how much work the model does inside the turn, not only at how fast the model is. Amravatkar’s October change targeted that work. He said that “in October 2026 we took DeepSeek out of the live call path and moved the tasks it handled onto Gemini Flash, while keeping Twilio for the phone leg.” He added: “We kept the reasoning-heavy work (comparing quotes, deciding the next negotiation move) outside the real-time turn, so the in-call model only has to produce a short, natural reply.”

The outcome is not yet known. Mighto has not launched; a private beta in San Francisco is planned for January 2027. Amravatkar said the change “was tested on internal test calls rather than live production traffic, and I don’t have measured latency figures to share yet.” The team also swapped the model and narrowed its job at the same time, so even a later measurement could not show which change made the difference. His case is a design decision with a stated reason. It does not show that narrowing the model’s job works better than switching models. Amravatkar disclosed that Mighto takes part in startup credit programs from Google for Startups, AWS, Microsoft for Startups, NVIDIA Inception, ElevenLabs, Cartesia and Sarvam. Gemini Flash is a Google model, and AWS and Cartesia are the companies behind the November 3 post.

Twilio’s guide recommends the same architecture. “Real-time dialogue is typically driven by a lightweight conversational model optimized for latency, emotional intelligence, and speaking style,” it says. “Deeper or more computationally intensive reasoning is usually handled asynchronously by background systems.” The guide adds two cautions for any in-call model. First, benchmark time to first token on the exact provider and API you will use. Second, be careful with “managed conversation history” layers built for chat, which “often introduce delays and rigidities” in a voice context.

The two fixes act in different places. In PSEEDR’s reading, a faster model shortens every turn somewhat, but a turn that carries a quote comparison, a negotiation decision or a tool call still carries that work. Moving the work out of the turn removes the cause of the slow turns from the part of the call the caller hears. This depends on a condition, which is also PSEEDR’s inference and which none of the sources tested. The background reasoning has to finish before the agent needs the result. If it does not, the stall does not disappear; it moves to a later turn. The in-call model also needs enough context to stay coherent while the heavier work runs somewhere else.

A third option overlaps the model’s work with the end of the caller’s turn, instead of shrinking the work. LiveKit’s preemptive generation lets the agent “begin generating a response before the user’s end of turn is confirmed.” By default, only the language model runs early. Speech generation waits until the turn is confirmed unless `preemptive_tts` is turned on. The AWS post claims something similar for Ink’s partial transcripts, which it says let a downstream model “begin forming its response before the turn ends.” The Hugging Face post names the cost: compute spent on generations that are thrown away when the caller keeps talking.

## The network floor, and the hosting choices that raise it

Amravatkar calls the phone network “a floor you can’t engineer away.” Twilio’s guide explains where that floor comes from. A cascaded agent needs at least ten network traversals for each response: two voice legs over the public network and eight handoffs between services. “The public leg is the slowest and least reliable part of this path,” the guide says. Twilio advises customers to colocate at a Twilio Edge Location or to connect privately through Twilio Interconnect. It also tells teams to place the media services first. The orchestration server, speech-to-text and text-to-speech should sit close together. Delays from the language model, it says, are “easier to mask with interstitial fillers and are generally less volatile since they only deal with text.” The AWS post gives similar advice for self-hosted Cartesia models: use cluster placement groups, keep replicas in a single Availability Zone, and use private connections “to avoid public-internet hops.”

Carlos Correa, chief operating officer of [Ringy](https://www.ringy.com), argued in a written response to PSEEDR that teams neglect this layer. “Voice AI developers often try to optimize their choice of language model, or their choice of speech synthesis TTS and voice selection, but don’t consider network transport at all,” he said. In his account, “getting the network layer right with UDP introduces the largest single factor for latency improvements.” He also said the telephony stack and network round-trip optimizations “are what ultimately reduce total latency to the sub-0.5-second range.” His response did not describe a dated change, a specific deployment or a measurement, so these statements are his claims. Ringy’s public website presents a communications-focused sales CRM with a power dialer and a VoIP softphone. PSEEDR did not see an AI voice agent product there.

The mechanism behind his transport claim is documented. LiveKit explains in [a March 2026 post](https://livekit.com/blog/why-webrtc-beats-websockets-for-voice-ai-agents) that when a packet is lost, “TCP pauses the stream and retransmits it before delivering anything that came after.” Audio that arrived intact waits in a buffer, so the listener hears silence and then a burst of sound. WebRTC carries media over RTP and UDP, and “when a packet is lost, the stream keeps flowing.” Pipecat’s [transport documentation](https://docs.pipecat.ai/guides/learn/transports) lists the same weakness for WebSockets: “TCP-based: Subject to head-of-line blocking.” LiveKit sells WebRTC infrastructure, and its post does not say how often such stalls happen.

The same Pipecat page shows the limit of this advice for phone agents. It recommends WebRTC for client-facing web and mobile apps and WebSocket for “integrating with telephony providers (Twilio, Telnyx, etc.).” On a Twilio Media Streams connection, audio travels over a WebSocket in both directions as base64-encoded mu-law at 8,000 Hz, and outbound audio is “buffered and played in the order received.” An agent that connects to the phone network this way gets the WebSocket as part of the integration. Moving that leg to UDP would need a different integration path, which this article did not examine. On that kind of stack, the remaining levers are where the agent’s services run, how far they sit from the provider’s edge, and how connections are set up.

So a team does not have to pick between the two views. Twilio, whose voice network and orchestration services many phone agents run on, says end-of-turn detection is usually the long pole. Correa says transport is the largest factor. PSEEDR’s reading of the sources is that transport is a floor that every turn crosses twice. It grows large under specific conditions: when services run far from the provider’s edge or from each other, or when packet loss stalls a TCP stream. Those conditions are worth checking. They do not show that transport is the largest slice for most teams.

Correa also pointed to a smaller cost that is easy to miss: “calling out to an external speech synthesis provider will cause perhaps five internal DNS queries within the cluster, adding additional time before the first word can be said.” The mechanism comes from standard configuration. By default, a Kubernetes pod’s [`/etc/resolv.conf`](https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/) lists three cluster search domains and sets `options ndots:5`. The [resolv.conf(5) manual page](https://man7.org/linux/man-pages/man5/resolv.conf.5.html) says that a name with fewer dots than `ndots` “will be attempted using each component of the search path in turn until a match is found,” before the resolver tries it as an absolute name. An external provider’s hostname usually has fewer than five dots, so the resolver can try it against the cluster’s search domains first. The manual warns that this “may be slow and will generate a lot of network traffic” when the servers for those domains are not local. The exact number of queries depends on the search list, on whether both IPv4 and IPv6 records are requested, and on caching. “Perhaps five” is his estimate. It fits the mechanism, but PSEEDR did not verify it. Kubernetes lets a pod set its own `ndots` value through `dnsConfig`. The cost arises when a name has to be resolved for a new connection. PSEEDR infers that reusing persistent connections, which Twilio’s guide also recommends, limits how often a call pays it. Where it does show up, the first turn or the first turn after a reconnect is the most likely place.

## What to change first

Start with measurement, and use the right definition. Measure the mouth-to-ear gap on real phone calls, not only the platform gap. Split it by stage on the same calls: end-of-turn wait, model time to first token, speech first byte and network transit. Look at both the median and the 95th percentile. The Hugging Face trace shows that a stage that looks fine at the median can dominate the tail. Then match the pattern you see to its likely cause.

| What the calls or traces show | Most likely part | First change to try | Watch for |
|----|----|----|----|
| A steady pause after the caller finishes, even before short replies | End-of-turn wait | Find which layer decides the end of the turn and remove stacked delays; try a semantic or dynamic detector; tune by line or audio condition; keep barge-in on | Callers cut off mid-sentence; test on real phone audio |
| A jump in the tail close to your endpointing silence timeout | A smart detector waiting for speech that is not coming | Check the transcripts and audio quality on those turns; review the timeout | Noisy lines, accents and unusual speaking patterns |
| Most turns fine, but some stall for seconds, especially turns that need a decision or a tool | Model time to first token and tool calls inside the turn | Keep the in-call model’s job to a short reply; move comparison and decision work outside the turn; start generation before the turn ends | Background work that finishes too late; lost context; wasted compute |
| Silence followed by bursts of audio, worse on some networks | Transport stalls after packet loss | Check the transport path; use WebRTC over UDP where the integration allows it | Twilio Media Streams uses a WebSocket by design |
| The first turn, or the first call to a provider, slower than later ones | Connection setup, including DNS lookups | Reuse persistent connections; check the pod’s DNS search path and `ndots` | The exact cost depends on configuration |
| Every turn slower by about the same amount | Distance between the provider’s edge, the orchestrator and the model and speech services | Colocate services near the provider’s edge and near each other | Twilio warns that replacing providers after colocation is expensive, so plan regions early |
| Speech first byte already around 100 to 250 ms | Speech generation | Leave it until the trace says otherwise | Vendor speed figures are vendor claims |

## Where the pause comes from

In the breakdowns reviewed here, a faster voice is the wrong first purchase. Speech generation was the smallest slice in Twilio’s starting budget and both the smallest and the steadiest stage in the one measured trace, so a faster engine has the least room to help. The end-of-turn wait is often just a configured value, sometimes stacked across two layers, and teams can shorten it once barge-in and graceful aborts make a wrong guess cheap. The model’s cost shows up mostly in the tail, in turns that carry decisions or tool calls. That is the argument for keeping the in-call model’s job small, as Amravatkar has done at Mighto, although his result is not yet measured. The network sets a floor, and hosting decisions keep that floor low or raise it. On a phone leg connected through Twilio Media Streams, the integration fixes the transport protocol, so service placement and connection setup are the levers left.

The order of work follows from this, on one condition: your own trace has to look like these. First, measure on real calls. Fix the end-of-turn wait if the pause is steady. Move decision work out of the turn if the tail is slow. Check hosting, transport and DNS if the delay is constant across stages or worst on the first turn. Leave the speech engine until last unless your trace says otherwise.

One question remains open, and only teams with real-call data can answer it. Mozamil tunes the silence threshold for each line’s quality, and frameworks now let that value change during a call. Which signals you can observe on a line, such as noise, the carrier or the caller’s speaking rate, predict the right end-of-turn wait for it? And how many false cut-offs are acceptable on real phone audio?

*The contributors’ accounts in this article come from written responses to PSEEDR. Each latency figure is attributed to its source. PSEEDR did not measure any of the systems described.*

---

## Sources

- https://aws.amazon.com/blogs/machine-learning/building-ultra-low-latency-voice-ai-applications-on-aws/
- https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents
- https://pmc.ncbi.nlm.nih.gov/articles/PMC2705608
- https://www.itu.int/rec/T-REC-G.114/index.html
- https://huggingface.co/blog/dvalle08/voice-agent-latency-playbook
- https://livekit.com/blog/using-a-transformer-to-improve-end-of-turn-detection
- https://docs.livekit.io/reference/agents/turn-handling-options/
- https://developers.deepgram.com/docs/endpointing
- https://docs.livekit.io/agents/logic/turns/
- https://www.twilio.com/docs/voice/media-streams/websocket-messages
- https://livekit.com/blog/why-webrtc-beats-websockets-for-voice-ai-agents
- https://docs.pipecat.ai/guides/learn/transports
- https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/
- https://man7.org/linux/man-pages/man5/resolv.conf.5.html
