Two customers write in on the same morning. “Can I get my money back on this?” Is a refund question your team settled long ago. “Can I get my money back on this gift card?” Reads almost the same, and needs a different answer, because gift cards get store credit, not cash.
Anything that answers from resemblance treats the two as one. The second customer gets the refund policy, delivered with the same confidence as the first, and nothing flags it, because nothing looked wrong. A slow right answer costs you a minute. A confident wrong one goes out with your name on it, and you hear about it from the complaint, or you never hear about it at all.
Duplex knows what it knows. It answers what it has learned, however the request is worded, and it can tell when a request only looks familiar. That one goes to your AI, briefed with what Duplex knows about the case. The line between the two is where the risk lives, and Duplex draws it far more sharply than a cache.
A request Duplex has learned is answered at once.
Look-alikes are the hard case.
Requests come in more kinds than familiar and new. Some repeat a case your team has settled, word for word. Some are the same case in new words: “I’d like a refund on this, please.” Some only look familiar, like the gift card: the same subject, most of the same words, and one difference that changes the answer. Further out sit requests that are plainly new, such as a refund for an order split in two, and some from another field entirely.
The two ends are easy. An exact repeat can be answered the way it was decided before, and a request from another field is easy to set aside. The risk sits in the middle, where a request is close enough to pass for familiar and different enough that the old answer is wrong. That middle matters more every year, because more answers now turn straight into actions: when an agent acts on a look-alike, the wrong answer becomes a wrong refund, and nobody reads it first.
The usual tools each do part of the job well. A hand-written rule is precise about what it names: it catches “gift card” and misses “voucher”. A cache answers an exact repeat instantly, for almost nothing. Retrieval goes further and finds what looks similar, which gives your AI useful context. All three go by the surface of a request, so the look-alike gets the old answer, served with the same confidence as the real repeat.
Duplex learns what a decision depends on, as well as the words it arrived in. So it answers the same request in new words, and it notices when a familiar-looking request differs in the way that matters. “I’d like a refund on this, please” is answered at once, and the gift card goes to your AI. Scored out of 1 for telling familiar from new, Duplex reached 0.996 and a cache 0.930, a gap that looks small until you see where it falls: on the look-alikes.
Known requests on one side, new ones on the other: whoever answers must tell them apart.
Fewer wrong answers, because it hands over what is new.
The brain works with two systems: a slow one for general knowledge, and a fast one for each new experience. Your AI is the slow one, and Duplex is the fast one. The pairing works only if the fast one knows where its knowledge ends. A request Duplex has learned is answered at once, with no model call. A request that is new, or only looks familiar, goes to your AI, briefed with what Duplex knows about the case, so the model starts from your team’s context rather than from nothing.
Across ten runs, Duplex was wrong on 7.5% of misleading look-alikes. A cache, on the same requests, was wrong 45.3% of the time, about six times as often. And Duplex didn’t buy that safety by turning work away: it answered 95.78% of the known requests itself, and at every confidence setting it handled more of the known work and made fewer unsafe guesses on new work.
Count a correct hand-off to your AI as what it is, the right call, and Duplex handled 98.98% of all requests correctly. In production, that is the number to watch: how often each request ends up with whoever should answer it, rather than how often a system is willing to answer. A system that answers everything scores well on willingness and badly on trust.
That changes how far you can let it run. A system that guesses has to be watched on everything, because any answer might be the wrong one. A system that knows its limits can be given the familiar work outright, with your AI taking what is new. It is the difference between a new hire whose every reply you check and a colleague you trust with the routine, who checks with you when a case is unfamiliar.
And the edge moves. Every result your team confirms on a new case teaches Duplex that case, so the next request like it is answered on the near side, in milliseconds. Your AI keeps the work it does best, the new and the hard, and fewer confident wrong answers go out with your name on them. A system that knows what it knows can be trusted with a little more every week.
On misleading look-alikes, a cache served the stored answer and was wrong 45.3% of the time.