VAD is not turn detection

TL;DR: Voice activity detection estimates whether audio contains speech; turn detection decides whether the caller has yielded the conversation. Evaluate them separately with labeled pauses, background speech, and interruption fixtures, then choose a policy that balances premature replies against waiting time.

A caller says they need to check a document, pauses, and starts speaking again just as the agent begins its answer. The speech detector may have behaved exactly as designed while the conversation policy made the wrong decision.

That distinction determines what you fix. Raising an acoustic threshold changes which sounds count as speech; extending an endpoint timeout changes how long silence lasts before the system proceeds, and neither operation proves that the user finished their thought.

This guide develops an evaluation method for that boundary. It connects speech-to-playback latency measurement with task completion, rather than treating a shorter silence timeout as an unconditional improvement.

Reviewed November 9, 2026. Public documentation supplies the technical contracts; all worked scenarios and proposed test budgets below are illustrative, and no comparative benchmark or customer-call result is claimed.

Table of contents

1. Separate the questions
2. Build a policy around evidence
3. Label a corpus that exposes mistakes
4. Measure errors and waiting together
5. Run a controlled endpointing experiment
6. Handle interruptions and background speech
7. Implement safe transitions
8. Ship and monitor the policy
9. Frequently asked questions
10. Choose the next experiment

Separate the questions

A speech boundary is an acoustic observation; a turn boundary is a conversational decision. A useful implementation preserves that separation even when a provider exposes both through one event stream.

Voice activity detection, usually shortened to VAD, assigns speech or non-speech labels to audio windows. The output may be a probability, a binary label, or start and stop events produced after smoothing several windows.

Turn detection uses those observations to decide when an agent can speak. It can also use recognized words, prosody, task state, and explicit signals such as a push-to-talk release, but those inputs still leave uncertainty about whether the caller intends to continue.

A pause after a complete answer and a pause while searching for a reference number can sound similar. The desired behavior depends on the question the agent asked and the cost of acting before the caller finishes.

The distinction appears in public tools. OpenAI's VAD guide describes silence-based server_vad and a semantic_vad mode that considers whether an utterance is complete; these are documented product behaviors, not evidence that one setting wins for your callers.

Keep the provider's terminology attached to its interface. Calling a semantic end-of-turn classifier "VAD" in an API does not make acoustic speech classification and conversational completion the same engineering problem.

The OpenAI client-event reference distinguishes automatic response creation from automatic interruption. That separation lets an application observe speech events without treating every event as a command to generate or cancel a reply.

A third question sits beside them: should new sound interrupt the agent? Speech can be a short acknowledgment, a person elsewhere in the room, or the caller correcting a dangerous misunderstanding, and your cancellation policy needs different consequences for each case.

Our interruption state machine guide explains the downstream cancellation boundary. Here, the input is the evidence that should cause that state machine to run.

Why one threshold cannot solve everything

An acoustic activation threshold trades missed speech against false speech detections. A silence duration trades waiting against premature endpoints, and a semantic completion score trades different linguistic mistakes against each other.

Treating those controls as interchangeable makes tuning unpredictable. If the system repeatedly misses quiet initial consonants, adding a longer silence timeout will not restore audio that the speech segmenter already discarded.

Prefix padding addresses another problem: preserving audio before speech activation. It requires a rolling input buffer and changes the audio included in the utterance, rather than changing whether the user has yielded their turn.

The Silero VAD project documents speech detection and supported sample rates as part of its public implementation. Its output can be useful input to a turn policy, but a speech detector's README is not a task-completion benchmark.

Start with the failure you can observe. Classify a clipped onset, premature reply, background-triggered interruption, and long wait as separate defects, then choose the control whose mechanism matches that defect.

Separate endpointing from idle behavior

Endpointing follows an utterance that appears to have ended. Idle handling decides what to do when the conversation has no useful activity for a longer interval, including a caller who never answered.

A reminder such as asking whether the caller needs more time belongs to idle policy. Triggering a full answer merely because an idle timer fired can create a response to silence, especially if a transcription system has produced speculative or empty text.

