# Voice AI Latency in 2027: Why Sub-Second Replies Matter and the 6 Checks That Get You There

> Voice AI latency in 2027: why sub-second replies matter, where the milliseconds go on a phone call, and 6 checks with a time budget and a 30-day pilot.

- Canonical: https://buffersoltech.com/blog/voice-ai-latency-2027
- Author: BufferSol Editorial Team
- Published: 2026-11-22 · Updated: 2026-11-22

## Key takeaways
- Voice AI latency is the gap between the caller's last word and the agent's first audio. Twilio, Vapi, SignalWire and AssemblyAI all define it that way, but they start and stop the clock in different places, so two published numbers are rarely comparable.
- Sub-second is a sensible target for a phone agent, not a law. SignalWire says 500 to 1,000 ms feels smooth and past about 2,000 ms conversations start to fail, and a 2025 conference paper says delays beyond two seconds begin to feel unnatural.
- On a phone call the line itself takes a large share of the budget. Webex puts roughly 500 ms of delay across the call path, and SignalWire says telephony adds 200 to 500 ms, so a web demo is faster than a real call.
- End-of-turn detection is usually the longest wait. Twilio calls it the long pole in the tent, and several platform defaults add silence on purpose, so audit every deliberate wait before you tune the model.
- Measure three numbers on the same recorded calls, report the median and the 95th percentile, and count talk-overs. A fast median with a long tail still feels broken.

Voice AI latency is the gap between the caller's last word and the first audio the caller hears from the agent. For a phone agent in 2027, a median near one second is a sound target, and anything past about two seconds starts to fail. This guide gives 6 checks, a copyable time budget and a 20-call test, with every source named and dated November 2026.

For the full build, read our [AI voice agents guide](/blog/ai-voice-agents-guide). To see where latency fits in a working agent, see [how to build an AI receptionist](/blog/ai-receptionist) and the [AI call center guide](/blog/ai-call-center).

## What is voice AI latency, and how do vendors define it?

