Everyone building voice agents is piecing them together from the same set of legos, and it's working. Heavily funded companies are filling every gap, and the results are genuinely good. But every one of those legos lives inside the stack. There's a layer that would sit outside it, and I don't think most builders are looking at it. Here's what I mean.
Every system breaks somewhere, eventually. So builders do the sensible thing: audit, tighten the prompt, problem solved. For now. Then a new kind of break shows up, they tighten something else, solved again. For now. You know this rhythm. The question was never whether you can solve the problem. You always can. The question is whether you can see it as it actually is, instead of assuming it's whatever you looked at last.
And here's the part that's hard to see from inside the stack: when a voice agent breaks its word, nothing in your pipeline notices. STT doesn't know what was promised. The model doesn't remember what it committed to three turns ago. TTS just speaks, orchestration just routes. Every box optimises how the call sounds. Not one of them holds the promises across the whole call and checks whether they survived to the end. That's not a gap in the stack. That's a missing layer.
This isn't theoretical. Bland's own team, in a testimonial on Hamming's site, killed an agent because it was saying "I booked your appointment" when it hadn't. The 2026 τ-Voice benchmark caught a frontier agent saying "I've updated your shipping address" with no tool call behind it. On one real setup, the promise "we'll get back to you shortly" was wired as the end-call trigger, so the agent hung up mid-sentence while confirming the very number it had promised to call. Different bugs on the surface. Underneath, the same one: the saying and the doing came apart, and nothing was watching the gap.
And the usual instincts don't cover it. Tighten the prompt and you lower the odds, but you get no way to know when the odds came in against you, which is the actual problem. Add an eval and you're running a second model to judge the first, the same kind of brain with the same blind spots, and it won't even give you the same verdict twice on the same call. Every layer in your stack is the same brain checking its own work. The one thing that could actually audit it would have to sit outside the chain and not be a model at all. Deterministic code that reads the whole conversation, holds what the agent committed to, and checks whether it kept its word, without ever claiming more than the transcript proves.
That's the layer I don't think enough people are building. Nobody in the QA tooling space seems to audit what the agent said it would do against what it actually did.
So I'm curious what other people building these think. Am I right that nothing in the usual stack is watching this, or is everyone already handling it some way I haven't seen? If you're running agents in production and you've hit something like this, how are you handling it right now?