Use task state to make the reminder appropriate. A caller searching for a document needs a different follow-up from someone who has gone silent during an authentication step, where the system should avoid repeating sensitive information aloud.

The agent's prompt can describe the intended conversational behavior, but enforcement belongs in a workflow boundary outside the prompt. The timer should produce a specific permitted transition, with a reason visible in the trace.

Choose the control whose mechanism matches the observed failure.

Build a policy around evidence

A useful turn policy combines signals without pretending each signal has the same meaning. Define the evidence available at each decision point and what actions that evidence can authorize.

Consider a caller answering a scheduling question. An acoustic detector reports silence after the words "Tuesday, let me check," while a partial transcript suggests an unfinished answer and the workflow still lacks a confirmed time.

The safe response is to preserve the caller's turn for a bounded period. A speculative read of available times may be acceptable under a separate read-early, commit-once policy, but the system should not book an appointment on that fragment.

The following matrix compares what signals establish by themselves. Checkmarks indicate evidence provided by that signal, not guaranteed correctness or vendor support.

The last column matters. An end-of-turn decision permits the agent to consider a response; it does not replace authorization, argument validation, or the caller's confirmation of a consequential action.

LiveKit's turn-detector documentation describes a contextual detector as a distinct integration component. Its documented scope helps you identify which evidence comes from acoustic detection and which comes from completion modeling.

A turn classifier can confidently detect that a sentence ended while misunderstanding the sentence itself. Keep completion confidence separate from speech-recognition confidence and business-intent confidence in both code and monitoring.

Define a small state model

Use states that map to observable behavior: listening, possible endpoint, preparing response, speaking, and waiting for clarification. You may already have these states in the conversation runtime, so extend their transitions instead of building another orchestration layer.

A possible endpoint should be reversible. If the caller resumes before the agent starts audible speech, cancel the prepared response and continue the same conversational turn unless a task-specific rule requires a new turn.

Once speech is audible, resumption becomes an overlap decision. The system must decide whether to stop output, which buffered audio to discard, and whether a partly heard answer belongs in conversation memory.

stateDiagram-v2
    [*] --> Listening
    Listening --> Candidate: Speech stops
    Candidate --> Listening: Caller resumes
    Candidate --> Preparing: Turn policy accepts endpoint
    Preparing --> Listening: New caller speech
    Preparing --> Speaking: Valid response starts playback
    Speaking --> Listening: Confirmed interruption
    Speaking --> Listening: Playback finishes
    Candidate --> Clarifying: Bounded wait expires ambiguously
    Clarifying --> Listening: Clarification delivered

The diagram is vendor-neutral. It specifies ownership and reversibility, rather than implying a public 60db Agent API or revealing an internal implementation.

LiveKit's turn-handling overview documents configurable turn detection and interruption handling. Its existence supports treating these as distinct runtime concerns, while the state model here is an engineering proposal you should adapt to your selected framework.

Let task state change the cost of a mistake

The same acoustic pause has different consequences across tasks. Cutting off an optional preference question is inconvenient; cutting off the final digits of an account reference can produce an incorrect lookup or an unnecessary repetition of personal information.

Record the current task class as a bounded label. You need categories such as collecting a reference, awaiting confirmation, or casual explanation, rather than the reference value or the full caller utterance.

An endpoint policy can then use stricter completion requirements for tasks where errors are expensive. Keep that adaptation explicit and testable, because hidden per-task exceptions are hard to reproduce and easy to forget during a provider migration.

The comparison belongs in outcome metrics, too. A faster average answer is a poor trade if the new policy creates more repeated questions or failed confirmations in the task that pays for the call.

Label a corpus that exposes mistakes

The corpus must describe intended turn ownership, not just where speech energy stops. Acoustic labels alone cannot tell you whether an endpoint was premature.

Use consented test recordings or newly recorded synthetic scenarios with clear provenance. Avoid using customer transcripts as convenient fixtures, and do not assume removing a name makes a voice recording anonymous.

