Retrieval for speech: return an answer the caller can follow

TL;DR: Retrieval for speech should produce short, supported spoken units that answer the current question before adding necessary conditions. Keep evidence provenance outside the spoken wording, preserve critical exceptions, and evaluate whether a listener can follow and recover after interruption.

---

The retriever finds the right policy and the agent reads a dense paragraph aloud. The caller interrupts to ask what the first sentence meant, while the system continues queuing the rest.

This is a response-contract failure even when every retrieved passage is relevant. A useful spoken answer needs grounding, clear references, manageable units, and a way to revise the plan as soon as the caller changes the question.

Start with one supported spoken unit: a direct answer plus the condition needed to keep that answer true. Offer optional detail after the caller has enough information to decide whether they need it.

This guide supplies a small reference planner and runnable fixtures, a listening review rubric, and a diagnostic method. It does not present an automatic proof of natural-language entailment, a universal sentence length, or a production performance measurement.

All examples are synthetic and all diagrams are conceptual unless explicitly labeled otherwise. The public product name 60db Agent supplies context for the engineering audience; no private implementation is described.

Table of contents

1. Define the listening task
2. Keep evidence and wording separate
3. Choose the first spoken unit
4. Run a supported-unit planner
5. Preserve conditions and references
6. Handle interruption without stale replay
7. Review pronunciation and accessibility
8. Build a listening evaluation
9. Diagnose retrieval-to-speech failures
10. Connect the contract to live output
11. Design a replay that exposes listening failures
12. Frequently asked questions
13. Validate one answer end to end

Define the listening task

A reader can scan a table, reread a condition, and inspect a footnote. A caller hears a temporal sequence and may need the agent to repeat or rephrase a phrase that has already passed.

Define the outcome before choosing a summarization prompt. For a policy question, the listener might need to know whether a requested action is possible, which condition applies, and what to do next.

For a troubleshooting question, the listener might need one safe instruction they can carry out before receiving another. Delivering the whole procedure in one turn can make a grounded answer difficult to use.

These are task-specific goals. A brief answer to a complex eligibility question can be misleading, while an overly detailed response to a simple location question can bury the only fact the caller needed.

The W3C's cognitive accessibility guidance discusses clear content and reducing memory demands. Apply those principles to your listening task, then test with the intended audience rather than treating a word count as evidence of comprehension.

Keep success criteria observable. Ask a reviewer to state the answer and condition in their own words, choose the correct next step, or identify what the agent still does not know.

Do not score success solely by whether the generated text contains the right phrase. A listener can hear that phrase without understanding its referent, importance, or relationship to an exception stated much later.

A community report describes voice responses becoming overly verbose. Treat that as a real usability concern to investigate, not as proof about the behavior or cause of every voice system.

The outcome metrics guide separates a plausible answer from a successful task. For speech retrieval, include listening outcomes in that separation rather than importing text-only retrieval scores as the final quality measure.

The diagram ends at playback admission because the application can inspect that boundary. It does not claim that local acceptance proves acoustic audibility or that hearing the sentence proves understanding.

Keep evidence and wording separate

Maintain a private evidence bundle for the response and a separate speakable representation. A source URL, chunk identifier, document version, and authorization scope can be necessary for verification while being awkward or inappropriate to read aloud.

The spoken unit should point to its supporting evidence in the internal record. This lets the system offer a source through an appropriate channel without making the first answer a sequence of document titles and links.

W3C's PROV overview describes provenance relationships. A small application can preserve the same useful idea by recording which evidence observation supported each approved claim and which response used it.

Source presence does not prove support. A relevant passage may discuss the general topic while omitting the exact condition, date, or account state asserted in the proposed sentence.

Require claim-level review or a validated domain rule before approving wording. If your application uses a model to propose a paraphrase, treat that text as a proposal until the grounding check has decided whether the evidence supports it.

The reference planner deliberately avoids an entailment model. It accepts preapproved claim wording, checks evidence references, and composes only those immutable sentences under a small local word budget.

