Overlap, duck, or stop? Design full-duplex audio policy

TL;DR: Treat output gain, playback progression, and conversational ownership as separate controls. Ducking can be reversed while an overlap is uncertain; a confirmed interruption needs response invalidation and queue cancellation, and every policy must preserve caller input and test both false stops and missed corrections.

---

A caller says "mm-hm" while an assistant explains a task. Stopping immediately can break a useful explanation, while ignoring an explicit "stop" can make the same application feel unresponsive.

A single speech threshold cannot express both requirements. Your audio policy needs to decide what happens to the mix while evidence accumulates and what event transfers ownership of the conversation.

The interruption safety guide covers committed cancellation. This guide adds a policy matrix and a synthetic audio fixture generator so you can inspect overlap, ducking, pause, and stop as different behaviors.

The examples are generic engineering artifacts for a voice application, including an integration with 60db Agent. They contain no measured product results and do not imply a particular private implementation.

As of November 2026, public Web Audio gain and scheduling primitives support building a custom playback policy, but primitives do not select the conversational behavior for you. The policy still needs explicit rules, device coverage, and a record of what remains unobserved.

Table of contents

1. Separate the controls before tuning
2. Write the overlap policy matrix
3. Build reproducible mix fixtures
4. Connect gain control to response ownership
5. Preserve capture and double talk
6. Choose boundaries for telephony and browsers
7. Evaluate the policy without hiding trade-offs
8. Operate and revise the policy
9. Frequently asked questions
10. Ship a policy with evidence

Separate the controls before tuning

Ducking changes the level of output; interruption changes who owns the turn. A player can reduce gain while preserving the current response, and a controller can invalidate a response even when some downstream audio remains beyond its control.

Playback progression is another independent control. A ducked stream can continue advancing quietly, while a paused stream holds a position if the player supports that behavior.

That difference changes recovery. Restoring gain after a duck does not replay words that passed while the volume was low, whereas resuming a pause can continue from a retained point in the response.

Do not call both operations "pause" in logs. Record the actual gain action and whether the media cursor kept advancing, since the caller's likely listening experience depends on both.

A stop can be local and reversible only in a limited sense. You might retain source data and create a new playback attempt, but audio already emitted cannot be retracted and a stopped one-shot source may require a new source object.

A committed interruption should invalidate old output ownership. Restoring a volume slider later must not revive a response that became obsolete when the caller corrected a value.

The self-correction guide explains the task-state consequence. If the caller changes the fictional delivery entrance, the previous entrance explanation is stale even if its remaining audio can still be played technically.

Keep input capture independent. The application needs to receive the caller's full correction during every output transition, so muting microphone capture is a separate half-duplex choice with a visible usability cost.

The figure shows a policy distinction rather than an automatic sequence for every sound. Some applications can stop immediately on an explicit control, while uncertain acoustic evidence can justify a short reversible change before classification finishes.

Define an explicit stop action that bypasses ambiguous acoustic classification. A button or other accessible control should request cancellation under the same response-ownership rule as a confirmed spoken stop.

Avoid treating simultaneous speaking as a metric failure by definition. A short acknowledgment can be useful, while a long overlap can be harmful; the annotation must describe the caller's intent and the task consequence.

The backchannel guide supplies labels for that distinction. Reuse the same labels in the policy matrix so the detector evaluation and the player evaluation refer to the same behavior.

Gain, playback position, and response validity need independent controls.

Write the overlap policy matrix

Start with caller intent categories and content consequence. The output action for a brief acknowledgment during an explanation can differ from the action for an explicit correction during a confirmation request.

Write the policy in ordinary language before encoding it. A reviewer should be able to decide whether a synthetic conversation followed the rule without reading the gain-control implementation.

For uncertain speech onset, one possible rule is to reduce output briefly while retaining the response generation. If evidence resolves to a harmless event, restore only if that generation and its task facts remain current.