Start with cases that challenge one assumption at a time. A quiet speaker tests activation; a long thinking pause tests turn retention; a television voice tests speaker relevance; and a short acknowledgment during agent speech tests interruption policy.

Keep the expected result tied to the scenario. If an actor deliberately says they need time and resumes after a scripted pause, the label can specify that the agent should remain silent until resumption or a bounded supportive prompt.

A realistic corpus also needs cases where waiting is wrong. Record short complete answers, explicit refusals, and clear requests for help so the evaluation penalizes policies that avoid interruption by delaying every response indefinitely.

For multilingual cases, label language and switching points without guessing nationality or identity. The multilingual task benchmark explains why identical timeout values can have different effects across language and task combinations.

Annotate independent timelines

Create at least an acoustic speech timeline and a conversational turn timeline. The first marks where intended speaker speech exists; the second marks the earliest acceptable point for an agent response under the scenario instructions.

You can add an ambiguity interval when multiple response times would be reasonable. Forcing every clip into one exact millisecond creates false precision and encourages a model to imitate the annotator's timing rather than respect the caller's task.

Have annotators review disagreements without seeing the policy being evaluated. If they know which output came from the new configuration, their expectations can contaminate labels and turn a regression test into a preference poll.

Record uncertainty explicitly. A clip labeled ambiguous can remain useful for qualitative review, while a release gate should rely on examples whose expected behavior has enough agreement to support a clear pass or fail.

A fixture manifest needs a fixture identifier, format, language label, scenario class, allowed behavior, and annotation version. It does not need a real phone number, a customer's account identifier, or the literal business document someone read aloud.

Keep fixture identifiers stable across releases. When you correct an annotation, version that change separately so an apparent model improvement cannot hide a moving answer key.

Preserve the audio conditions

Audio preprocessing changes what the detector sees. Record the sample rate, channel count, codec path, resampling behavior, gain control, and whether echo cancellation or noise suppression ran before the test input reached the agent.

A clean local microphone recording sent directly to a model does not reproduce narrowband telephony. Neither does converting it to a lower sample rate without reproducing the codec and packetization conditions that affect the real route.

The goal is controlled relevance. Keep a clean fixture set for deterministic analysis and a transport-conditioned set for deployment checks, with the same intended utterances where possible so you can attribute failures to the audio path.

Transport choice affects the test boundary. A browser fixture can include device and playback behavior; a SIP fixture must also account for negotiated media and telephony processing before the agent receives audio.

Do not mix these cohorts in a single headline metric. A change that helps clean browser audio while harming telephone calls needs a segmented report, even if the aggregate happens to improve.

Include recovery, not just first response

A premature response does not always end the task. Record whether the caller corrected the agent, whether the agent stopped promptly, and whether the next turn recovered without losing information.

That recovery has a cost. It consumes time, creates repeated speech, and can change the meaning of a later confirmation, so a recovered task should retain its original error label even if the final outcome is successful.

Use the real-call regression harness to replay full sequences. A single isolated pause cannot expose a stale response that reappears after the caller resumes or a tool result that arrives after its turn was canceled.

Measure errors and waiting together

A turn policy needs at least two axes: how often it violates the caller's intended turn and how long it waits after an acceptable endpoint. Optimizing either axis alone produces an easy but useless winner.

Define a premature endpoint as an accepted endpoint before the earliest acceptable response boundary in an unambiguous fixture. Define a missed endpoint as failure to proceed within the fixture's allowed response interval after a complete turn.

Keep false interruption separate. An agent can endpoint correctly while later stopping its own answer because a background voice triggered the interruption detector.

For waiting time, choose an observable start and end. A useful server-side endpointing delay starts at the annotated acceptable boundary and ends when the policy accepts the endpoint; end-to-end response delay ends at actual audible playback.

These metrics answer different questions. A provider's synthesis onset number excludes endpointing and can exclude transport and device buffering, so it cannot stand in for conversational response latency.

The latency guide provides the wider measurement boundary. Keep your endpointing experiment narrow enough to explain cause, then verify the full path before release.