That narrowness makes the guarantee testable. The program can prove it did not invent an unapproved clause, while the human or domain validator remains responsible for whether the approved sentence is true and appropriate.

The query correction guide explains why the bundle must reference the current question revision. Evidence can support a sentence about the old question and still be unusable after a correction.

Freshness is independent too. The answer caching guide shows how an unchanged sentence can become obsolete when account state or source policy changes.

Do not let a source label travel without the actual observation it identifies. A citation string attached to generated text is weak evidence if the application cannot retrieve the relevant passage and version during review.

For private material, keep that review path authorized. Evidence provenance should make a response inspectable without creating a new unrestricted store of account facts or raw transcripts.

Choose the first spoken unit

Lead with the useful answer that the evidence supports. A long acknowledgment, restatement of the question, and summary of the search process can delay the part the caller needs while adding little meaning.

Include a condition in the same unit when omitting it would make the answer false or unsafe. "You can return it" is incomplete if the actual policy applies only to unopened items within an allowed period.

Optional background can wait. The controller can offer detail, invite a follow-up, or answer the next question after the caller has understood the present decision.

The sentence boundary guide explains why streaming output needs meaningful boundaries. A technical packet boundary is not a good substitute for a unit that a listener can understand on its own.

A unit can contain more than one sentence. Conversely, a single sentence with several nested exceptions can be too much to process, so sentence count alone should not control output.

Use a local word budget as a testable engineering constraint, then validate its value for the task. The number in the reference fixture is a synthetic setting that bounds composition, not a recommended human attention limit.

The comparison table describes response strategies. A check means the strategy explicitly includes the property; a cross means the property is absent or needs another mechanism.

Avoid turning "answer first" into "answer without context." If the evidence supports only a conditional or uncertain response, that limitation is part of the first useful answer.

A failure at the support gate should produce clarification or a truthful limitation. It should not send an unsupported sentence to speech merely because the voice model can say it fluently.

Run a supported-unit planner

Save the entire fence as spoken_units.py and run it with Python 3.11 or later. The reference uses a tiny approved-claim catalog and exact wording so its composition guarantee can be verified without a language model.

The trusted adapter supplies current evidence identifiers and approved claims. Approval must include all material conditions; the program does not infer missing exceptions from source text or verify an account's permissions.

A unit is immutable and belongs to one response generation. The final gate checks generation and terminal cancellation; a real adapter must also check source freshness and authorization at its protected boundary.

from dataclasses import dataclass, FrozenInstanceError


@dataclass(frozen=True)
class Claim:
    key: str
    text: str
    sources: tuple

    def __post_init__(self):
        if any(type(v) is not str or not v for v in (self.key, self.text)):
            raise ValueError("claim strings required")
        if type(self.sources) is not tuple or not self.sources:
            raise ValueError("immutable evidence references required")
        if any(type(v) is not str or not v for v in self.sources):
            raise ValueError("invalid evidence reference")


@dataclass(frozen=True)
class Unit:
    generation: int
    text: str
    claim_keys: tuple
    sources: tuple


def plan(claims, evidence, generation, max_words):
    if type(generation) is not int or generation < 0:
        raise ValueError("invalid generation")
    if type(max_words) is not int or max_words < 1:
        raise ValueError("positive word budget required")
    claims = tuple(claims)
    if not claims or any(type(c) is not Claim for c in claims):
        raise ValueError("approved claims required")
    if len({c.key for c in claims}) != len(claims):
        raise ValueError("duplicate claim identity")
    evidence = frozenset(evidence)
    if any(not set(c.sources) <= evidence for c in claims):
        raise ValueError("missing supporting evidence")
    text = " ".join(c.text for c in claims)
    if len(text.split()) > max_words:
        raise ValueError("split at a reviewed semantic boundary")
    return Unit(generation, text, tuple(c.key for c in claims),
                tuple(sorted({s for c in claims for s in c.sources})))


