August 19, 2026
Our last two posts covered what breaks — real incidents like McDonald's drive-thru pilot and the Air Canada tribunal case, and the technical failure points inside a live voice pipeline. This post is about the fix, and it's more structural than most teams expect: the problem isn't that language models occasionally get things wrong. It's that most systems never built anything to catch it when they do.
The Wrapper Paradigm Is the Root Cause
Almost every documented enterprise voice AI failure traces back to the same architectural choice: a single probabilistic model handling the entire interaction; interpreting noisy audio, tracking conversation state, deciding on business logic, and generating the spoken response, all in one pass. Language models are built to predict a statistically likely continuation of text, not to execute deterministic rules. Asking one model to do both jobs at once means there's no independent check on its output before that output becomes a confirmed order, a quoted policy, or a committed transaction.
The fix is separation, not better prompting: keep the probabilistic layer responsible for what it's actually good at (parsing messy, accented, ungrammatical human speech into structured intent) and hand everything downstream of that (routing, business rules, database writes) to a deterministic layer that isn't guessing.
Sanity Layers: Where Business Rules Actually Belong
A sanity layer sits between the model's output and the systems it can affect, and it operates on a simple principle: nothing reaches a backend system unless it passes explicit validation. In practice that looks like hard numerical ceilings on things like order quantities, so a misheard request for "a hundred nuggets" gets capped and confirmed rather than processed as-is; rule-based checks that flag incompatible combinations before they're ever submitted; and strict isolation between the model and any system of record, so the model can propose an action but never directly execute a database write. Every one of the headline AI failures, from the absurd drive-thru orders, the fabricated policy at Air Canada, is exactly the kind of output a sanity layer is designed to intercept before it reaches a customer.
Structured Output and Sub-Agent Design
The second half of the fix is constraining what the model is allowed to say in the first place. Instead of free-form text, the model is required to return strictly typed output — if a task needs a customer ID, a date, and a product code, the system won't proceed until all three pass validation. Layered on top of that, a single generalist model gets replaced with a set of narrow, specialized sub-agents, each handling one part of the interaction — scheduling, lookup, confirmation — under a hyper-focused prompt limited to that one job. Narrowing the scope of what any single model call is responsible for is one of the most effective levers for reducing hallucination rates, simply because there's less room for the model to guess.
Speed Without Cutting Corners
None of this works if it comes at the cost of the latency budget covered in the last post. The practical answer is to overlap the pipeline stages rather than running them in sequence: streaming partial results from speech-to-text into the language model as they arrive, and streaming the model's early output straight to speech synthesis rather than waiting for a complete response. Short acknowledgment phrases can mask the time needed for a backend lookup, and predicting likely responses before the caller finishes speaking cuts perceived latency further. None of these techniques trade accuracy for speed — they're about removing dead time between stages that are already running correctly.
Wrapper vs. Deterministic, Side by Side
This Is the Architecture Behind AZcall
This isn't a theoretical framework for us; it's the design principle behind AZcall's own Real-Time Context Management and Dynamic Language System (DLS), which we cover in detail in our architecture deep dive. In our own benchmarking simulations, this approach took task completion from 64.2% under a monolithic, wrapper-style setup to 98.4%, while cutting hallucination rate from 8.4% to 0.2% — without giving up the sub-second response time a live call requires. The failure patterns in this series aren't hypothetical risks we're guarding against; they're the specific problems this architecture was built to solve.
Talk to Us
If you'd like the full technical walkthrough, including how AZcall's sanity layers and sub-agent design map to the concepts in this post, we're happy to set up a briefing.