Use rates with honest denominators

Report premature endpoints per eligible turn, false interruptions per agent-speaking interval, and missed endpoints per completed user turn. Include the count behind every rate.

Do not divide all errors by all call minutes. A long monologue creates more minutes without necessarily creating more opportunities for a premature endpoint, which can make a weak policy appear better on a different workload.

Repeat-call dependence matters. Many turns from one speaker or one fixture are correlated, so thousands of replayed turns do not equal thousands of independent speakers or independent task situations.

A practical report groups results by fixture and speaker cohort, then shows uncertainty using a method that respects those groups. If you use bootstrap intervals, resample at the appropriate independent unit and describe that unit in the report.

Zero observed failures still needs context. It means the evaluated set produced none under the tested conditions, not that the failure is impossible in production or that the policy is safe for every accent and device.

Treat costs as a decision rule

You can compare policies using an explicit weighted objective, but the weights are product decisions. A false cutoff, an extra second of waiting, and a missed urgent interruption do not carry universal exchange rates.

For an illustrative evaluation, assign a higher penalty to cutting off a reference number than to a modest wait after a complete casual answer. Publish that weighting as an assumption and keep the raw error counts alongside the combined score.

Otherwise, a single number conceals the trade. Two policies with equal scores can fail in different ways, and one may be unacceptable for your use case even though the arithmetic ranks them equally.

Cost per successful call can capture repeat attempts and added call duration after deployment. It should supplement the safety and experience constraints, rather than permit an economic average to excuse a serious workflow failure.

Distinguish a plotted frontier from measured evidence

A latency-versus-cutoff chart is useful only when its points come from actual runs. Before measurement, show the axes and explain the experiment; do not draw a persuasive downward curve that looks like a result.

After measurement, label every point with the configuration identifier and sample count. Use the same fixture set and replay conditions, and show excluded or failed trials so policy comparisons remain auditable.

A Pareto frontier contains configurations for which no evaluated alternative improves both axes. Choosing among those points still requires product judgment about whose mistakes matter and how much waiting is acceptable.

That distinction is valuable during review. Engineers can demonstrate that one configuration dominates another on the tested set without claiming that the chosen business trade-off is mathematically inevitable.

Run a controlled endpointing experiment

Change one policy dimension first. If you simultaneously alter VAD, speech recognition, prompt wording, and transport buffering, a better result will be hard to explain and a worse result will be hard to repair.

Pin the input corpus, model versions where available, preprocessing, and runtime configuration. Record any provider setting that cannot be pinned, because a moving hosted model limits strict reproducibility even when your application commit remains fixed.

For silence-based endpointing, sweep a small set of candidate durations that bracket your current setting. The values are experimental choices; do not present a timeout borrowed from a provider example as a recommended production default.

Run the current baseline first and repeat it after the candidates. A shifted baseline can reveal provider drift, changing machine load, or a fixture playback problem that would otherwise be mistaken for a policy improvement.

Keep a minimal result schema

The following vendor-neutral record is an example evaluation format. It is not a 60db Agent response object, and the empty collection does not claim measurements were taken.

{
  "fixture_version": "pause-corpus-v1",
  "policy_version": "candidate-a",
  "clock_domain": "replay-host-monotonic",
  "results": []
}

Each result should include the fixture identifier, repetition index, accepted endpoint time, acceptable endpoint interval, audible response time when available, and a categorical failure reason. Store raw event timing separately from derived pass/fail decisions so corrected evaluation logic can recompute results.

Do not put utterance text into metric labels. If an authorized reviewer needs fixture content, keep it in the controlled fixture store and join through the opaque identifier under the appropriate access policy.

The observability guide explains how correlation identifiers connect endpoint events to audio, tools, and playback. The evaluation schema should reuse those identifiers rather than invent a competing trace model.

Add assertions that catch invalid comparisons

Before comparing policies, verify every expected fixture produced a terminal result. An empty result set must fail evaluation; it must never become a zero-error success.