def admit(unit, generation, canceled):
    if canceled:
        return "canceled", None
    if unit.generation != generation:
        return "stale", None
    return "ready", unit.text


def tests():
    claims = [Claim("return", "Unopened items may be eligible.",
                    ("synthetic-policy-v1",))]
    evidence = {"synthetic-policy-v1"}
    unit = plan(claims, evidence, 0, 20)
    claims.clear()
    evidence.clear()
    assert unit.text == "Unopened items may be eligible."
    assert unit.sources == ("synthetic-policy-v1",)
    assert admit(unit, 0, False) == ("ready", unit.text)
    assert admit(unit, 1, False) == ("stale", None)
    assert admit(unit, 0, True) == ("canceled", None)
    assert admit(unit, 0, True) == ("canceled", None)
    try:
        unit.text = "Opened items are eligible."
        raise AssertionError("unit was writable")
    except FrozenInstanceError:
        pass
    for bad in (
        lambda: plan([], {"s"}, 0, 20),
        lambda: plan([Claim("a", "Answer.", ("s",))], set(), 0, 20),
        lambda: plan([Claim("a", "Too many words.", ("s",))], {"s"}, 0, 2),
        lambda: plan([Claim("a", "Answer.", ("s",))] * 2, {"s"}, 0, 20),
        lambda: Claim("a", "Answer.", ["s"]),
    ):
        try:
            bad()
            raise AssertionError("invalid plan accepted")
        except ValueError:
            pass
    print("synthetic spoken-unit fixtures passed")


if __name__ == "__main__":
    tests()

Python's dataclasses documentation explains the frozen record mechanism. The program also copies the caller's collections into immutable values, because freezing an outer record would not protect a retained mutable list.

The budget failure asks for a reviewed semantic split. Automatically cutting at the last allowed word can detach a condition from its answer, so the program refuses that shortcut.

A production paraphraser can sit before this planner. Its output still needs the same approval contract, and adding one does not expand the tested guarantees of this exact reference program.

Preserve conditions and references

A concise answer must preserve the conditions that determine its meaning. Deleting an exception to make speech shorter can turn an accurate source into an inaccurate response.

Find the smallest self-contained claim. It should identify the thing being discussed, the supported answer, and the condition that would change that answer.

Avoid pronouns when several referents are active. "It is available" can refer to an item, an appointment, a refund method, or the service itself, depending on which phrase the listener remembers.

Repeat a short noun when it prevents ambiguity. A little repetition in speech can be more useful than elegant prose that forces the caller to infer which earlier object a pronoun describes.

Numbers need explicit units and context. A bare "fifteen" can describe minutes, days, money, or quantity, and the correct reading depends on the task rather than the string's characters alone.

Dates need a similarly clear interpretation. Use the task's date and locale policy, then speak the value in a way that avoids confusing month and day where that ambiguity matters.

The multilingual task evaluation guide helps test canonical values and spoken forms separately. Do not let translation change an identifier or remove the condition that made the claim valid.

For a long list, ask which dimension the caller needs or group items around a useful decision. Reading every search result title can sound complete while leaving the listener without a usable answer.

For a procedure, deliver one actionable step and wait for the relevant observation when the next step depends on it. If a safety condition applies before the step, place it before the action rather than after the listener may already have acted.

An instruction to "check the second option" is fragile without a stable label. Prefer the option's meaningful name or a concise distinguishing property, and verify that the label remains valid after a correction.

Handle interruption without stale replay

Interruption changes the response plan. The caller may ask for clarification, withdraw the question, correct a fact, or move to another task, and these require different recovery behavior.

Attach a response generation to prepared spoken units. Canceling that generation makes its queued units ineligible, including units that were already approved for grounding before the interruption.

The interruption-safe output guide covers generation ownership. The resumption policy guide explains why continuing, summarizing, and restarting are different decisions.

Keep a distinction between text planned, audio generated, audio submitted, and provider playback evidence. A generated second sentence does not mean the caller heard the first sentence or understood its condition.