If evidence resolves to an interruption, invalidate the generation, clear controllable output, and preserve the incoming caller turn. The partial transcript guide explains why an unstable recognition fragment alone should not authorize a business operation.

Do not require a long transcript before honoring an explicit stop control. The acoustic detection path and the user-control path can share cancellation effects without sharing all of their evidence requirements.

The table is a candidate policy for synthetic evaluation, not a universal recommendation. ✓ means the action is allowed under the stated condition; ✗ means it is forbidden by this candidate's safety rule.

Specify what happens when uncertainty does not resolve. A bounded wait should end in a declared choice such as yielding and asking a short clarification, rather than keeping output indefinitely quiet while the call appears stuck.

The timeout value needs empirical tuning for the supported routes and users. Do not copy the synthetic fixture's durations into production and describe them as an evidence-based optimum.

Avoid a global list of uninterruptible content unless the product has a concrete requirement. A user still needs a way to stop sound or leave, and the system should preserve the caller's input even if a particular announcement has its own completion requirement.

For required disclosures or consequential flows, define the completion and consent contract separately. The workflow guide helps keep content requirements from becoming permission to ignore user control.

A policy needs a reason field. "Duck because input source is unresolved" and "stop because caller corrected the proposal" produce similar temporary silence while requiring different history and recovery behavior.

Keep the reason vocabulary small. It should map to known fixture categories and operational actions rather than growing into a collection of nearly identical labels that nobody can compare across releases.

Build reproducible mix fixtures

A reproducible fixture separates audio arithmetic from speech interpretation. First verify that the mixer applies the intended gain envelope and avoids numeric clipping, then use consented speech fixtures to judge intelligibility and conversation behavior.

The following Python script writes a synthetic stereo reference file and separate mono mixes for overlap, duck, and stop. The left reference channel represents assistant output and the right represents caller input; the tones are markers rather than simulated human speech.

The Python wave module provides standard-library WAV writing. Save the script as overlap_fixtures.py, run it with Python 3, and keep playback volume comfortable if you listen to the generated markers.

import math
import struct
import wave
from pathlib import Path

RATE = 16000
SECONDS = 2
TOTAL = RATE * SECONDS


def tone(freq, amplitude, start, end):
    return [
        amplitude * math.sin(2 * math.pi * freq * i / RATE)
        if start <= i / RATE < end else 0.0
        for i in range(TOTAL)
    ]


def assistant_gain(mode, t):
    # Synthetic envelope, not a production timing recommendation.
    if mode == "stop" and t >= 0.7:
        return 0.0
    if mode == "duck":
        if 0.65 <= t < 0.7:
            return 1.0 - 0.8 * (t - 0.65) / 0.05
        if 0.7 <= t < 1.2:
            return 0.2
        if 1.2 <= t < 1.3:
            return 0.2 + 0.8 * (t - 1.2) / 0.1
    return 1.0


def write_wav(path, frames, channels):
    flattened = [sample for frame in frames for sample in frame]
    if any(not math.isfinite(x) or abs(x) > 1 for x in flattened):
        raise ValueError("Non-finite sample or clipping risk")
    pcm = b"".join(struct.pack("<h", round(x * 32767)) for x in flattened)
    with wave.open(str(path), "wb") as output:
        output.setnchannels(channels)
        output.setsampwidth(2)
        output.setframerate(RATE)
        output.writeframes(pcm)


def make(directory):
    directory.mkdir(parents=True, exist_ok=True)
    assistant = tone(330, 0.25, 0.0, 1.8)
    caller = tone(550, 0.25, 0.7, 1.2)
    write_wav(directory / "synthetic-reference.wav", zip(assistant, caller), 2)
    for mode in ("overlap", "duck", "stop"):
        mixed = [
            (a * assistant_gain(mode, i / RATE) + c,)
            for i, (a, c) in enumerate(zip(assistant, caller))
        ]
        write_wav(directory / f"synthetic-{mode}.wav", mixed, 1)
    assert assistant_gain("duck", 0.8) == 0.2
    assert assistant_gain("duck", 1.4) == 1.0
    assert assistant_gain("stop", 0.8) == 0.0
    for path in directory.glob("*.wav"):
        with wave.open(str(path), "rb") as audio:
            assert audio.getnframes() == TOTAL
            assert audio.getframerate() == RATE
    print("Synthetic fixture envelope and file checks passed")