Assert that timestamps used in one subtraction belong to the same clock domain or have a documented synchronization method. Negative delay can indicate a legitimate prefetch boundary, a mistaken annotation, or clock misuse, so inspect it rather than clipping it silently to zero.

Require explicit handling of ambiguous fixtures. A test runner should exclude them from strict timing gates with a reported count, or evaluate them against an allowed interval; treating them as ordinary failures distorts the objective.

Check cancellation invariants alongside detection metrics. If speech resumes during response preparation, a stale candidate response must not become audible later merely because its provider request completed successfully.

A release candidate needs the whole chain. The shutdown guide covers another edge: closing a call must invalidate pending responses even when endpointing and interruption code are otherwise correct.

Review the worst cases by mechanism

Sort failures into mechanisms before changing settings. A cutoff caused by a late transcript revision requires a different fix from a cutoff caused by the silence timer ignoring an explicit wait request.

Inspect outliers using synchronized event views, preferably with consented fixture audio and a text-independent timeline. Reviewers should see when speech existed, when a candidate endpoint appeared, when the policy accepted it, and when the agent became audible.

Resist averaging away a reproducible failure. A candidate that improves most easy clips while consistently failing one supported language or accessibility condition needs a scoped exclusion, a repair, or a different rollout plan.

Document the reason for the selected configuration in terms of observed errors and allowed trade-offs. A statement that the setting "felt natural" can accompany a listening review, but it cannot replace the actual acceptance criteria.

Missing fixture results cannot be reported as a zero-error endpointing experiment.

Handle interruptions and background speech

Interruption policy decides whether the caller should regain the floor while the agent speaks. It uses speech evidence, but its most expensive mistakes often come from confusing relevant caller speech with other audible sources.

A television can contain perfectly intelligible human speech. VAD is correct to classify that signal as speech, while a conversational policy may be wrong to treat it as the caller's instruction.

Likewise, a caller saying a brief acknowledgment may intend the agent to continue. A system that cancels every answer on every voiced sound can make conversation exhausting even if its detection recall is excellent.

The correct policy depends on what your input path can establish. A single mixed microphone stream cannot reliably guarantee speaker identity, and a transcript alone cannot tell whether a phrase came from the intended caller.

Use a two-stage interruption decision

Treat acoustic speech start as an interruption candidate. A stronger confirmation can incorporate minimum voiced duration, recognized content, speaker relevance when supported, and whether the task permits interruption at that moment.

Those checks add delay. Measure the time until output actually stops, because a detector that avoids false triggers by waiting too long can prevent callers from correcting a harmful misunderstanding.

A short initial output ducking policy is another possible design, but it changes audible behavior and requires its own tests. Do not add it merely to hide uncertainty in the detector or to make a demo look smoother.

The interruption-safe runtime needs a clear event contract: candidate, confirmed, canceled candidate, and completed stop. A single boolean called interrupted loses the information needed to explain why audio continued or stopped.

Test echo separately

An agent's own synthesized speech can leak into its microphone input. That creates a feedback loop in which output triggers VAD and then cancels the output that caused the trigger.

Record whether echo cancellation is enabled and where it runs. Browser, device, transport gateway, and server processing can interact, so a setting that works with headphones may fail when callers use a loudspeaker.

Use a controlled speakerphone fixture and vary output level within safe listening conditions. The pass condition is stable behavior under the supported setup, with no self-triggered cancellation and no unexplained suppression of genuine caller speech.

If browser calls pass and telephony calls fail, inspect the media boundary before retraining a classifier. SIP audio troubleshooting helps establish that the input actually carries the expected signal and format.

Make accessibility part of the supported workload

Callers differ in speaking rate, breath patterns, volume, and the length of pauses between words. A policy tuned on fluent scripted speech can penalize people whose natural delivery includes longer gaps or speech that the recognizer handles less confidently.

Build explicit supported-case fixtures with appropriate consent. Describe the behavior you test rather than assigning medical labels or collecting sensitive attributes that the evaluation does not need.

Offer a route to assistance when the system repeatedly fails to hold the turn. A warm handoff should preserve the task state and the caller's requested next step without forwarding an unnecessary audio history.