Twilio's public Media Streams message contract describes mark and clear behavior for bidirectional streams. Use the actual transport semantics when interpreting acknowledgments, especially around cleared buffered audio.

Do not infer acoustic comprehension from a mark. A transport event describes its documented boundary; listening evaluation still needs a separate observation.

A caller who asks "Which item?" may need a referent clarification rather than a replay of the whole paragraph. Rebuild the next unit from the current question and evidence instead of resuming at a raw text offset.

A caller who corrects "opened" to "unopened" changes the factual conditions. Invalidate dependent retrieval and prepared speech, then use the corrected accepted fields for the next plan.

The reference admit function checks current cancellation every time. An exact retry stays canceled rather than restoring an old ready result from a cached planning outcome.

Review pronunciation and accessibility

Correct text can produce confusing speech. Abbreviations, product codes, mixed-language names, decimal separators, and punctuation can all require a presentation decision.

W3C's SSML 1.1 specification defines speech-oriented markup such as sentences, paragraphs, pronunciation controls, and breaks. Actual provider support varies, so verify the subset your synthesis adapter implements.

Keep canonical values outside presentation markup. A pronunciation hint should change how a value is spoken without changing the source identifier used for retrieval or business logic.

Test markup escaping at the adapter boundary. Retrieved text should not become executable or structural speech markup merely because it contains angle brackets or resembles a supported tag.

Do not solve every ambiguity by slowing the voice. Rate changes cannot repair a missing referent, an omitted condition, or a number whose units were never stated.

Offer repetition and rephrasing as separate actions. Repetition helps when the caller missed the sound, while rephrasing helps when they heard the words but did not understand the explanation.

Preserve an accessible alternative channel where the product supports one. A long identifier or address may be easier to verify in text, but sending it still requires the appropriate destination and permission checks.

The mobile voice latency guide shows why playback conditions matter. Test listening on representative devices and environments without claiming that a desktop text review establishes real call usability.

Background noise and hearing needs can change what is followable. Include intended listeners in evaluation, collect only necessary information, and keep individual accessibility observations separate from unsupported generalizations about an entire audience.

Build a listening evaluation

A listening evaluation needs a task and an answer key. Prepare a small corpus of synthetic questions with evidence, approved claims, required conditions, and the action a listener should be able to take.

Include straightforward answers and difficult cases. Useful fixtures cover negation, multiple referents, changing dates, conditional eligibility, mixed-language identifiers, and a caller interruption after the first unit.

Use a rubric with separate dimensions instead of one unexplained quality score. Accuracy asks whether the claim matches evidence; clarity asks whether the listener can resolve its objects and conditions; recovery asks whether the next response fits the interruption.

For pronunciation, identify the critical value before listening. A pleasant voice that misreads the one character needed for the task should fail that field even if the surrounding explanation sounds natural.

Ask reviewers concrete questions. What answer did you hear, which condition applies, what remains unknown, and what should happen next are more inspectable than a request to rate whether the agent sounded intelligent.

Preserve disagreement. If reviewers infer different referents from the same sentence, that is useful evidence of ambiguity rather than noise to average away.

Keep the evidence bundle available to a separate factual reviewer. A listener should not need to study the source passage first, since that would provide context the caller never received.

The voice regression guide describes controlled replay. Freeze the question, evidence version, approved claim, synthesis settings, and interruption point when comparing response changes.

This article provides a protocol rather than completed listener results. Do not present the rubric's categories or synthetic fixture settings as measured human performance.

Diagnose retrieval-to-speech failures

Work backward from the observable failure. If the caller repeats the question, inspect whether the first unit answered it, whether the source supported that answer, and whether the audio reached the documented playback boundary.

A correct search result with an incorrect paraphrase is an answer-construction problem. A correct paraphrase with a confusing referent is a presentation problem, and a current answer followed by old audio is an invalidation problem.

The playback evidence guide helps separate transport observations. The voice observability guide explains why those observations should remain distinct in traces.