if __name__ == "__main__":
    make(Path("synthetic-overlap-fixtures"))

The fixture uses fixed sample rate, duration, tone frequencies, and gains solely to make the output deterministic. Those values are synthetic test inputs and do not represent measured speech quality, recommended voice levels, or a platform benchmark.

The mixer rejects samples outside its numeric range. Real systems also need codec-aware headroom, loudness policy, and device testing; a passing array bound does not certify comfortable or intelligible playback.

The stop envelope deliberately exposes an abrupt boundary in a synthetic marker. A production stop may use a tested short fade to avoid clicks, but the fade's residual audio still belongs in the stop-time measurement.

Use the stereo reference to inspect which source is present at each point. The mixed file alone loses that separation and makes it harder to tell whether a low-level caller was preserved or merely masked by output.

After arithmetic checks, replace the tones with approved speech assets under the same timing schedule. Keep the reference channels, script text, consent status, and expected intent label beside the fixture.

Do not claim tones validate a semantic interruption detector. They validate file construction and mix behavior, while actual speech fixtures test whether a caller's correction remains audible and actionable under the policy.

Connect gain control to response ownership

A gain control should carry the response identity it affects. Otherwise a delayed restore callback can raise the volume of a new response or revive an old one after the caller changed direction.

Use a small state record containing active generation, gain mode, pending overlap identity, and lifecycle state. A candidate event can request ducking without changing generation; a confirmed interruption changes generation and makes old callbacks ineligible.

Keep that transition serialized with the output gate. The gate should reject stale audio before it enters the player, because canceling the producer alone does not stop a late chunk already in flight.

The audio queue guide covers bounded admission. A ducked player that keeps accepting unlimited output can restore into a long backlog even when the policy decision itself was correct.

A restore operation must check both generation and task revision. A response can become stale through a tool result, caller correction, or lifecycle transition even if no explicit spoken interruption was classified.

If the output continued advancing while ducked, decide whether the low-volume interval needs a brief repeat. Use a self-contained phrase when intelligibility is uncertain rather than restarting at an arbitrary sample that begins inside a word.

The resumption guide develops that decision. Resumption depends on content validity and delivery evidence, not just whether the gain control can return to its previous value.

Gain automation also needs consistent clock coordinates. Schedule ramps using the player or audio context's supported time base, and record callback observation time separately from scheduled render time.

Do not mix a server timestamp with an audio-context timestamp when calculating a fade endpoint. Convert only through an explicit synchronization model or keep each local duration within its own clock domain.

An existing ramp can collide with a new ramp. The implementation should cancel or hold prior automation under the chosen API's semantics before scheduling a new transition, and tests should cover a second candidate event during restoration.

Keep the simplest supported envelope. Multiple gain curves and configurable stages add combinations to test; add them only when actual listening evidence shows the existing envelope cannot meet the stated behavior.

A policy test should verify stale callback rejection directly. Begin ducking for one response, invalidate it, start another, then deliver the old restore event and assert that the new response's gain state remains unchanged.

The regression testing guide gives this event schedule a durable place. Save the expected ownership effect beside the fixture rather than asserting only that some function was called.

A restore callback must still belong to the active response and current task facts.

Preserve capture and double talk

A full-duplex application receives caller input while output is active. That contract must survive duck, pause, stop, and restore transitions, including when the caller begins quietly or speaks over a loud syllable.

The WebRTC audio processing requirements discuss endpoint echo control. They do not imply that a particular device preserves every double-talk condition, so evaluate the complete capture and playback route.

