Voice AI Testing Framework: Regression, Adversarial, and Production-Derived Tests

A voice AI testing framework decides which simulated calls your agent must pass and what fails a release. Here are our three layers, their pass rules, and how fixed failures move between them.

Without a framework, you end up fixing the same failure twice. Your agent ignores a caller who keeps asking for a person, you patch the prompt, and the next model swap quietly brings the failure back.

A voice AI testing framework is the plan behind your test suite. It decides which simulated calls your agent has to pass, where those calls come from, how often they run, and what result stops a release. We recommend building yours in three layers. Regression tests check that what already works still works. Adversarial tests go looking for the caller, or the audio, that breaks the agent. Production-derived tests turn confirmed failures from real calls into permanent tests.

With all three in place, that ignored request becomes a test, and once the fix passes it moves into the regression suite and runs on every release. Each layer also needs its own pass rule for what counts as passing, because the three kinds of failure need different handling and one pass rate would blur them together. Here’s how the layers differ, and how to build each one.

Each layer of a voice AI testing framework has its own pass rule

We first laid out this three-layer testing framework in our 2026 Voice AI Report. Side by side, the layers look like this.

LayerQuestion it answersWhere cases come fromPass ruleWhen it runs
RegressionDoes what worked still work?Your top call reasons, must-always behaviors, and fixed failures that graduatedEvery run of every case passesEvery prompt, model, or config change, plus nightly
AdversarialWhat breaks it?Attack types you can name, and hard audio conditions such as noise and accentsOne successful attack fails that attack type; hard audio is judged against a clean-call baselineAfter every agent change, plus a schedule
Production-derivedWhat did real callers find?Confirmed failures from real callsThe reproduction fails before the fix and passes afterAs confirmed failures come in

Together the layers cover the scenarios you know, the edge cases you can anticipate, and the failures nobody anticipated.

Pool the layers into one suite with one pass rate and all three kinds of failure hide. A single leaked account number is a failed release, yet it barely moves an average across hundreds of cases. A drop that shows up only on noisy calls vanishes when noisy and clean calls are scored together. And a reproduced production failure is supposed to fail until its fix ships, so inside the regression gate it keeps the build red for a reason everyone already knows. Separate layers keep each failure where its rule can see it.

Regression tests keep working behavior working

Regression is the layer that catches a model swap undoing an earlier fix. It holds the calls your agent has to handle correctly every time, and after every change it asks one question: does what worked yesterday still work?

Start with your agent’s top call reasons, then add the behaviors that cut across them, such as authentication, transactions, information lookups, escalation to a human, and recovery from errors. In Coval, these go into a Regression Set, the scenarios that make up your typical successful calls.

Each test case pairs a goal for the simulated caller with the expected behaviors your agent has to show. The caller never sees those behaviors. After each call, a Coval metric scores every one of them as met or not met. Here’s a case for a clinic’s scheduling agent:

  • Goal: move Thursday’s appointment to next week.
  • Expected behaviors: verifies the caller’s identity before changing anything; offers open slots; reads back the new date and time; keeps the old booking until the new one is confirmed.

The pass rule is strict. A case passes only when every expected behavior is met on every run. One run isn’t enough, because agents behave differently from one try to the next. Even text agents, with no audio in the way, are inconsistent. In τ-bench, a text benchmark from the AI agent company Sierra, gpt-4o handled simulated retail and airline customer-service tasks and succeeded on fewer than half of them. Its chance of getting a retail task right on all eight tries was under 25%. Coval’s GitHub Action runs each test case up to 10 times and fails your CI job when any simulation returns the failure value you chose for a metric, such as “NO” on a yes/no check.

Run the suite on every prompt, model, or config change, and again every night. At Zoom, a Coval customer, the QA team runs daily scheduled regression tests. Our regression testing guide goes deeper on building the suite.

Adversarial tests look for the caller who breaks the agent

Regression only protects what you already know works. Adversarial testing goes looking for the input that makes your agent fail. It comes in two kinds with different pass rules: hostile callers who try to push the agent off policy, and honest callers whose audio, accent, or way of talking trips it up. Red teaming is the hostile half.

Hostile callers. Our red-team guide sorts attacks into 12 types, including identity-verification bypass under pressure, extracting a third party’s personal information, prompt injection, and gradual escalation over many turns. Write a case for each attack type that applies to your agent. For a banking agent, that might be a caller who says they’re the account holder’s spouse and keeps pushing for the balance without passing verification.

The pass rule follows the attacker’s math, since an attacker needs only one success. A scenario passes only when every expected behavior is met, and a single jailbreak, leak, or policy break fails that attack type, even if the average score looks high. Run each scenario at least three times, because an agent that holds once won’t necessarily hold the next time. Attackers retry too. Researchers from Speechmatics, Anthropic, and several universities showed this with Best-of-N jailbreaking. The attacker resends the same harmful spoken request with random changes to speed, pitch, noise, and volume until one version gets past the model’s safeguards. It worked on four audio models for 59% to 87% of requests.