Keep a claim identifier on each unit. That lets a reviewer connect a troublesome spoken phrase to the approved wording and evidence without guessing which retrieved chunk supplied it.

Record the unit's generation and disposition. A canceled unit should remain canceled in later traces, even if its audio generation completed successfully after the caller moved on.

Trace output queue age separately from retrieval time. A fast retriever can still produce a delayed answer when earlier units remain buffered, as the audio backpressure guide explains.

Measure the correction-to-useful-answer interval when evaluating recovery. Reporting only the first audio byte from the abandoned response can make a poor interrupted experience look fast.

The latency benchmark guide provides the measurement boundary framework. Include unanswerable questions and clarification outcomes so a system cannot appear better by excluding hard requests.

Connect the contract to live output

The reference program ends before synthesis and transport. Connect it to a real adapter by carrying the response generation, approved claim identities, source versions, and current authorization through every asynchronous step.

The Python asyncio documentation explains the task and cancellation mechanics, but application state must still be rechecked after waiting. Cancellation requests and current eligibility are separate facts.

After synthesis completes, compare the unit's generation with the active response. Before local media submission, recheck age and any clear barrier required by the transport; a later await creates another boundary that needs a check.

Do not make a stale old unit's failure cancel a new response. Compare identity before applying side effects, and target cancellation at the exact generation that expired or was superseded.

Output admission must preserve a required condition with its claim. If your chunker can split a condition away from the first sentence, revise the approved unit or enforce a semantic boundary in the adapter.

A unit budget also needs an overflow policy. The reference refuses oversized composition; an application can ask a reviewed planner to split the claim or provide an authorized alternative channel.

Keep optional detail optional. A caller who already has the needed answer should be able to continue the task without waiting through every related passage the retriever found.

For business actions, a spoken explanation does not replace confirmation or authorization. The workflow enforcement guide separates what the assistant says from the authority needed to perform the requested change.

Design a replay that exposes listening failures

A useful speech replay preserves the order in which a caller receives information. Reviewing the final transcript alone can conceal a condition that arrived too late to prevent a misunderstanding.

Create a fixture with an answer and a required exception. Mark the earliest point at which the spoken answer becomes self-contained, then interrupt before and after that point to see whether recovery preserves the correct meaning.

Do not choose the interruption point solely by character count. A natural pause, completed noun phrase, or explicit caller question gives you a more meaningful test of the response plan.

For a date question, include two active dates in the evidence. Ask the listener which date the agent meant when it says "that day," and fail the clarity dimension if the answer depends on guessing.

For a conditional policy, ask the listener to identify the condition that would change eligibility. If the listener repeats the headline answer while missing the condition, inspect the unit's ordering and wording before changing the voice.

For an identifier, preserve the canonical value and the intended spoken form separately. A transcript can show the correct characters while the rendered audio uses an ambiguous pronunciation or omits the distinguishing suffix.

For a long procedure, ask the listener to perform the next safe step using only the audio they have heard so far. This reveals whether the system requires them to remember later instructions before they can interpret the first one.

Keep the task harmless and synthetic. The purpose is to expose response-structure failures, not to create a realistic emergency or to ask a reviewer to perform a risky action.

Replay a correction after the evidence was approved. The next response must use the current accepted fields, and every unit prepared under the earlier question must retain its stale or canceled disposition.

The planner's immutable records prevent caller-side mutation of approved wording, but they do not establish a complete conversation controller. Your adapter suite must prove that the correct current generation reaches the admission function.

A useful negative fixture deliberately passes the previous generation after a new one begins. Assert that the adapter withholds its text and audio, not merely that a later correct answer eventually appears.

Test a held unit that expires while output is blocked. This is a distinct boundary from interruption: the caller may say nothing while synthesis or transport waiting makes a once-eligible unit too old for the task.

If the adapter checks age before waiting and never checks again, the fixture should fail. Add the final check after the wait and preserve the failing-before and passing-after evidence in the adapter's own tests.