The echo diagnosis guide supplies silent-caller and genuine-interruption comparisons. Run those conditions before deciding that a policy needs a less sensitive speech detector.

If a supposed interruption contains the assistant's own words, identify whether they entered acoustically or through a software loop. A policy that stops on returned output can become unstable even when its gain code works exactly as written.

If genuine caller speech disappears during output, inspect capture processing and route behavior. A cleaner output-only recording is not a success when the caller's stop request was removed at the same time.

Include a quiet correction that carries a negation or revised value. Losing a small word can preserve most of a transcript while reversing its intended meaning.

Add a repeated-word fixture. The caller may repeat a fictional location name as a question immediately after the assistant says it, so output/input word similarity must not become a blanket rule for discarding input.

For browser capture, inspect actual track settings after requesting constraints. The Media Capture and Streams specification provides the supported-constraints and settings model used to inspect that boundary.

Do not assume the same configuration covers a route switch. A Bluetooth headset, device speaker, and handset earpiece can change processing and delay, and the output reference may need to be re-established under the new route.

The mobile browser guide helps organize physical-device coverage. A desktop replay cannot certify lifecycle and route behavior on a phone.

Keep input evidence available during a reversible output change. If the application discards early caller samples while waiting for classification, the eventual transcript can start after the most important word.

That creates a false impression of ambiguity. A caller who said "no, the other room" can become "the other room" if the beginning was clipped by a gate, which changes the evidence available to the conversation policy.

For accessible control, provide a visible or otherwise operable stop mechanism appropriate to the client. A spoken-only stop path can fail for people who cannot speak over the output or whose microphone route is unavailable.

Keep the control's semantics explicit. A mute toggle, a stop-speaking action, and ending the call are different requests, and each should have a distinct lifecycle effect that the user can predict.

Choose boundaries for telephony and browsers

A browser with a custom mixer can change local gain directly. A telephony adapter may expose only media submission and queue clearing, so the same policy concept can require a different implementation or be unavailable at the desired boundary.

Do not label a provider clear as ducking. Clear discards queued media under the provider contract, while ducking changes level and may preserve progression or source state.

Twilio's public Media Streams message contract documents media, mark, and clear. Build only behavior supported by that interface, and keep any application-side attenuation separate from claims about already-buffered provider audio.

If attenuated media is sent after normal-volume media has already queued, the caller can still hear the earlier normal-volume buffer first. Your effective control boundary is downstream of what has already been admitted.

The playback evidence guide explains why "sent" cannot stand in for "playing now." A policy needs the best available queue and acknowledgment evidence before it claims an audible transition happened.

A browser also has downstream buffers. Scheduling a gain change in an audio graph can be more direct than sending a remote command, but device output remains a separate boundary with its own latency.

The WebRTC statistics specification exposes media statistics useful for diagnostics. Treat energy and jitter-buffer fields as supporting observations, not as proof that a particular spoken correction was understood.

Keep codec framing in view when building test files. The Opus RTP payload specification defines codec transport behavior; a raw PCM fixture still needs the deployed encoder and packetization path before it represents a telephony or WebRTC trial.

A transport adaptation should declare capabilities. If the endpoint cannot provide reversible pause or reliable output gain control, choose a supported stop-and-repair policy rather than presenting an unavailable duck mode in configuration.

Avoid emulating pause by accumulating unbounded output. Holding the media cursor while generation continues can create a backlog that makes the eventual response conversationally stale.

The chunk-size guide helps inspect framing and admission granularity. Smaller chunks can make control more precise at one boundary while leaving a larger downstream queue untouched.

A capability test should be observable. Verify that a requested gain or stop action changes the recorded endpoint output under the declared setup, and report the unobserved physical path separately.

Evaluate the policy without hiding trade-offs

Measure the behavior the caller experiences and the task effect. A detector-only score can improve while output still talks over the caller because the player or provider retained a backlog.