A generous timeout alone is insufficient. The system also needs clear acknowledgment of requests for more time and a bounded way to recover when silence has become ambiguous.

Implement safe transitions

Keep the policy state close to the runtime that owns audio playback. A disconnected classification service can provide evidence, but the runtime must decide which response generation and playback buffers remain valid after that evidence arrives.

Use a monotonically advancing turn generation or equivalent cancellation identity. Every prepared response carries the generation it belongs to, and the playback owner rejects responses from an invalidated generation.

That check protects against races. Cancellation is often cooperative, so a network request can complete after the application requested cancellation; accepting its result without checking ownership can revive stale speech.

The same principle applies to tools. A canceled response can release a read-only prefetch result for later reuse only under an explicit data and freshness policy; it must not silently commit a write that the caller's resumed speech has invalidated.

Distinguish speculation from commitment

You can start preparing a likely response while waiting for a stronger endpoint decision. Preparation is reversible only if its output remains inaudible and its tools cannot perform unauthorized side effects.

Tag speculative work in the trace. Otherwise, an early model-start event can make latency look excellent even while the user waits for a later endpoint decision and the prepared response is frequently discarded.

Count discarded work in resource usage. Faster perceived response can consume extra model or synthesis work, and that cost belongs in the cost-per-success analysis rather than disappearing as an implementation detail.

Keep confirmation near the irreversible boundary. A classifier's belief that the user finished speaking cannot authorize a booking, payment, or record update whose arguments still depend on the unfinished utterance.

Keep the silence response bounded

A supportive prompt should not become an infinite loop. Define how many reminders the task permits and what terminal state follows when the caller does not respond.

The terminal state can be abandonment, safe closure, or a supported transfer path. Record which occurred instead of labeling every silent call a successful completion simply because the system ended cleanly.

Avoid repeatedly restating private information during reminders. A caller may have put down the phone, and your system should not keep reading sensitive details to an unattended speaker.

Local versus managed data boundaries apply here as well. A silence-handling feature that sends extra audio to another processor changes the data path and deserves explicit review of the documented service contract.

Ship and monitor the policy

Release endpointing changes as versioned configuration with a rollback path. Record the VAD implementation, endpoint policy, relevant model settings, and fixture version together so a later incident has an identifiable baseline.

Use a limited rollout that preserves meaningful cohorts. Compare the same task and route classes, and keep operational changes such as a carrier migration out of the experiment when possible.

Monitor caller repetition, abandonment after overlap, clarification requests, false interruptions, and end-to-end response timing. These are complementary signals: no single metric establishes that a conversation feels respectful and completes correctly.

A symptom such as increased repeat calls may emerge later than the immediate endpoint event. Join that outcome through a privacy-preserving task identifier rather than extending raw transcript retention just to make analysis easier.

State what the product test proves

For 60db Agent, use a documented browser or authorized outbound testing surface in the selected workspace. Public inbound availability is unconfirmed, so do not make an evaluation plan depend on a generally available inbound route.

Observe behavior at the supported boundary. If the interface exposes only high-level events, report that limitation and use controlled recordings to measure audible behavior instead of claiming access to internal turn scores.

No internal deployment aggregate supplied for this series establishes a turn-detection win. The article's proposed corpus and metrics are a measurement plan, and any later result should identify the exact tested configuration, sample size, and uncertainty.

The outcome guide completes the loop. A useful rollout preserves the caller's ability to finish and improves verified task outcomes under the conditions you actually support.

Frequently asked questions

What is VAD in a voice agent?

VAD estimates whether an audio segment contains speech. A voice agent can use that estimate to manage input buffering, but it still needs a policy for deciding when the caller has finished their turn.

What is semantic turn detection?

Semantic turn detection estimates conversational completion using linguistic or contextual evidence. It can distinguish some unfinished statements from complete answers, but it remains probabilistic and needs workload-specific evaluation.

Does silence always mean the caller finished?