Keep equality rules explicit. Two units with the same creation timestamp may still need deterministic ordering, while a later-arriving older unit must not be treated as new just because the queue was recently drained.

Generation-wide ordering history belongs to the generation, not to the current queue length. Draining the last item should not reset the history that protects against an older same-generation arrival.

That queue rule is outside the small planner's implementation. Mentioning it here identifies the adapter responsibility; it does not claim the published planner already enforces media ordering.

For source support, ask a factual reviewer to identify the exact passage behind each approved claim. If one sentence depends on several sources, record which part each source supports and whether their conditions are compatible.

Combining two individually correct passages can create an unsupported conclusion. A public eligibility rule and an unrelated account status do not prove that this caller satisfies the rule unless the relevant relationship is established.

Keep uncertainty in the spoken unit when evidence is incomplete. A direct answer can be "I cannot confirm that status from the available record" when that is the supported conclusion for the task.

Avoid a confident preamble followed by a quiet disclaimer. Listeners can act on the first clear claim, so put the uncertainty or required condition where it changes interpretation.

A useful review compares the intended answer with the listener's reconstruction. Store both separately, along with the evidence version and unit text, so an evaluator can distinguish factual disagreement from a presentation failure.

Do not infer comprehension from conversational politeness. A caller's "okay" can acknowledge the sound, accept a proposed next step, or simply keep the conversation moving, depending on context.

The backchannel guide explains why brief acknowledgments need contextual handling. The confirmation repair guide shows why a positive word followed by a correction cannot be treated as completed agreement.

For multilingual review, preserve the same task and critical fields across language variants while allowing natural wording. Literal translation can produce awkward speech, and free adaptation can accidentally change a required condition.

Record the reviewer's language competence and the evaluation boundary when reporting results. A small convenience sample is useful for finding defects but does not establish performance for every accent, locale, or accessibility need.

When an answer fails, change one cause at a time. Shorten an unnecessary preamble, replace an ambiguous pronoun, or move a required condition earlier, then replay the same fixture before broadening the change.

This produces a reviewable relationship between edit and outcome. Replacing the retriever, prompt, voice, chunker, and interruption policy together makes it difficult to know which change repaired the listening problem.

Keep the rejected version in the test bundle when it captures a useful failure. A future rewrite should have to preserve the condition or reference that the old response lost, even if the new wording sounds more polished.

Finally, evaluate the handoff out of the answer. The caller should know whether the agent is waiting for a response, offering optional detail, or taking a separately authorized action, because an accurate explanation can still leave the conversation in an unclear state.

A final review should inspect the transition between units as well as each unit alone. An individually clear sentence can become confusing when it answers a different interpretation from the sentence that preceded it.

Keep the accepted question revision in the review bundle so that transition can be checked. If a correction occurred between units, the next sentence should acknowledge or reflect the revised question rather than continuing an obsolete explanation.

For operational handoff, state whether the adapter submits one approved unit at a time or can prebuffer several units. That choice affects how much stale speech can remain after interruption and which clear barrier must complete before new-generation audio is admitted.

The review is complete only for the boundaries observed. A browser replay can establish controller behavior, while representative devices and real transport tests are still needed for claims about physical listening conditions.

Keep the review artifact close to the approved claim catalog. A future editor should be able to see which condition made a sentence acceptable and which listening failure the current wording repaired.

When wording changes, rerun the critical-value and referent fixtures even if the evidence source did not change. A shorter paraphrase can preserve the topic while losing the unit, negation, or noun that made the original sentence usable.

For generated audio, retain the settings needed to reproduce the pronunciation decision under the provider's supported contract. A text-only approval cannot establish how a particular voice rendered an identifier, and a later provider update can require another listening review without changing the source passage.

---

Frequently asked questions

What makes retrieval for speech different?

A spoken answer arrives as a sequence that the listener cannot scan like a document. The response needs clear references, supported units, necessary conditions, and recovery behavior, while retrieval relevance remains only one part of the task.

Should the agent read source passages verbatim?

