Readback Confirmation

Aviation and emergency dispatch solved this decades ago with mandatory readback: the receiver repeats the instruction, the sender confirms. Voice agents need the same discipline, applied selectively to the values where an error actually costs something.

Speak values in disambiguated form

Reading a value back in its natural form does not help — if the system heard "fifty" and says "fifty", a user who said "fifteen" often will not catch it. Speak digits individually, letters with a phonetic alphabet, and amounts with explicit units. The unnatural phrasing is the point: it forces the difference into the acoustic signal.

NATO = {"a": "alpha", "b": "bravo", "c": "charlie", "d": "delta", "e": "echo",
        "f": "foxtrot", "g": "golf", "h": "hotel", "i": "india", "j": "juliet"}  # ...


def for_readback(value: str, kind: str) -> str:
    if kind == "digits":
        # "4471" -> "four, four, seven, one" — never "four thousand …"
        return ", ".join(value)
    if kind == "alphanumeric":
        return ", ".join(NATO.get(c.lower(), c) if c.isalpha() else c for c in value)
    if kind == "money":
        d, c = divmod(int(value), 100)
        return f"{d} dollars and {c} cents" if c else f"{d} dollars exactly"
    if kind == "date":
        return parse(value).strftime("%A, %B %-d, %Y")   # weekday catches off-by-one
    return value

Require an unambiguous affirmative

"Okay" is not confirmation — it is acknowledgement, and users say it while thinking. Accept a clear affirmative set, treat a clear negative as a correction, and treat anything else as unclear and re-ask. Critically, when the user corrects, capture the new value and confirm that one; do not assume the correction succeeded.

AFFIRM = {"yes", "yeah", "yep", "correct", "that's right", "right", "confirmed"}
DENY = {"no", "nope", "wrong", "incorrect", "that's not right"}


async def confirm(self, label: str, value: str, kind: str, attempt: int = 1) -> str | None:
    spoken = for_readback(value, kind)
    reply = (await self.ask(f"I have your {label} as {spoken}. Is that correct?")).lower().strip(" .")

    if any(a in reply for a in AFFIRM):
        return value

    if any(d in reply for d in DENY) or attempt >= 2:
        if attempt >= 2:
            return await self.escalate_capture(label, kind)   # spell / keypad / human
        corrected = await self.ask(f"Sorry — what is the correct {label}?")
        return await self.confirm(label, normalize(corrected, kind), kind, attempt + 1)

    return await self.confirm(label, value, kind, attempt + 1)   # unclear: re-ask

Escalate the channel, do not repeat the question

Asking the same question a third time in the same way will fail the same way — the acoustics, the accent, or the noise floor that caused the first two failures have not changed. Change the channel instead: ask the user to spell it, collect digits via keypad tones where the transport supports it, or hand to a human. Each escalation has a much higher success rate than another attempt at the original method.

async def escalate_capture(self, label: str, kind: str) -> str | None:
    if kind in ("digits", "money") and self.transport.supports_dtmf:
        await self.speak(f"Let's try the keypad. Enter your {label}, then press pound.")
        return await self.collect_dtmf(terminator="#", timeout_s=20)

    if kind == "alphanumeric":
        await self.speak(f"Could you spell your {label} one letter at a time?")
        return normalize(await self.listen(mode="spelling"), kind)

    await self.speak("Let me get someone who can help with this.")
    return await self.transfer_to_human(reason=f"capture_failed:{label}")

• Confirm only what drives consequential action; confirming everything trains people to stop listening
• Read back in disambiguated form — individual digits, phonetic letters, weekday-bearing dates
• Require a clear affirmative; treat "okay" and silence as unclear, not as yes
• After two failures, change the capture channel rather than asking again
• Log every confirmation turn — it is your consent record and your STT error dataset