Define overlap duration between annotated caller onset and the audible reduction or stop at the measured output boundary. State whether the measurement uses a local recording, a provider event, or a human annotation.

Keep separate counts for harmless acknowledgments that caused disruption, explicit stops that failed, and corrections whose content was lost. Combining them into one accuracy figure hides which user behavior became worse.

Track gain pumping during uncertain input. Repeated duck-and-restore transitions can make a sentence difficult to understand even when the controller eventually chooses the correct turn owner.

Count the transitions and annotate their cause. If one background sound creates several candidates, deduplicate or stabilize the event policy at the responsible boundary rather than adding more decorative ramps.

Measure repair burden after an interruption. A policy that stops quickly but always restarts a long explanation can still make the call tedious and increase the chance of another overlap.

The outcome metrics guide offers a way to connect these events to task success. Keep the media measures as diagnostics and record whether the caller completed the intended task without unnecessary repetition.

Use the same fixture set for candidate comparisons. If a candidate fails capture or loses a connection, report that condition rather than removing it from the denominator silently.

Annotators should know the scripted intent and review both channels. A mixed recording alone can make it hard to tell whether the assistant masked a quiet caller or the caller never produced the intended phrase.

For listening tests, state the environment and playback setup. Headphones in a quiet room are a useful controlled condition, but they do not represent every caller using a speaker in a busy space.

Do not invent a universal duck level or confirmation wait. Choose candidate values from the product's needs, test them under declared conditions, and report the selected operating envelope with its failures.

Keep synthetic arithmetic results distinct from listening judgments. The fixture generator's assertions prove file shape and envelope properties; they do not establish that a human could follow the sentence under a chosen mix.

Synthetic envelopes, speech judgments, and device-route behavior require different evidence.

Operate and revise the policy

Version the policy alongside its fixture labels and expected outcomes. A threshold change without a matching evaluation record is difficult to interpret when support later reports a regression.

A useful release note names the changed behavior: for example, harmless acknowledgments no longer commit cancellation while explicit stop controls still invalidate immediately. Avoid a vague claim that turn-taking became more natural.

Monitor route-specific failures. A global average can conceal that one mobile speaker route gained false stops while every headset route stayed stable.

Use content-free event reasons for routine telemetry. Raw recordings and transcripts need separate consent, access, and retention rules, and they should not be required just to count stop requests or stale restore rejections.

The observability guide describes response and operation correlation. Connect policy decisions to those identifiers so an operator can trace a correction without exposing its personal content in dashboards.

Retain a simple fallback appropriate to the client. If the duplex route is unreliable, a visible push-to-talk interaction can provide user control while the team repairs the route, provided the changed behavior is made clear.

A fallback should not silently reinterpret old queued output. Invalidate the current response when switching interaction modes if its playback and evidence cannot be preserved safely.

The shutdown guide supplies the terminal rule. A late restore callback after hangup must remain a harmless rejected event, never a reason to start output again.

Review the policy after adding languages or task categories. A short acknowledgment, a hesitant correction, and a spelled identifier can have different timing and recognition behavior across the actual users you support.

The structured-answer turn guide helps keep continuation cues visible. A policy tuned only on fluent full sentences can mishandle the pauses that real structured answers need.

Check the policy under resource pressure

A player can behave correctly in an idle test and miss its control deadline when decoding, rendering, or unrelated application work competes for resources. Add a declared pressure condition that resembles the supported client workload, then compare the same input and output boundaries used in the ordinary trial.

Do not describe a delayed JavaScript timer as an audio rendering measurement. Preserve the scheduled gain action, the callback observation, and the recorded output transition as separate events so the test shows which boundary moved.

If the application generates a long answer faster than playback, include that condition too. A temporary duck can become a long low-volume span when the player is already far behind, which changes both listening experience and the amount of content the resumption policy must repair.

Keep capture-health checks active during pressure tests. A missing caller signal is a failed trial, not evidence that the policy avoided interruption, and the report should identify whether the capture, decoder, player, or test harness failed.