Verbatim reading can preserve wording but can also include dense structure and irrelevant context. Use it when exact wording matters, and otherwise approve a speakable claim that retains the source's material conditions.

How long should the first answer be?

The first unit should contain the useful supported answer and any condition needed to keep it true. Choose a local budget for your task, then validate it with listeners instead of treating a universal word or sentence count as a comprehension rule.

Can a summary be too short?

A summary is too short when it removes a condition, referent, unit, or uncertainty needed for the task. Concision should reduce unnecessary material while preserving the information that changes the answer.

Does a citation prove a spoken claim?

A citation proves only that a source was referenced unless the relevant passage supports the claim. Keep claim-level evidence and source versions so a reviewer can inspect the connection rather than trusting a plausible-looking link.

Why does the reference use approved wording?

Exact approved wording makes the composition guarantee small and testable. A free-form paraphraser needs a separate grounding review, and the reference does not claim to prove natural-language entailment automatically.

Can I add a model before the planner?

A model can propose a spoken claim or a split into units. Its output still needs approval against eligible evidence and material conditions before the deterministic planner can treat it as supported wording.

Why keep evidence outside the spoken text?

Source identifiers and URLs can be necessary for review without helping the caller understand the answer. Preserve them in the evidence record and offer a suitable source channel when useful and authorized.

How should numbers be spoken?

Speak the value with its task-relevant unit and disambiguating context. Keep the canonical value separate from pronunciation choices, and test critical numbers and identifiers with the actual synthesis adapter.

What should happen after interruption?

Cancel the old response generation and interpret the caller's new intent. Clarification, correction, and a new task need different next units, so rebuild from current state rather than blindly resuming a text offset.

Can a cached plan restore canceled audio?

A cached plan cannot reactivate a canceled generation under this contract. The controller can create a separately authorized new response, while retries of the old generation continue to return a canceled disposition.

Do playback marks prove understanding?

Playback marks describe the transport's documented boundary. They do not establish acoustic audibility, attention, comprehension, or agreement, so listening outcomes and business confirmation require separate evidence.

Is SSML enough to make answers clear?

SSML can control supported presentation details such as pauses and pronunciation. It cannot repair an unsupported claim, an omitted condition, or a confusing reference that was already present in the approved text.

How should long procedures be handled?

Break procedures at meaningful task boundaries, especially when the next step depends on an observation. Put necessary safety conditions before the action and wait for the caller's relevant response rather than reading every step at once.

What belongs in a listening rubric?

Separate factual accuracy, referent clarity, critical-value pronunciation, and recovery after interruption. Ask reviewers what answer and condition they understood, then compare that observation with the task's approved evidence.

Should reviewers read the source first?

A factual reviewer needs the evidence, while a listening reviewer should encounter the answer as the caller would. Giving listeners the source in advance can hide missing context or ambiguity in the spoken response.

How do I compare two response versions?

Replay the same questions, evidence versions, synthesis settings, and interruption points. Preserve individual disagreements and failed critical fields instead of collapsing every dimension into one unexplained average.

What does the sample program verify?

It verifies immutable supported units, required evidence references, unique claim identities, a local word budget, and generation cancellation decisions. It does not verify source truth, authentication, physical playback, or human comprehension.

Can the agent offer more detail later?

Optional detail can follow after the first useful answer or after the caller requests it. Keep the necessary exception with the initial claim so deferring detail does not make the first answer misleading.

Where should a team begin?

Choose one common question, identify its evidence and required condition, and approve one spoken unit. Run the reference fixtures, listen on the intended channel, and add an interruption where a caller would ask for clarification.

Validate one answer end to end

Take one evidence-backed answer through claim approval, unit planning, synthesis, transport admission, and a listening review. Preserve the source version and every generation decision so a failure can be located at the boundary that caused it.

Use the resulting fixture as the first regression case for retrieval-to-speech behavior. Expand the corpus when the task introduces another real condition, language, interruption pattern, or critical value that the original case did not cover.