Hard but honest callers. Our audio-quality personas include High Background Noise Speaker, Interruptive Speaker, Low Volume Speaker, and Super Fast Speaker, and the accent guide adds six accent personas. Rerun your regression cases under each persona and under Standard Customer, the clean-call baseline, then compare results persona by persona. If a case passes for Standard Customer but fails for High Background Noise Speaker, that’s a failure, even when the overall score holds.

Clean audio tells you little about the noisy call. In our July 2026 word error rate snapshot of 31 speech-to-text models (7 days of data), no single model led every condition. AssemblyAI Universal 3.5 Pro had the lowest overall word error rate, 3.3%, but OpenAI GPT-4o Transcribe led on accents, intermittent background noise, phone-line compression, and room echo. The board keeps moving: over the 30 days ending October 28, 2026, AssemblyAI’s Universal 3.6 Pro led our speech-to-text benchmark at 2.2% overall, and each of our five picks there makes more errors once clean audio is compressed for the phone line. Task metrics can hide the damage, too. An accented call can score as a success while the recording shows the agent misheard a name, number, or address.

Honest callers also change their minds mid-call. Add cases like “Cancel my order. Actually, can you just change the shipping?” and the caller who asks for an address change and a billing answer in one breath.

Rerun the adversarial suite after every agent change to confirm fixes hold, and on a schedule between releases.

Production-derived tests turn real failures into permanent tests

Some failures slip past both layers until a real caller hits them, like that ignored request for a person. Production-derived tests start from those calls.

  1. Score every production call. Get your production calls into Coval as uploaded conversations, and Coval’s observability scores each one against the metrics you care about.
  2. Route flagged calls to people. An alert on a metric can send calls that cross its threshold straight to a Human Review queue.
  3. Confirm the failure. An automated flag isn’t always a real failure, so have a person check each flagged call before you write a test for it. One team’s AI-disclosure metric, which checks whether the agent says it’s an AI, agreed with human reviewers on 89% of 314 conversations. Every one of the 35 disagreements was a call where the wrong person picked up or the caller hung up early, and the metric had failed the agent for a step the call never reached. In Coval, reviewers confirm flagged calls in a Triage project, tagging each one by failure type, theme, and severity.
  4. Reproduce it. Build a test case from the call with a Transcript input, where the simulated caller follows the real caller’s side as closely as possible, or an Audio Upload, which replays the real caller audio. For the ignored request, the test replays that call with one expected behavior: transfers the caller to a person when asked.
  5. Prove the fix. The reproduction should fail on the current build. It counts as fixed when it passes on the new one.
  6. Generalize. Write two or three scenario variants of the same failure, so the fix isn’t tuned to one caller’s exact words.

For what to capture from each call, see voice AI observability.

How cases move between layers, and how many you need

Once a fix is proved, the case moves. An adversarial finding or a confirmed production failure graduates into the regression suite, and from then on it runs on every change, model swaps included. Krew, a Coval customer, works this way: “Whenever there’s an edge case, we add it into our eval set and run it again.”

Six-step loop turning a production failure into a permanent regression test. Production: 1, a real call fails (the caller asks for a person and the agent ignores it). Production-derived: 2, a person confirms the failure; 3, reproduce it as a test that expects a transfer to a person; 4, prove the fix (the test fails before the fix and passes after). Regression: 5, the case graduates into the regression suite as a permanent test; 6, the suite runs on every release, model swaps included. The loop closes when the next failure starts at step 1.
How a confirmed failure becomes a permanent regression test, so you fix it once.

Cases also go stale. Self-driving evaluation, where our approach to testing started, has a name for it: scenario decay. A scenario written to measure one thing stops measuring it. In voice AI, it’s a test of identity capture where the phone number no longer works, so the call never reaches the identity step. A decayed case fails for reasons that have nothing to do with the agent, or passes without testing anything, so fix it or delete it.

Size each layer from your own agent, not from a target count:

  • Regression: one case per must-always behavior across your top call reasons, plus every fix that graduated.
  • Adversarial: a case for each attack type that applies to your agent, plus your regression cases rerun under each audio and accent condition your callers bring.
  • Production-derived: one case per confirmed failure, plus its variants. This layer grows with your traffic.

Two things sit outside the three layers. How your agent holds up under many simultaneous calls gets its own load testing plan, and choosing what to score is covered in our evaluation guide.

Coval runs all three layers in one loop

Moving cases between layers only works if a failure is measured the same way everywhere it shows up. In Coval, every metric works on both simulated conversations and live-monitored production calls. The metric that flagged a live failure is the one that scores its reproduction and, later, its regression case, so a pass means the same thing at every stage.

Scheduled runs keep the layers going without anyone kicking them off: the regression suite every night, the adversarial suite between releases. A schedule can be anything from every 15 minutes to every 30 days. And the Coval CLI takes you from install to your first simulation in under 15 minutes.

That’s the whole framework. Three layers, each with its own pass rule, and a loop that turns every fixed failure into a regression test. It’s what lets you fix that ignored request for a person once and know it stays fixed. Start with the layer you already have data for: take your last five confirmed failed calls and make them your first production-derived tests.

Build your three layers Turn your last five failed calls into tests that run on every release.

Get deployment-ready.