Repeat the stop-control path while the application is busy. The user needs a predictable way to silence output even if recognition or classification is delayed, so the control should not wait behind a large batch of optional presentation work.

A pressure test should have an explicit end and cleanup. Stop the capture tracks, close the test player, and remove generated files under the fixture's own policy so repeated evaluation does not leave duplicate audio sessions running.

Distinguish ducking from disclosure completion

Some tasks contain an instruction or disclosure that must be delivered as a complete unit under the product's requirements. Reducing its volume while the cursor advances can leave the media system reporting completion even when the caller needs the sentence repeated.

Record that content category before the response begins. After an uncertain overlap, the policy can repeat the whole short unit or ask whether the caller wants it again, without pretending the gain envelope established comprehension.

Do not use an uninterruptible flag to infer consent. A caller can stop listening, lower volume, or leave the call, and successful playback at a technical boundary remains separate from accepting a proposal.

If the application needs explicit confirmation, bind the confirmation to the current proposal revision. A caller who interrupts to change a fictional destination has changed what the later yes would refer to, regardless of how much of the old proposal was played.

The qualified-answer guide covers that intent boundary. Keep the audio policy focused on control and evidence while the workflow validates the meaning of the response.

Retain an accessible escape path

A caller may be unable to speak over output because of an environment, device problem, or personal access need. A client that offers only acoustic interruption can leave that person without a reliable way to regain control.

Provide an operable stop control suited to the surface and verify it with the same terminal and ownership checks as spoken interruption. Its visible label should state whether it stops the current speech, mutes future output, or ends the session.

If a telephony surface uses a keypad action, document the exact supported provider event and keep the action separate from spoken content. Do not invent a keypad capability merely because another transport exposes one.

Test recovery after the control is used. The system should preserve current task facts, avoid replaying stale speech, and explain the next available action in a way the person can perceive through the supported channel.

Keep policy ownership explicit

The team that owns the conversation contract should approve changes to what transfers the turn. The team that owns the player should verify the mechanics of gain, stop, and queue clearing, with both groups using the same fixture identifiers and expected behavior.

That division prevents a local audio fix from silently changing task semantics. Lowering gain earlier can be a reversible acoustic choice, while accepting a new caller turn can invalidate a confirmation or a pending read that another subsystem depends on.

Write one owner for each invariant. Someone should be able to answer who verifies caller capture during ducking, who rejects stale audio, and who checks that business actions remain governed by current intent after a correction.

Do not spread the same policy into several independent callbacks. If capture, player, and recognizer each decide when to resume, late events can create contradictory actions even when every callback appears reasonable in isolation.

Review a failure with a complete event schedule

Take a synthetic case where the caller says "wait" during a long explanation. The input detector emits a candidate, the output ducks, recognition revises its partial, and a delayed restore arrives after the controller has already committed cancellation.

The expected result is stable: the caller input remains available, the old response stays invalid, and the restore is rejected. The explanation does not resume merely because an earlier timer expired.

Now change the case to a harmless acknowledgment while all task facts remain current. If the policy retains ownership, the output may restore under the declared rule, but any low-volume words still need a delivery-aware decision about whether a short repeat would help.

These paired schedules test the distinction the policy promises. They are more useful than a single happy-path recording because they force the implementation to preserve the boundary between a reversible mix action and a committed conversation transition.

---

Frequently asked questions

What is full-duplex audio policy?

It is the rule set controlling output while caller input remains active. The policy decides how overlap affects gain, playback progression, response ownership, and recovery under the capabilities of the selected transport.

Is ducking the same as pausing?

No. Ducking reduces level and can let the playback cursor continue, while a pause holds progression when the player supports it. The distinction determines whether words passed quietly or remain available at a retained position.

Should every detected sound stop the agent?

No universal rule fits every task and route. Label backchannels, explicit stops, corrections, echo, and uncertain input separately, then test the chosen output action and task consequence for each category.