Silence can mean the caller finished, is thinking, is looking for information, or is experiencing an audio problem. Interpret it with task state and a bounded waiting policy rather than treating every quiet interval as permission to answer.

Which silence timeout should I use?

Choose a timeout through a controlled evaluation of your supported tasks and audio routes. A provider's example value describes an interface configuration; it does not establish the right trade-off for your callers.

Can a prompt fix premature endpointing?

A prompt can describe requests for more time or appropriate clarification behavior. It cannot reliably recover audio that was never captured or enforce cancellation after a stale response has already entered the playback buffer.

Why does background television interrupt my agent?

Television audio can contain genuine speech that an acoustic detector correctly recognizes. Your interruption policy needs evidence about relevance, and it should acknowledge the limits of a single mixed audio stream.

Should every acknowledgment stop agent speech?

Short acknowledgments do not always request the floor. Test the intended conversational behavior explicitly, and measure the added delay if you require stronger interruption confirmation.

What is prefix padding?

Prefix padding retains a short amount of audio before detected speech onset. It helps preserve initial speech sounds that precede activation, while turn completion remains a separate decision.

How do I measure a premature endpoint?

Compare the accepted endpoint with a labeled earliest acceptable response boundary. Report errors per eligible turn and preserve ambiguous cases separately so annotation uncertainty does not become false precision.

How do I measure endpointing latency?

Measure the interval between an acceptable end-of-turn boundary and the policy's endpoint acceptance event. Measure audible response latency separately, because model generation, transport, and playback add further delay.

Are VAD probabilities calibrated confidence scores?

Do not assume a detector's numeric output is a calibrated probability for your environment. Validate its behavior on your audio conditions, and keep acoustic confidence separate from intent and turn-completion confidence.

Can endpointing be different by language?

Language, recognition quality, and task structure can change the effect of a policy. Evaluate supported language cohorts with the same outcome definition instead of assuming one configuration transfers unchanged.

How should I test long thinking pauses?

Record consented scenarios where the speaker explicitly requests time and resumes after a known interval. Include complete answers as counterexamples so a policy cannot pass by waiting indefinitely.

Is push-to-talk more reliable?

Push-to-talk provides an explicit release signal, which removes some endpoint ambiguity. It changes the interaction model and still does not prove that recognized content or business-action arguments are correct.

Why does the agent interrupt itself?

Output audio can leak into the input path and trigger speech detection. Test echo handling with the supported speakerphone and device conditions before changing conversational thresholds.

Should I store recordings for every failure?

Store only what your consent, access, and retention policy permits. Metadata traces and controlled fixtures often explain timing failures without retaining real caller audio or transcripts.

Does faster endpointing reduce call cost?

It can reduce waiting, but premature replies can add repetitions and repeat calls. Evaluate total cost per verified outcome alongside timing and error constraints.

What should happen when the caller resumes?

Before audible response, invalidate the candidate response and continue listening. During playback, apply the interruption policy and ensure canceled generation cannot resume later.

Can I compare vendor turn detectors directly?

Compare them only under equivalent audio, tasks, measurement boundaries, and supported settings. Report missing controls and provider drift instead of turning unlike demonstrations into a performance ranking.

What should a first release gate contain?

Require complete fixture coverage, bounded premature endpoints, acceptable waiting, and correct cancellation under resumed speech. Set thresholds from the task's risk and observed baseline, then retain a rollback configuration.

Choose the next experiment

A useful endpointing system preserves the distinction between speech presence, turn completion, and interruption. Each question has a different failure mode and needs evidence that matches its role.

Build a small consented corpus before changing thresholds. Label acoustic speech and intended turn ownership separately, include complete answers and difficult pauses, then compare waiting time with premature responses on the same fixtures.

Keep response preparation reversible until the policy permits audible output. Tie every response to its turn identity, reject stale results, and keep business writes behind their own confirmation and authorization checks.

For a practical next step, choose one supported task and one audio route in 60db Agent or your existing stack. Record the current behavior, run a narrow endpointing sweep, and select a candidate only after the full conversation still completes correctly under interruption and silence.