It is the wait the caller experiences between finishing a sentence and hearing the reply start. [Vapi](https://docs.vapi.ai/assistants/model-intelligence/understanding-latency) says "Voice-to-voice latency is the gap between when a caller finishes speaking and when your assistant starts responding." [SignalWire](https://signalwire.com/blog/what-latency-means-voice-ai) gives the same idea in its own words, and [AssemblyAI](https://assemblyai.com/blog/low-latency-voice-ai) treats the whole turn as one end-to-end clock that covers transcription, reasoning, speech synthesis and network transit.

[Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) names it the mouth-to-ear turn gap and splits it into stages: speech-to-text, a language model and text-to-speech, chained in what it calls a cascaded architecture. [Vapi](https://docs.vapi.ai/assistants/model-intelligence/understanding-latency) lists five stages: transport, transcription, endpointing, model response and speech synthesis. The definitions agree. What they do not agree on is where the stopwatch starts and stops, which is why the next sections spend so long on measurement. Our [AI voice agents guide](/blog/ai-voice-agents-guide) covers the full pipeline, and our [AI agent architecture post](/blog/ai-agent-architecture) shows where the voice loop sits.

## Why do sub-second replies matter on a phone call?

Because people take turns very quickly, and a long pause reads as a problem. A 2025 conference paper from [Maslych and colleagues](https://arxiv.org/html/2507.22352) says "response times beyond two seconds begin to feel unnatural", citing Miller (1968), and notes that studies of turn-taking report sub-second latency on average. We did not open those original studies, so treat the paper as a summary of research, not as a measured figure.

Vendors say the same thing more bluntly. [SignalWire](https://signalwire.com/blog/what-latency-means-voice-ai) says "Latency between 500-1000ms keeps things smooth; beyond ~2000ms, conversations start to fail." [Webex](https://blog.webex.com/engineering/building-voice-ai-that-can-keep-up-with-real-conversations/) says humans naturally pause for only a few hundred milliseconds between speaking turns. Both are vendor statements, so read them as engineering opinion, not as a standard. The practical reading is simple: aim at one second, treat two seconds as a failure, and decide where inside that range your call type sits. Our [AI outbound calls guide](/blog/ai-outbound-calls) and [AI appointment setter post](/blog/ai-appointment-setter) show how call purpose changes what callers tolerate.

## What does a slow reply do to a business?

It increases interruptions, abandonment and escalations to a person, according to one vendor. [SignalWire](https://signalwire.com/blog/what-latency-means-voice-ai) says "Users abandon or interrupt voice sessions when responses lag", and that this raises abandonment and escalation rates and lowers containment, meaning calls the agent completes alone. The page gives no measured rates, so we do not repeat any.

[AssemblyAI](https://assemblyai.com/blog/low-latency-voice-ai) describes a compounding effect: past a second, callers repeat themselves, the overlapping speech degrades transcription, and the problem gets worse. That is a vendor's account of how failures cascade, not a controlled study. What you can do is count it on your own calls: how often does the caller speak again before the agent answers, and how often is the agent's first words talked over? Those two counts, which the test later in this guide records, turn a vague feeling into a number. See our [AI receptionist cost calculator](/tools/ai-receptionist-cost-calculator) for what a missed or abandoned call is worth in your own business.

## What does one extra second cost across a whole call?

More than one second, because it repeats on every turn. BufferSol calculation using [Twilio's](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) published figures: its launch target for mouth-to-ear delay is 1,115 ms and its upper limit is 1,400 ms, a gap of 285 ms per turn. Over a 12-turn call that is about 3.4 seconds of extra dead air. At the [SignalWire](https://signalwire.com/blog/what-latency-means-voice-ai) "fail" line of roughly 2,000 ms, the same 12-turn call carries about 24 seconds of silence in total.

Those are illustrations of arithmetic, not measurements of any real agent, and the turn count is an assumption. The point is that a delay you would shrug off once becomes a conversation that feels slow after a dozen turns. A caller who has waited that long is more likely to talk over the agent, and then the turn-taking logic has to cope with the overlap. Our [workflow exception handling post](/blog/workflow-exception-handling) covers what the agent should do when a turn goes wrong.

```infographic
{"type":"stats","title":"One call, three delays (BufferSol calculation on published figures, 12 turns assumed)","items":[{"value":"1,115 ms","label":"Twilio's launch target for mouth-to-ear delay per turn"},{"value":"1,400 ms","label":"Twilio's upper limit per turn, 285 ms more"},{"value":"3.4 s","label":"extra silence over 12 turns between those two"},{"value":"24 s","label":"total silence over 12 turns at 2,000 ms a turn"}],"source":"BufferSol calculation using Twilio's published targets (November 2025) and SignalWire's two-second line; the 12-turn call is an assumption"}
```

## What latency targets do the vendors publish?

They range from under 300 ms to about 1.4 seconds, depending on what is being timed. The table lists what each page says, with its date and what the number covers. Read the last column before comparing anything.

| Source | Number it gives | What it measures | Date on page |
|---|---|---|---|
| [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) | 1,115 ms target, 1,400 ms upper limit | Mouth-to-ear turn gap at launch | Published Nov 2025, modified Aug 2026 |
| [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) | 885 ms target, 1,100 ms upper limit | Platform turn gap, excluding the phone or internet leg | Same page |
| [SignalWire](https://signalwire.com/blog/what-latency-means-voice-ai) | 500 to 1,000 ms | End to end, "many voice-AI systems aim" | Published Nov 2025, modified Oct 2026 |
| [AssemblyAI](https://assemblyai.com/blog/low-latency-voice-ai) | About 300 ms; about one second | Speech-to-text layer; full conversational turn | Nov 2026 |
| [Deepgram](https://deepgram.com/blog/low-latency-voice-ai) | Under 300 ms | Its definition of low-latency voice AI, end to end | Apr 2026 |
| [Telnyx](https://telnyx.com/resources/low-latency-voice-ai) | Roughly 500 ms | "Ideal benchmark" between responses | Last modified Sep 2026 |
| [Webex](https://blog.webex.com/engineering/building-voice-ai-that-can-keep-up-with-real-conversations/) | Sub-second | Its own agent, caller stops to first audio, on telephony | Dec 2025, updated Mar 2026 |

The spread is real: [Deepgram](https://deepgram.com/blog/low-latency-voice-ai)'s under-300 ms and [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents)'s 1,115 ms are not rival claims about the same thing. We checked the dates on each page in November 2026. Our [voice agent software roundup](/blog/top-ai-call-center-software-2027) compares how vendors package these budgets.

## Why do published latency numbers disagree?

Because vendors time different events under different conditions. [Telnyx](https://telnyx.com/resources/low-latency-voice-ai) says "Published voice AI latency numbers can be misleading when providers measure different events or use different configurations", and lists geography, tool calls, language and prompt complexity. [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) says many vendor benchmarks only measure a platform's internal processing, "leaving out the variability of network transmission".

[SignalWire](https://signalwire.com/blog/what-latency-means-voice-ai) adds "Sub-100-ms numbers typically refer to one part of the pipeline" and "True end-to-end voice latency below 500ms is extremely rare in the real world." [Vapi](https://docs.vapi.ai/assistants/model-intelligence/understanding-latency) is candid that its numbers are taken on its servers and that "None of the fields include network time to or from the caller". Each of these is a fair statement from a vendor that sells a part of the stack. Put together, they tell you to ask one question of every number: what started the clock and what stopped it? Our [AI vendor security questionnaire post](/blog/ai-vendor-security-questionnaire) shows how to put such questions to a vendor in writing.

## Where does the time go in one voice AI turn?

It goes into transport, three models and the hops between them. [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) walks one turn: audio reaches the media edge in 40 ms, then buffering adds 30 ms and decoding 25 ms, then the pipeline spends 350 ms on speech-to-text, 375 ms on the model and 100 ms on text-to-speech, with about 10 ms for each hop between services, for roughly 1.1 seconds from mouth to ear. [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) calls these starting benchmarks, not best-in-class, "as of November 2025".

| Stage | Twilio target | Twilio upper limit | Share of the 1,115 ms target |
|---|---|---|---|
| Speech-to-text | 350 ms | 500 ms | About 31 percent |
| Model, time to first token | 375 ms | 750 ms | About 34 percent |
| Speech, time to first byte | 100 ms | 250 ms | About 9 percent |
| Everything else: transport, buffers, decoding, hops | Remainder | Remainder | About 26 percent |

BufferSol calculation from [Twilio's](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) published targets: the three models add up to 825 ms of the 1,115 ms, so 290 ms is plumbing. The three upper limits add up to 1,500 ms, more than the 1,400 ms upper limit for the whole turn, which means the stages cannot all be at their worst at once. Our [AI agent evaluation post](/blog/ai-agent-evaluation) shows how to score each stage separately.

## What does a copyable voice AI time budget look like?

It is one row per stage, with a target, a worst case and the first thing to cut. This is BufferSol's working budget for a phone agent, built on [Twilio's](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) starting benchmarks and adjusted by what [Webex](https://blog.webex.com/engineering/building-voice-ai-that-can-keep-up-with-real-conversations/) and [SignalWire](https://signalwire.com/blog/what-latency-means-voice-ai) say about the phone line. It is BufferSol view, not a standard, and your first step is to replace each row with your own measurement.

| Stage | Working target | First thing to cut | Source for the idea |
|---|---|---|---|
| Phone line and edge | Not yours; track it | Pick a carrier and region close to callers | [SignalWire](https://signalwire.com/blog/what-latency-means-voice-ai), [Webex](https://blog.webex.com/engineering/building-voice-ai-that-can-keep-up-with-real-conversations/) |
| End-of-turn wait | Under 500 ms of silence | Replace a fixed timer with a smart model | [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents), [LiveKit](https://docs.livekit.io/agents/build/turns/) |
| Speech-to-text finalisation | About 350 ms or less | Stream and use interim results | [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents), [Deepgram](https://developers.deepgram.com/docs/endpointing) |
| Model first token | About 375 ms or less | Use a fast conversational model, reason in the background | [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) |
| Speech first audio | About 100 to 150 ms | Stream the first chunk, pre-connect | [ElevenLabs](https://elevenlabs.io/docs/best-practices/latency-optimization), [Microsoft](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/how-to-lower-speech-synthesis-latency) |
| Deliberate waits | Zero you cannot explain | Audit every setting that adds delay on purpose | [Vapi](https://docs.vapi.ai/customization/voice-pipeline-configuration) |
| Service hops | Few, same region | Colocate speech, model and orchestration | [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) |

If your whole budget is 1,000 ms and the phone line takes a large share, the rows above cannot all hit their targets, which is the reason to start by measuring the line. See our [AI agent ROI calculator](/tools/ai-agent-roi-calculator) for the business side of the same trade-off.

## What changes in 2027 for voice AI latency?

Three things change: turn handling gets smarter, replies start earlier, and targets get set by call type. Each has a primary source. [Deepgram's docs](https://developers.deepgram.com/docs/flux/voice-agent-eager-eot) describe eager end-of-turn processing, which starts the model on a medium-confidence transcript and says it can "cut hundreds of milliseconds" from response time. [OpenAI's documentation](https://platform.openai.com/docs/guides/realtime-vad) describes a semantic mode that chunks audio when the model believes the words said show the caller has finished.

[LiveKit](https://docs.livekit.io/agents/build/turns/) describes dynamic endpointing that adapts the wait within a range from session pause statistics, in its Python library. [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) dates its own targets to November 2025 and calls them a starting point, so expect them to move. BufferSol view: by 2027 the single "300 ms" slogan fades, and buyers ask for a median and a tail by call type, measured on their own calls. Re-check any vendor figure in this guide before you sign a contract. See [how long it takes to set up an AI receptionist](/blog/how-long-to-set-up-an-ai-receptionist-2027) for the wider plan.

```infographic
{"type":"steps","title":"The six checks, in the order we run them","steps":[{"title":"Measure","text":"Three numbers on the same recorded calls, with the median and the 95th percentile."},{"title":"Count the phone line","text":"Put the telephone leg in the budget before you tune the models."},{"title":"Audit waits and turn detection","text":"Find every delay you set on purpose, then tune end-of-turn."},{"title":"Start early","text":"Begin the reply before the caller finishes, with a safe way to cancel."},{"title":"Stream the model","text":"Fast first token, reasoning off the live turn."},{"title":"Stream the voice and colocate","text":"First audio chunk quickly, services close together."}]}
```

## 1. Are you measuring what the caller actually hears?

Start with one definition and three numbers, taken from the same recorded calls. The caller's experience is the mouth-to-ear gap. [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) separates it from the platform turn gap, which leaves out the internet or phone leg, and its launch targets differ by 230 ms between the two (1,115 ms against 885 ms). [Vapi's](https://docs.vapi.ai/assistants/model-intelligence/understanding-latency) per-turn fields are measured on its servers, and its per-stage fields do not add up to the turn figure.

| Number | Clock starts | Clock stops | What it hides |
|---|---|---|---|
| STT-only | Caller's last voice activity | Final transcript returned | Turn wait, model, voice, network |
| Platform turn gap | Caller's last voice activity | Reply audio leaves the platform | Phone or internet leg, device playback |
| Mouth-to-ear | Caller's last word | Caller hears the first audio | Nothing, but needs a recording of both sides |

BufferSol method: record both channels, mark the end of the caller's last word and the start of the agent's first sound, and compute all three. [AssemblyAI](https://assemblyai.com/blog/low-latency-voice-ai) reports a final transcript 86 ms after the caller falls silent, on its own streaming model, which is a true STT-only number and a small part of the whole. A report that shows only that number is accurate and still tells you nothing about the call.

**Choose it first if** you are comparing two vendors. **Skip the full method if** you have one call a day, and use a stopwatch on a recording instead.

## 2. Does your budget include the phone line?

It must, because on a real call the line is outside your code. [Webex](https://blog.webex.com/engineering/building-voice-ai-that-can-keep-up-with-real-conversations/) says "roughly 500 ms of latency is introduced across the call path" on the public telephone network, "leaving only a few hundred milliseconds for turn detection, retrieval, reasoning and speech synthesis". [SignalWire](https://signalwire.com/blog/what-latency-means-voice-ai) says telephony paths add 200 to 500 ms from routing, carrier hops, jitter buffering and codecs.

The two vendors give different sizes for the same effect, so the honest reading is a range of 200 to 500 ms, varying by route. [Webex](https://blog.webex.com/engineering/building-voice-ai-that-can-keep-up-with-real-conversations/) also says "Delivering speed is easy in web demos", because browser connections avoid the PSTN's extra delay and encoding. That is why a demo that feels instant can feel sluggish on a number. [ITU-T G.114](https://www.itu.int/dms_pubrec/itu-t/rec/g/T-REC-G.114-200305-I!!SUM-HTM-E.htm) recommends that one-way delay not exceed 400 ms for general network planning, and warns that highly interactive tasks such as many voice calls can be affected by much lower delays. That standard covers the network, not the agent, so use it as a ceiling for the line only. See our [AI call center post](/blog/ai-call-center) for carrier and routing choices.

**Choose it first if** your pilot demo felt fast and your first live calls did not.

## 3. Is end-of-turn detection tuned, not just fast?

It is usually the longest single wait, and shortening it blindly makes the agent interrupt callers. [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) says "End-of-turn detection is usually the long pole in the tent because systems are tuned to avoid false positives", and that "Most defaults are set around 500ms". It also says pushing too hard backfires because a false endpoint makes the agent talk over the caller, which feels worse than a little extra latency.

Defaults differ by platform. [Pipecat](https://docs.pipecat.ai/guides/learn/speech-input) documents a 0.2-second stop value and uses a trained turn model by default. [Deepgram](https://developers.deepgram.com/docs/endpointing) says endpointing is on by default at 10 milliseconds of silence and can be set to a longer value. [OpenAI's](https://platform.openai.com/docs/guides/realtime-vad) example configuration uses 500 ms of silence and notes "With shorter values turns will be detected more quickly." Fixed timers are blunt, so use a model that listens to meaning, [as LiveKit recommends](https://docs.livekit.io/agents/build/turns/) for most agents.

[Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) adds a trap: "Smart endpointing reduces median latency, but can also cause abrupt jumps in tail latency." Look for a cluster of slow turns that line up with your silence timeout. See our [human-in-the-loop post](/blog/human-in-the-loop-ai-agents) for when a person should take the call instead.

## 4. Can the agent start a reply before the caller has finished?

Yes, with a safe way to cancel. [Deepgram's](https://developers.deepgram.com/docs/flux/voice-agent-eager-eot) eager end-of-turn feature sends a medium-confidence transcript to the model early. If the caller was not finished, a resume event tells you to cancel the draft. The docs list the costs plainly: "Expect more LLM calls and slightly more complexity." Lower eager thresholds trigger earlier but cause "more false starts".

[Webex](https://blog.webex.com/engineering/building-voice-ai-that-can-keep-up-with-real-conversations/) describes the same idea from the answer side: it generates the beginning of the final answer while the caller is still speaking, and never discards it, so the final answer continues from it. It reports a turn-detection step under 75 ms at the 99th percentile and first-segment speech of usually 10 to 20 ms thanks to cache hits, which are its own measurements.

[Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) says you can run endpointing more aggressively if you can abort gracefully: clear the outgoing audio buffer, abort the model stream, cancel open tool requests and clean up the conversation history. Build that abort path before you tighten any threshold. Our [AI agent development guide](/blog/ai-agent-development-guide) covers cancellation as a design rule.

## 5. Does the model reach its first token fast enough?

The number that matters is time to first token, not total generation time. [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) says synthesis can start when the first tokens come back, so the model's share of delay is set by that one figure, and gives 375 ms as a target and 750 ms as an upper limit. It says "Streaming is non-negotiable" for the model API, and warns that managed conversation history layers designed for chat often add delay in voice.

[Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) also says a small, fast conversational model usually carries the live dialogue while heavier reasoning runs elsewhere in the background. [Webex](https://blog.webex.com/engineering/building-voice-ai-that-can-keep-up-with-real-conversations/) warns of the trade-off: smaller models are fast but less accurate and weaker at following instructions, which is why it pre-generates an opening instead of shrinking the model. Benchmark the exact model, provider and API you will use, since public leaderboards are only a rough guide, as [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) says.

Tool calls sit outside these numbers. [Telnyx](https://telnyx.com/resources/low-latency-voice-ai) notes that an agent that looks up account data mid-call adds a round trip, and most marketing benchmarks leave tools out. See our [AI workflow automation vs RPA post](/blog/ai-workflow-automation-vs-rpa) for where such lookups belong.

## 6. Does speech start from the first chunk, close to the line?

It should, and the services should sit in one region. [ElevenLabs](https://elevenlabs.io/docs/best-practices/latency-optimization) says its real-time models have a median latency of about 100 ms, excluding network time and your application, and lists time to first byte by region from 100 to 150 ms in North America, Europe and South East Asia to 150 to 200 ms in South Asia and North East Asia. [Microsoft](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/how-to-lower-speech-synthesis-latency) says "Streaming is critical to lowering latency" and recommends pre-connecting and reusing the synthesizer to avoid connection set-up.

[Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) counts "at least ten network traversals" per reply: two voice legs and eight handoffs between services. It advises "keep your services close together and deploy them close to the customer". [Deepgram](https://deepgram.com/blog/low-latency-voice-ai) puts it as "Even perfect code cannot outrun geography." [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) also warns that co-hosting speech-to-text and text-to-speech on one machine can create tail spikes when interruptions line up. Our [AI voice agents service page](/services/ai-voice-agents) lists the stack we choose for each build.

**Choose it first if** callers are far from your servers.

## How do interruptions and barge-in change perceived latency?

They change it a lot, because a wrongly triggered interruption makes the agent stop mid-sentence and feel broken. [LiveKit](https://docs.livekit.io/agents/build/turns/) calls a voice-activity interruption with no real words a false positive and says by default the agent resumes speaking from where it left off. [Vapi](https://docs.vapi.ai/customization/voice-pipeline-configuration) exposes a back-off period that blocks assistant audio after an interruption, with a default of 1.0 seconds.

So two settings pull against each other. A quick stop makes the agent feel attentive, and a long back-off makes the next reply feel slow. [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) notes that false voice-activity triggers can cause turn collisions on shared hardware. Measure barge-in with its own counts: how often the agent stops for noise, and how long until it speaks again. Our [conversational IVR vs AI voice agent post](/blog/conversational-ivr-vs-ai-voice-agent-2027) shows how callers react to each style.

## What is a deliberate wait, and where does your platform hide them?

A deliberate wait is a delay a setting adds on purpose, and it is the cheapest latency to remove. [Vapi's](https://docs.vapi.ai/customization/voice-pipeline-configuration) documentation describes a final audio delay of 0.4 seconds by default, applied after the reply is generated and before the assistant speaks, with example transcription waits of 0.1 seconds after punctuation and 1.5 seconds when there is none.

[Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) says most fixed end-of-turn defaults sit around 500 ms, and [OpenAI's](https://platform.openai.com/docs/guides/realtime-vad) example shows 500 ms of silence. None of these is wrong. Each one is a decision someone made for a typical call, which may not be yours. BufferSol audit: list every wait in your stack (end-of-turn silence, final-audio delay, back-off, chunk waits in speech), write the value and the reason beside it, and delete any you cannot justify. Our [AI automation agency guide](/blog/ai-automation-agency-guide) explains how to ask a vendor for these settings.

| Wait | Where it hides | Question to ask |
|---|---|---|
| End-of-turn silence | Speech-to-text or turn settings | Fixed or model-based? What is the cap? |
| Final-audio delay | Platform assistant settings | Why is it on? Which call type needs it? |
| Back-off after interruption | Interruption settings | How long is the agent silent after a barge-in? |
| Chunk wait in speech | Text chunking before synthesis | How much text must arrive before audio starts? |

## Which latency target fits your call type?

Pick the target from the cost of an awkward pause on that call, not from a slogan. [Vapi](https://docs.vapi.ai/customization/voice-pipeline-configuration) suggests final-audio delays of 0.0 to 0.2 seconds for real-time interactions, 0.3 to 0.5 for standard conversations such as customer service, and 0.6 to 0.8 for healthcare and formal settings. That is one vendor's guidance on one setting, but the principle is useful: formal calls tolerate a more deliberate pace.

BufferSol view: a booking or order-status call, where callers want speed, should aim at one second or under. A medical or legal intake, where callers give long, careful answers, should favour not interrupting over speed. A sales callback sits between them. Write the target per call type, then test it. See [our AI receptionist guide for medical practices](/blog/ai-receptionist-for-medical-practices-2027) and the [AI receptionist for law firms](/blog/ai-receptionist-for-law-firms-2027) for the call types where careful pacing matters most.

## Does a faster reply always make a better call?

No. [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) says interrupting the caller "feels far worse than a little extra latency", which is the reason fixed defaults are padded. [Webex](https://blog.webex.com/engineering/building-voice-ai-that-can-keep-up-with-real-conversations/) says smaller models may be fast but are less accurate and weaker at following instructions, so customers would get answers sooner that are "noticeably less helpful, natural, and trustworthy".

Speed is one input to quality, not the goal. A reply that arrives in 700 ms and gets the date wrong is worse than one that arrives in 1,100 ms and is right. Score accuracy and latency together on the same calls, and set a pass mark for each. Our [AI agent evaluation post](/blog/ai-agent-evaluation) gives the scoring approach. The [AI voice agents guide](/blog/ai-voice-agents-guide) covers the quality side of a call.

## Is a speech-to-speech model faster than a cascaded pipeline?

Often it is designed to be, but we found no independent measurement to say by how much. [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) describes a speech-to-speech model as one that handles the whole exchange in a single latent space with "no intermediate representations". [Google's Live API](https://ai.google.dev/gemini-api/docs/live) says it enables low-latency, real-time voice interactions, and [Amazon's Nova Sonic](https://docs.aws.amazon.com/nova/latest/userguide/speech.html) says it provides real-time conversational interactions through bidirectional audio streaming.

[Microsoft's](https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/realtime-audio) realtime audio page also describes low-latency speech-in, speech-out interactions with configurable turn detection. None of these pages gives a comparable millisecond figure, and each describes its own product. BufferSol view: treat speech-to-speech as a candidate to benchmark on your calls, since it removes hops but also removes the chance to inspect the text between stages. Our [AI call center agent post](/blog/ai-call-center-agent-2027) compares architectures for the buyer.

## How do you hide a slow tool call without lying to the caller?

You tell the caller what is happening, briefly, and keep the line alive. [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) notes that delays from the model or tool endpoints are easier to mask with interstitial fillers than audio delays, because they deal only with text. [Telnyx](https://telnyx.com/resources/low-latency-voice-ai) says a tool call adds a round trip that most marketing benchmarks leave out.

A good filler is true and short: "One moment while I check that booking." A bad filler is a guess that the tool then contradicts. Set a cap, such as a spoken update if a lookup runs past about two seconds, and a fall-back, such as offering a call back or a person, if it runs past a limit you choose. Those numbers are BufferSol view, to be tuned on your own calls. Our [workflow exception handling post](/blog/workflow-exception-handling) covers what to do when a tool fails.

## How should you read a latency distribution, not an average?

By looking at the median and the tail separately, because callers remember the slow turns. [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) reports internal benchmarks for its ConversationRelay product of a 491 ms median and a 713 ms 95th percentile, using different models, and warns that a discrete jump in the tail can line up with an endpointing timeout. [Pipecat](https://docs.pipecat.ai/guides/learn/speech-input) notes that its built-in speech-to-text 99th-percentile figures were measured at a stop value of 0.2 seconds and should be re-run if you change it.

Report p50 and p95 for each of your three numbers, and plot the slowest turns against their cause. A fast median with a bad tail means the typical call is fine and one in twenty feels broken. That is what callers describe afterwards. Our [AI agent ROI calculator](/tools/ai-agent-roi-calculator) can price the abandoned calls those slow turns cause.

## How do you test voice AI latency in 20 calls?

Record 20 real or scripted calls on the real phone number, then compute the three numbers and two counts. This is BufferSol's test, built from the method above. It needs a recording of both channels and a few hours, not a lab.

1. Place 20 calls across at least three locations or carriers, at two times of day.
2. Script five question types: a short fact, a long answer, a number read-back, an interruption and a tool lookup.
3. Mark the caller's last word and the agent's first sound on each turn.
4. Compute STT-only, platform and mouth-to-ear for every turn.
5. Count talk-overs, where the agent speaks while the caller continues.
6. Count late replies, where the wait lines up with your silence timeout.
7. Report median and 95th percentile per number, per question type.
8. Change one setting, re-run the same calls and compare.

| Measure | BufferSol pass mark for a phone agent | Why this mark |
|---|---|---|
| Mouth-to-ear median | At or under about 1,100 ms | [Twilio's](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) launch target is 1,115 ms |
| Mouth-to-ear 95th percentile | Under 2,000 ms | [SignalWire](https://signalwire.com/blog/what-latency-means-voice-ai) says conversations start to fail around 2,000 ms |
| Talk-over turns | No more than 1 in 20 | BufferSol view, set from the interruption cost |
| Late turns near the timeout | None clustered | [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) warns of tail jumps at the timeout |

## What should the agent do when latency spikes during a call?

It should degrade gracefully: say something short, retry once, then offer a person. [Webex](https://blog.webex.com/engineering/building-voice-ai-that-can-keep-up-with-real-conversations/) describes hedging with parallel safety-net requests to guard against slow model responses, plus regional failover and coordinated retries. [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) says dedicated capacity can help tail latency during peak hours, most of all for the audio services.

Decide the ladder in advance and test it: a spoken filler after one extra second, a retry after a second, and a handoff to a person after a third, for example. Those thresholds are BufferSol view. Log every spike with its cause so you can see whether the fix is the model, the voice, the network or a tool. See our [human-in-the-loop AI agents post](/blog/human-in-the-loop-ai-agents) and the [AI call center agent post](/blog/ai-call-center-agent-2027) for handoff design.

## Which parts of latency can a builder control on a phone call?

Most of them, but not the line. The table sorts the stages by control, with the source for each. Use it to decide where engineering time goes.

| Stage | Control | Evidence |
|---|---|---|
| Phone network and carrier hops | Partial: choose carrier and region | [SignalWire](https://signalwire.com/blog/what-latency-means-voice-ai), [Webex](https://blog.webex.com/engineering/building-voice-ai-that-can-keep-up-with-real-conversations/) |
| End-of-turn wait | High | [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents), [Deepgram](https://developers.deepgram.com/docs/endpointing) |
| Transcription | Medium: streaming and vendor choice | [AssemblyAI](https://assemblyai.com/blog/low-latency-voice-ai) |
| Model first token | Medium: model and provider choice | [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) |
| Speech first audio | Medium: model, voice, region | [ElevenLabs](https://elevenlabs.io/docs/best-practices/latency-optimization) |
| Deliberate waits | High | [Vapi](https://docs.vapi.ai/customization/voice-pipeline-configuration) |
| Caller's device and mobile network | None | [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) |

[Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) calls last-mile congestion and packet loss among the uncontrollable factors. Spend your first week on the high-control rows.

## What do the top-ranking voice AI latency guides agree on?

They agree on the definition, the stage list and the idea of streaming. They differ on target numbers and measurement. We read five vendor guides and the vendors' own documentation in November 2026. Every page is written by a company that sells a part of the voice stack, so we treat their numbers as vendor-measured.

| Topic | Agreement | Where they differ |
|---|---|---|
| Definition | Caller stops to agent starts | Where the clock stops |
| Stages | Speech-to-text, model, speech | Whether turn detection and transport are counted |
| Method | Stream everything | Whether network time is included |
| Target | Sub-second feels natural | Under 300 ms to about 1.4 s |
| Phone line | Adds delay | 200 to 500 ms versus about 500 ms |

What none of the pages gives is a copyable budget, a three-number method on one recording, a list of deliberate waits or a pass mark per call type. That gap is what this guide fills, and it is also why we call every pass mark here BufferSol view. See our [AI voice agents guide](/blog/ai-voice-agents-guide) for the buyer-side checklist.

## Which latency claims should you treat as vendor-measured?

All of them, unless a standard or an independent study backs them. The table grades what we used. A vendor measurement is useful when the setup is stated, and weak when it is a single headline figure.

| Claim | Who made it | How strong |
|---|---|---|
| 491 ms median and 713 ms p95 on one product | [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) | Internal benchmark, models varied |
| 86 ms final transcript after speech stops | [AssemblyAI](https://assemblyai.com/blog/low-latency-voice-ai) | Vendor's own streaming model |
| Roughly 500 ms across the PSTN call path | [Webex](https://blog.webex.com/engineering/building-voice-ai-that-can-keep-up-with-real-conversations/) | Vendor engineering blog |
| About 100 ms median for real-time speech | [ElevenLabs](https://elevenlabs.io/docs/best-practices/latency-optimization) | Vendor docs, excludes network |
| Two seconds feels unnatural | [Maslych and colleagues](https://arxiv.org/html/2507.22352) | Paper citing Miller (1968), originals unopened |
| 400 ms one-way planning ceiling | [ITU-T](https://www.itu.int/dms_pubrec/itu-t/rec/g/T-REC-G.114-200305-I!!SUM-HTM-E.htm) | A standard, for networks only |

The one standard in the table is about the network, not about a voice agent. That is why the paper and the vendor statements carry the rest of the argument, and why you should run the 20-call test on your own calls before you trust any of them.

## What does Webex's published breakdown actually show?

It shows a list of stages, not a sum you can add up. [Webex](https://blog.webex.com/engineering/building-voice-ai-that-can-keep-up-with-real-conversations/) times the gap from the customer's last word to the first sound they hear, and lists: voice-activity end of speech about 500 ms, turn detection under 75 ms at the 99th percentile, the first part of the answer already generated and cached, first-segment speech usually 10 to 20 ms, and a PSTN return path of about 500 ms. It calls the result sub-second.

BufferSol calculation on those listed figures: 500 plus 75 plus 20 plus 500 is about 1,095 ms if every item is added in series, a little over one second. The page does not say why the total is sub-second, and the likeliest explanations are that some items overlap or that the clock starts later than the stage list implies. That is a reading, not a finding. The useful lesson is practical: when a vendor lists stages and a total, ask whether the stages add up, and which clock the total uses. See our [AI voice agents guide](/blog/ai-voice-agents-guide) for the questions to put to a vendor, and the [AI call center guide](/blog/ai-call-center) for how buyers compare them.

```infographic
{"type":"bar","title":"Where Twilio's launch target spends 1,115 ms (milliseconds)","unit":"ms","data":[{"label":"Speech-to-text","value":350},{"label":"Model first token","value":375},{"label":"Speech first byte","value":100},{"label":"Transport, buffers, hops","value":290}],"source":"Twilio, November 2025 targets; the 290 ms remainder is a BufferSol calculation (1,115 minus 825)"}
```

## Which five questions should you put to a voice vendor in writing?

Ask for the clock, the conditions, the tail, the waits and the abort path. Each question comes from a gap the sources above expose, and a vendor that cannot answer in writing has told you something.

1. **Where does your latency number start and stop?** [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) and [Vapi](https://docs.vapi.ai/assistants/model-intelligence/understanding-latency) both show the answer changes the figure.
2. **Under what conditions was it measured?** [Telnyx](https://telnyx.com/resources/low-latency-voice-ai) lists region, tool use, language and prompt length as the usual differences.
3. **What are the median and the 95th percentile?** [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) reports both for its own product.
4. **Which waits are on by default, and what do they cost?** See the [Vapi](https://docs.vapi.ai/customization/voice-pipeline-configuration) final-audio delay and the [Deepgram](https://developers.deepgram.com/docs/endpointing) endpointing setting.
5. **How does the agent cancel a reply when the caller was not finished?** [Deepgram](https://developers.deepgram.com/docs/flux/voice-agent-eager-eot) and [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) both describe the abort steps.

Put the answers in a table and compare vendors on the same call script. Our [AI vendor security questionnaire post](/blog/ai-vendor-security-questionnaire) and [AI automation agency pricing guide](/blog/ai-automation-agency-pricing) show how to structure written vendor questions.

## Can you keep the first words quick without a bigger model?

Yes, by separating what is said first from what is decided later. [Webex](https://blog.webex.com/engineering/building-voice-ai-that-can-keep-up-with-real-conversations/) pre-generates an opening segment so playback can start as soon as the turn ends, while a larger model keeps working. It says the early part must be safe and plausible, that it never discards it and that the final answer continues from it.

[Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents) describes a similar split, with a lightweight conversational model speaking and deeper reasoning running in the background. The risk is a promise the later reasoning cannot keep, such as "Yes, we can book that" before the calendar is checked. BufferSol rule: the first words acknowledge, they never commit. "Let me check that for you" is safe. Anything about price, availability or policy waits for the answer. Our [AI agent development guide](/blog/ai-agent-development-guide) and [single-agent vs multi-agent systems post](/blog/single-agent-vs-multi-agent-systems) cover how a fast speaker and a slower reasoner can work together.

## Which source backs which of the six checks?

Each check rests on named pages, and the table shows which ones, so you can open the original before you act. Where a row has a single vendor source, treat it as one vendor's view.

| Check | Main sources | What they support |
|---|---|---|
| 1. Measure what the caller hears | [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents), [Vapi](https://docs.vapi.ai/assistants/model-intelligence/understanding-latency), [Telnyx](https://telnyx.com/resources/low-latency-voice-ai) | Two clocks give two numbers; server numbers omit the network |
| 2. Count the phone line | [Webex](https://blog.webex.com/engineering/building-voice-ai-that-can-keep-up-with-real-conversations/), [SignalWire](https://signalwire.com/blog/what-latency-means-voice-ai), [ITU-T](https://www.itu.int/dms_pubrec/itu-t/rec/g/T-REC-G.114-200305-I!!SUM-HTM-E.htm) | The line adds 200 to 500 ms; a network planning ceiling of 400 ms one way |
| 3. Tune end-of-turn | [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents), [LiveKit](https://docs.livekit.io/agents/build/turns/), [Pipecat](https://docs.pipecat.ai/guides/learn/speech-input), [OpenAI](https://platform.openai.com/docs/guides/realtime-vad) | Fixed timers versus models that read meaning |
| 4. Start early | [Deepgram](https://developers.deepgram.com/docs/flux/voice-agent-eager-eot), [Webex](https://blog.webex.com/engineering/building-voice-ai-that-can-keep-up-with-real-conversations/) | Speculative replies and a pre-generated opening, with a cancel path |
| 5. Stream the model | [Twilio](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents), [Microsoft](https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/realtime-audio) | First-token budget; configurable turn detection in realtime audio |
| 6. Stream the voice | [ElevenLabs](https://elevenlabs.io/docs/best-practices/latency-optimization), [Microsoft](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/how-to-lower-speech-synthesis-latency), [AssemblyAI](https://assemblyai.com/blog/low-latency-voice-ai) | First-chunk speech, pre-connect, regional serving |

Two sources, the [Google Live API](https://ai.google.dev/gemini-api/docs/live) and [Amazon Nova Sonic](https://docs.aws.amazon.com/nova/latest/userguide/speech.html), appear only in the speech-to-speech section because neither page gives a comparable figure.

## Where should you read next for each part of the voice stack?

Each of these BufferSol guides goes deeper on one part, and they are written to be read in any order. Start with the one that matches your biggest gap.

| If your gap is | Read | What it covers |
|---|---|---|
| The whole voice build | [AI voice agents guide](/blog/ai-voice-agents-guide) | Pipeline, consent, handoff and measurement |
| Inbound answering | [AI receptionist guide](/blog/ai-receptionist) | Call types, booking and message-taking |
| Large call volumes | [AI call center guide](/blog/ai-call-center) | Containment, queues and escalation |
| Outbound calling | [AI outbound calls guide](/blog/ai-outbound-calls) | Callbacks, reminders and consent |
| Booking | [AI appointment setter post](/blog/ai-appointment-setter) | Qualifying and scheduling on a call |
| Legal rules for outbound | [TCPA and AI calls](/blog/tcpa-ai-calls) | US consent rules, not legal advice |
| Scoring an agent | [AI agent evaluation](/blog/ai-agent-evaluation) | Test sets and pass marks |
| Planning the timeline | [How long to build an AI agent](/blog/how-long-to-build-an-ai-agent) | What fits in 30 days |
| Pricing the calls | [AI agent pricing 2027 table](/research/ai-agent-pricing-2027) | Vendor prices as checked on their pages |
| Sizing the value | [AI receptionist cost calculator](/tools/ai-receptionist-cost-calculator) | Missed-call value from your own inputs |

## What are the limits of this guide?

It covers cascaded and speech-to-speech phone agents at a planning level, and it is not a benchmark. We did not test any vendor's product, and we did not measure any call. Every number comes from a page we opened in November 2026, dated in the text where it matters, and every pass mark that is not from a source is labelled BufferSol view.

We also did not find a published, independent comparison of end-to-end latency across vendors, so no ranking is given. Latency is one part of a good call: accuracy, consent rules and handoff matter as much. For [outbound calling](/blog/ai-outbound-calls), see our [TCPA guide for AI calls](/blog/tcpa-ai-calls), which is not legal advice. For the larger picture, read the [AI voice agents guide](/blog/ai-voice-agents-guide).

## How does BufferSol build for latency?

We build the voice loop around measurement first, then tune. The [AI voice lead agent case study](/portfolio/ai-voice-lead-agent) describes a voice agent that answers inbound calls, qualifies leads and books appointments into the CRM, with low-latency speech and interruption handling listed among its features, built on OpenAI Realtime and Twilio among other tools. It does not publish latency figures, so we do not quote any.

Our [AI voice agents service](/services/ai-voice-agents) covers AI receptionists, call center agents and [outbound calling](/blog/ai-outbound-calls) on your own phone line, calendar and CRM, with recordings, transcripts and a working agent on your real calls inside 30 days. For a fixed-scope version, see the Done For You [missed-call booking automation](/done-for-you/automations/missed-call-booking), built for trade businesses that lose calls when the office is busy.

## What does a 30-day pilot deliver for voice AI latency?

It delivers a working voice agent on your real calls and a measured latency baseline you can defend. BufferSol's 30-day pilot follows the same shape as our other [AI agent builds](/services/ai-agents): a prototype in about two weeks, then a live pilot on a first slice of calls, with a person watching.

| Week | Deliverable | Latency output |
|---|---|---|
| 1 | Call flows, phone number, stack choice | Your latency budget, one row per stage |
| 2 | Working prototype on your calendar and CRM | First three-number baseline from 20 calls |
| 3 | Live on a first slice of calls | Median and p95 by call type, talk-over count |
| 4 | Tuning and review | Waits audited, targets agreed, a go or no-go on widening |

What we need from you: a phone number or port plan, your call types, and two hours with the person who knows the calls. Success is measured by the pass marks above on your own calls, not by a vendor headline. See [how long it takes to build an AI agent](/blog/how-long-to-build-an-ai-agent) for the wider timeline.

## Is this right for you?

It is if you recognise most of these signs:

- Your voice agent sounds fast in a demo and slow on a real phone number.
- Callers repeat themselves or talk over the agent in the first few turns.
- Two vendors quote different latency numbers and you cannot compare them.
- You have never measured the tail, only an average or a vendor figure.
- Nobody can list the waits your platform adds on purpose.

If three or more apply, the Done For You [missed-call booking automation](/done-for-you/automations/missed-call-booking) is the nearest ready-made automation: it is a voice and text agent for HVAC, plumbing, electrical, roofing and remodeling companies whose office cannot pick up every ring, live in 3 to 6 weeks. Other call types start from a scoped build on the same pattern. Prices are quoted after a short call, never on the page. Our [AI receptionist cost calculator](/tools/ai-receptionist-cost-calculator) gives a first view of the value.

Updated November 2026: all vendor figures checked on the dates shown. Facts checked November 2026. Facts we did not re-check: the original studies behind the two-second and four-second figures in the 2025 conference paper (Miller, 1968, and the turn-taking studies it cites), the full text of ITU-T G.114 beyond its summary page, and any vendor latency number not opened on its own page. A claim that a delay causes callers to hang up more often was in a search summary only and is left out.

A scoped estimate for your voice agent's latency budget is the sensible next step: plan the 2027 budget now, and start the 30-day pilot in Q1 2027 so your first live calls are measured against pass marks you chose.

## Frequently asked questions
### What is a good voice AI latency?
For a phone voice agent, aim for a median of about one second from the caller's last word to the agent's first audio. SignalWire says 500 to 1,000 ms keeps things smooth, and Twilio's launch target for mouth-to-ear delay is 1,115 ms with an upper limit of 1,400 ms. Past roughly two seconds, callers repeat themselves or give up.

### Why is voice AI latency harder on a phone call than in a web demo?
A phone call adds the public telephone network. Webex says roughly 500 ms of latency is introduced across the PSTN call path, and SignalWire says telephony paths add 200 to 500 ms from routing, carrier hops, jitter buffering and codecs. A web demo skips most of that, which is why demo speed rarely survives into production.

### What is end-of-turn detection and why does it add delay?
End-of-turn detection decides that the caller has finished speaking so the agent can reply. Twilio says it is usually the long pole in the tent because systems are tuned to avoid false positives, since interrupting a caller feels worse than a short wait. Fixed silence timers often default to about 500 ms, and smart models can shorten that.

### How do you measure voice AI latency correctly?
Record real calls with both audio channels, then measure from the end of the caller's last word to the first audio the caller hears. Report the median and the 95th percentile, and note whether the clock includes the phone network. Vapi and Twilio both warn that server-side numbers leave out network time the caller experiences.

### Can a voice AI agent respond in under 500 milliseconds?
Rarely, over a real phone line. SignalWire says true end-to-end voice latency below 500 ms is extremely rare in the real world, and that sub-100 ms figures usually describe one part of the pipeline. Webex reports sub-second playback on telephony by pre-generating the opening of the answer while the caller is still speaking.

### What is the fastest way to cut voice AI latency?
Audit the waits you chose on purpose first: end-of-turn silence, any final-audio delay and interruption back-off. Then start the reply earlier with streaming and eager turn handling, keep speech, model and orchestration close together, and move heavy reasoning off the live turn. Measure each change on the same recorded calls so you know what helped.

### How long does it take to tune voice AI latency?
A first measured baseline takes days, because it only needs recorded calls and a stopwatch method. BufferSol's 30-day pilot puts a working voice agent on your real calls: a prototype in about two weeks, scored on the three latency numbers, then a live pilot on a first slice of calls with a person watching the tail.

## Sources
1. [A Guide to Core Latency in AI Voice Agents (Cascaded Edition)](https://www.twilio.com/en-us/blog/developers/best-practices/guide-core-latency-ai-voice-agents), Twilio
2. [How voice-to-voice latency works in voice agents](https://docs.vapi.ai/assistants/model-intelligence/understanding-latency), Vapi
3. [Voice pipeline configuration](https://docs.vapi.ai/customization/voice-pipeline-configuration), Vapi
4. [Mitigating Response Delays in Free-Form Conversations with LLM-powered Intelligent Virtual Agents](https://arxiv.org/html/2507.22352), arXiv (ACM CUI 2025)
5. [ITU-T Recommendation G.114: One-way transmission time](https://www.itu.int/dms_pubrec/itu-t/rec/g/T-REC-G.114-200305-I!!SUM-HTM-E.htm), ITU-T
6. [The 300ms rule: Why latency makes or breaks voice AI applications](https://assemblyai.com/blog/low-latency-voice-ai), AssemblyAI
7. [Building voice AI that can keep up with real conversations](https://blog.webex.com/engineering/building-voice-ai-that-can-keep-up-with-real-conversations/), Webex (Cisco)
8. [What Latency Means in Voice AI](https://signalwire.com/blog/what-latency-means-voice-ai), SignalWire
9. [What Is Voice AI Latency? Typical Numbers, Standards, and How to Measure It](https://telnyx.com/resources/low-latency-voice-ai), Telnyx
10. [Low latency voice AI: What it is and how to achieve it](https://deepgram.com/blog/low-latency-voice-ai), Deepgram
11. [Endpointing](https://developers.deepgram.com/docs/endpointing), Deepgram docs
12. [Optimize voice agent latency with Eager End of Turn](https://developers.deepgram.com/docs/flux/voice-agent-eager-eot), Deepgram docs
13. [Voice activity detection (VAD)](https://platform.openai.com/docs/guides/realtime-vad), OpenAI
14. [Turn detection and interruptions](https://docs.livekit.io/agents/build/turns/), LiveKit docs
15. [Speech input and turn detection](https://docs.pipecat.ai/guides/learn/speech-input), Pipecat docs
16. [Latency optimization](https://elevenlabs.io/docs/best-practices/latency-optimization), ElevenLabs docs
17. [How to lower speech synthesis latency using Speech SDK](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/how-to-lower-speech-synthesis-latency), Microsoft Learn
18. [Use the GPT Realtime API for speech and audio](https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/realtime-audio), Microsoft Learn
19. [Live API overview](https://ai.google.dev/gemini-api/docs/live), Google AI for Developers
20. [Amazon Nova Sonic](https://docs.aws.amazon.com/nova/latest/userguide/speech.html), Amazon Web Services