When should a stop be committed?

Commit under the application's declared interruption evidence or an explicit user control. Once committed, invalidate the old response and reject its late output so a later volume restore cannot revive stale speech.

Can ducking be reversed safely?

Restore only if the same response and task facts remain valid. If the media cursor advanced quietly, the resumption policy still needs to decide whether any missing instruction should be repeated.

What does the synthetic fixture generator prove?

It proves the constructed file shape, numeric range, and selected gain-envelope properties. Tones do not validate speech intelligibility, a semantic interruption classifier, or the behavior of a physical device route.

How should duck levels be chosen?

Choose candidate levels and ramps under a documented listening setup, then test caller intelligibility and output comprehension. The synthetic gains in the example are reproducible inputs rather than recommended production values.

Why keep caller and assistant reference channels?

Separate channels show which source contributed to a mixed interval. They help reviewers distinguish a quiet caller masked by output from an absent caller signal or a returned copy of assistant audio.

Can echo look like an interruption?

Yes. Returned output can reach the input detector as speech-like content and trigger a stop. Diagnose the return path with silent-caller and genuine-speech trials before changing global sensitivity.

Does a minimum word count solve backchannels?

It can be one candidate rule, but it can also delay or miss short stop requests. Test the actual recognition update cadence and keep an explicit stop control available under a separate reliable path.

What is gain pumping?

It is repeated audible level movement caused by recurring duck-and-restore decisions. Count and inspect the transitions because a policy can preserve turn ownership while still making an explanation difficult to follow.

How should overlapping corrections affect tools?

A correction updates current intent under the task's revision rules. Stopping audio cannot roll back an external write, so check authoritative operation state and keep business authorization separate from mix control.

Can telephony always support reversible ducking?

No. Capabilities depend on the media boundary exposed by the provider and on audio already buffered downstream. Use supported stop-and-repair behavior when reversible gain or pause control is unavailable.

Does sending attenuated audio change queued audio?

It changes the new payload you send, while earlier normal-volume audio may still play first. Keep downstream buffering visible before claiming that a local gain decision immediately changed the caller's output.

Should microphone capture stop during output?

A full-duplex policy preserves capture so callers can interrupt. Muting capture is a separate half-duplex containment choice and needs a visible control path and an honest description of the changed interaction.

How should route changes be tested?

Treat each route as a separate condition and include switching when users can do it during a call. Record the device and software version because desktop or headset results do not certify a phone speaker route.

What happens if uncertainty never resolves?

End the wait under a declared bounded policy, such as yielding and asking a short clarification. Indefinite quiet output with active hidden work gives the caller no predictable way to recover.

Can a delayed restore affect a new response?

It can if the callback lacks ownership checks. Carry the original response identity and reject the restore after invalidation, task revision, or termination so it cannot change unrelated output.

Which metrics should compare policies?

Compare false disruptions of harmless input, missed explicit stops, preserved corrections, observed overlap duration, and task outcome. State the recording or event boundary for every timing measure and retain failed trials in the report.

What should a platform evaluation request include?

Ask which gain, pause, clear, playback, and interruption controls your integration can observe and use. Test those capabilities with synthetic fixtures before treating a broad full-duplex label as evidence of a particular caller experience.

Ship a policy with evidence

A useful full-duplex policy has separate controls, a small intent matrix, deterministic mix fixtures, and event schedules that reject stale restoration. Its report states the supported routes and keeps synthetic arithmetic separate from speech and device results.

Begin with one candidate policy and the smallest fixture set covering backchannel, explicit stop, quiet correction, and echo. Verify ownership and capture invariants before tuning levels or waiting periods, then expand only when a real failure exposes a missing condition.

For a 60db Agent integration, use the public controls and events available at your selected media boundary. The acceptance target is predictable caller control and preserved intent under overlap, with delivery uncertainty carried into a safe resumption decision.