# From Self-driving to Autonomous Voice Agents — Brooke Hopkins, Coval

Brooke Hopkins

AI Engineer World's Fair 2025

[Talk page](https://ai.engineer/talks/kDczF4wBh8s-from-self-driving-autonomous-voice-agents) · [Video](https://www.youtube.com/watch?v=kDczF4wBh8s)

## From Self-driving to Autonomous Voice Agents

Voice agents need more than a convincing demo: they need simulations, reusable metrics, and continuous evaluation that preserve autonomy while exposing failures.

Familiarity with LLM agents, tool calls, and basic software testing will help; no self-driving background is required.

### Production trust without sacrificing autonomy

[0:16](https://www.youtube.com/watch?v=kDczF4wBh8s&t=16s)

Why aren't voice agents everywhere? They promise to automate difficult workflows, yet trusting them with customer interactions remains a barrier. Brooke Hopkins, founder of [Coval](https://www.coval.ai/about-us), approaches that problem through her experience leading Waymo's evaluation job infrastructure team. The mismatch starts with scope: teams overestimate agents when they attempt to automate every call or workflow at once, while underestimating the useful experiences they could already build around a smaller problem.

![Slide asking why voice AI agents aren't everywhere, with trust identified as the biggest problem and two boxes stating that we overestimate and underestimate them.](https://ai.engineer/api/talk-essay-media/98ee55a336661e0392cbcb85a03b3e8a2f52be4a9527d538e845452e8e3a95dd)

Trust is the biggest barrier to launching voice agents: we both overestimate and underestimate them.

An agent can handle 10 conversations convincingly and still struggle across 10,000 or 100,000; Hopkins uses these counts to illustrate scale, not to report benchmark results. That gap leaves enterprises reluctant to move beyond proofs of concept, internal tools, or tightly controlled workflows.

Two familiar approaches appear to offer a tradeoff:

- **Constrain the conversation.** Force the agent down predetermined paths to make its behavior predictable. Taken far enough, this becomes an expensive interactive voice response tree with an LLM inside it.
- **Allow autonomy.** Let the agent adapt to unfamiliar situations, accepting that its interactions and actions become harder to predict.

**Reliability and autonomy need not be mutually exclusive.** Waymo provides Hopkins's motivating comparison: a system can respond to unfamiliar interactions while delivering a dependable experience. The engineering question is how to build confidence in that flexibility.

### From road observations to aggregate simulation

[2:59](https://www.youtube.com/watch?v=kDczF4wBh8s&t=179s)

Hopkins traces the self-driving evaluation process from manual observation toward large-scale simulation. Initially, teams drove cars through streets, noted failures, and brought those observations back to engineers. That produced useful evidence but was difficult to scale. Explicit scenario tests came next: construct a particular situation and specify what the vehicle should do. Those tests were more repeatable, but complicated scenarios and exact expectations were expensive to maintain and could quickly become obsolete.

The next step broadened the question from what must happen in one scripted instance to **how often a type of event happens across many simulations**. Aggregate evaluation characterizes behavior across varied runs instead of making every test depend on an exact sequence. This is the emphasis Hopkins brings from self-driving to voice; focused tests still have a role within that larger evaluation strategy.

### Conversations need a responsive environment

[4:12](https://www.youtube.com/watch?v=kDczF4wBh8s&t=252s)

Driving and conversation share a crucial property: each action affects what happens next. A car must respond to its environment, which continues changing as it moves. A conversational agent must respond to a person whose next answer depends on what the agent just said. Asking for a name produces a different continuation from asking for an email address. A useful simulation therefore needs an environment that responds to the agent's actual behavior.

A test that prescribes every conversational turn becomes fragile when the agent changes its wording or asks questions in a different order. Simulated users can instead generate varied responses as the conversation unfolds. Here, LLM nondeterminism becomes useful: it supplies variation across repeated interactions, helping explore possible continuations without writing each one by hand. The objective is broad coverage, not a claim that a finite simulation suite exhausts everything a caller might do.

### Measure behavior without prescribing every answer

[5:27](https://www.youtube.com/watch?v=kDczF4wBh8s&t=327s)

Repeated simulations let a team estimate how often its agent succeeds. That shifts evaluation beyond the familiar pattern of running fixed inputs through a prompt and comparing outputs against a golden dataset. In a conversation, enumerating every acceptable response to every possible input becomes cumbersome. **Reference-free evaluation** assesses behavior without requiring a reference answer for each turn.

| Evaluation approach | What it checks |
| --- | --- |
| Input-output evaluation | Correctness for specified inputs |
| Scripted scenario assertions | Expected events in a particular scenario |
| Reference-free conversational metrics | Behaviors across varied conversations |

Reusable criteria might ask whether the agent resolved the inquiry, repeated itself, or said something prohibited. These criteria still define what good behavior means; they simply avoid prescribing every intermediate response. Metrics that apply across many scenarios provide the basis for a continuous evaluation loop.

### A local fix must survive broader regression tests

[6:44](https://www.youtube.com/watch?v=kDczF4wBh8s&t=404s)

Without a repeatable process, maintaining a deployed voice agent can turn into an ongoing professional service: every enterprise needs another adjustment. Hopkins estimates that enterprise-specific tweaks can consume 80% of a team's time after initial setup when processes are inadequate; she supplies no study conditions for that estimate. The alternative is to make each fix pass through increasingly broad checks.

Consider a car that fails to stop at a stop sign. An engineer reproduces the problem, changes the system, and confirms that the car now stops. The focused test passes—but perhaps the change made the car stop every ten seconds. A larger regression suite reveals that the apparent fix damaged ordinary driving. **Passing the reproducer establishes that the local symptom changed, not that the whole system improved.**

The evaluation layers then extend through delivery and operation:

1. **Focused feature evaluations** reproduce the bug and check the fix.
2. **Larger regression sets** check for damage elsewhere.
3. **Pre-submit and post-submit CI/CD checks** keep verification connected to code changes and deployment.
4. **Large-scale release evaluations** assess readiness using automated tests, manual review, or both.
5. **Live monitoring and detection** find production failures and feed them back into development.

Each layer answers a broader question than the one before it. Monitoring closes the loop by supplying new cases for future fixes and regression tests.

![Slide titled “Constant Eval loops made AV scalable,” showing a vehicle visualization beside five evaluation layers: small feature evals, larger regression sets, presubmit and postsubmit CI/CD, large scale release evals, and live monitoring and detection.](https://ai.engineer/api/talk-essay-media/bfbbb4a7275a5994f1cf7fce309678d3fc2e697a73d6da87612d0b29974ae620)

Continuous evaluation spans feature tests, regression sets, CI/CD, release evaluations, and live monitoring.

### Build metrics by reading conversations

[8:05](https://www.youtube.com/watch?v=kDczF4wBh8s&t=485s)

The goal is not to automate every evaluation. Automated checks provide speed and scale; human reviewers handle judgments that need a human perspective. For an appointment-booking agent, begin with a happy path such as booking an appointment for tomorrow, then simulate that request repeatedly.

Read the resulting conversations before deciding what to measure. Identify how they fail, turn those failure modes into automated metrics, and iterate through simulation and evaluation. Once the agent is ready to deploy, run the evaluations again on production conversations. Flag cases for human review and return the findings to the simulation suite. The test collection grows from observed behavior rather than remaining a fixed checklist written before anyone used the product.

### Match simulation realism to the question

[9:18](https://www.youtube.com/watch?v=kDczF4wBh8s&t=558s)

Does a simulated caller need to sound exactly like a real customer? That depends on the component being tested. As in an experiment, the task is to control variables and expose the behavior of interest. A driving simulation that looks like real video is not automatically the most useful test environment. For some decisions, the system only needs inputs identifying a dog, a cat, or a person crossing the street. Controlling those relevant inputs matters more than rendering every detail.

| Simulation level | Suitable questions |
| --- | --- |
| Text | Workflows, tool calls, instruction following |
| Simple voice | Interruptions, latency, instructed pauses |
| Realistic audio conditions | Accents, background noise, audio quality |

For workflow iteration, text is often the fastest and cheapest option. Basic voices can exercise timing and turn-taking behavior without recreating every caller's accent or acoustic environment. More realistic audio becomes necessary when those properties are the suspected cause of a production issue. Keep end-to-end voice tests, but avoid paying for full realism in every component test.

![Three stacked bars labeled Text, Simple Voice, and Hyper-Realistic beside an upward cost arrow. Corresponding examples list workflows, tool calls and instruction following; interruptions, latency and instructed pauses; and accents, audio quality and background sound.](https://ai.engineer/api/talk-essay-media/90fcde27a27e33a1bc55a0efa66e0edebdccf7f56809e744e63c37f29c13e4f8)

Simulation realism progresses from text to simple voice to hyper-realistic audio, with increasing cost.

### Denoise a failure by rerunning its scenario

[11:26](https://www.youtube.com/watch?v=kDczF4wBh8s&t=686s)

One failed run tells you that a failure is possible. It does not tell you how frequently it occurs. Hopkins calls the next step **denoising**: take the failed scenario and simulate it repeatedly to estimate its failure frequency. Her example uses 100 reruns of the same scenario.

| Hypothetical failures in 100 reruns | Interpretation |
| --- | --- |
| 50 | Roughly coin-flip behavior |
| 99 | Near-consistent observed failure |
| 1 | A rarer observed failure |

These are illustrative outcomes, not experimental results. A 99-in-100 result does not prove that failure is certain, and a 1-in-100 result is acceptable only if the application's requirements permit it.

The bookkeeping can stay simple. This TypeScript function summarizes already-scored reruns of one scenario:

```typescript
type RunResult = {
  scenarioId: string;
  failed: boolean;
};

function summarizeScenario(runs: readonly RunResult[]) {
  const first = runs[0];
  if (!first) throw new Error("At least one rerun is required");
  if (runs.some(run => run.scenarioId !== first.scenarioId)) {
    throw new Error("Summarize one scenario at a time");
  }

  const failures = runs.filter(run => run.failed).length;
  return {
    scenarioId: first.scenarioId,
    runs: runs.length,
    failures,
    observedFailureRate: failures / runs.length,
  };
}
```

The output is an observed fraction, not a guaranteed underlying probability. Hopkins invokes cloud infrastructure's six-nines reliability as a way to ask what level of reliability each part of a voice product needs—not as a result established by these reruns or a universal target for voice agents.

### Choose metrics from the product's purpose

[12:18](https://www.youtube.com/watch?v=kDczF4wBh8s&t=738s)

**Evaluation design is product design.** Choosing metrics means deciding what the agent must do well. General voice systems, including those available through OpenAI APIs, already cover broad conversational capabilities. A vertical agent needs more specific priorities: which tasks justify its existence, and which capabilities matter less?

- **Refund support:** A caller who wants a refund may tolerate some delay to obtain the outcome.
- **Outbound sales:** Latency can be critical because the recipient is ready to hang up.
- **Appointment booking:** Instruction following and complete information collection are essential; a booking without the required details is useless.
- **Interviewing or therapy:** Conversational workflows may deserve more emphasis than rigid task completion.

Interruptions deserve evaluation alongside latency. The relative importance of each behavior comes from the interaction the product is supposed to support.

### Calibrate automated judges with human feedback

[13:44](https://www.youtube.com/watch?v=kDczF4wBh8s&t=824s)

**LLM-as-a-judge** makes customer-specific evaluation criteria practical, but flexibility brings noise. Asking only “Was this conversation successful?” leaves success underspecified. Hopkins illustrates the problem by suggesting that judging the same conversation ten times may produce inconsistent answers. Before trusting an automated metric, make its judgments align with what human reviewers actually mean by success.

Hopkins presents Coval's Metric Studio as a way to iterate on automated metrics using human feedback. Review conversations, supply judgments, and refine the metric until its evaluations align with those judgments. She illustrates scaling from 10 or 100 human-labeled conversations to automated evaluation of 10,000 conversations; those counts are not a guarantee that a small labeled sample is sufficient.

The calibration effort should reflect the reliability the product needs. A team may begin with a small number of labeled conversations, while another application warrants much more work to establish agreement. The essential step is to set the desired reliability deliberately and use human feedback to improve the metric before relying on it at scale.

### Benchmark components, then test the full system

[15:16](https://www.youtube.com/watch?v=kDczF4wBh8s&t=916s)

Build the evaluation strategy in stages:

1. **Review public benchmarks.** Use them for rough directional guidance about promising approaches.
2. **Benchmark on your own data.** A medical application should test transcription methods on the medical terminology callers will actually use.
3. **Run task evaluations.** Exercise individual modules or workflows, using text where appropriate. As with a car, testing one component does not require enabling every component.
4. **Run end-to-end evaluations.** Exercise the complete system at scale under conditions resembling production.

This progression keeps early tests focused while still requiring the integrated system to demonstrate that its parts work together.

Hopkins describes Coval's work on continuous model benchmarking, then emphasizes custom comparisons. A voice that suits one kind of conversation may not suit another; an LLM that performs well on one task may be a poor fit for a different workflow. Benchmark the components of the voice stack against their intended use, then establish task-level baseline performance. That baseline makes the next development question concrete: where does the application work, where does it fail, and which component or workflow needs attention?

### Give production failures an owner and a test set

[16:53](https://www.youtube.com/watch?v=kDczF4wBh8s&t=1013s)

An evaluation process must specify what happens after a customer reports a production bug. Decide who owns the investigation, how the failure becomes a test case, and which regression sets should include it. Organize those sets around meaningful boundaries: important customers, customer types, workflows, or individual features. This gives a discovered failure a route back into routine verification.

Dashboards and recurring review processes make that structure useful over time. A successful customer pilot answers a question about the agent during that pilot. Continuous monitoring and evaluation answer the ongoing question of whether it still works as the product and its operating conditions change.

### Voice as an expected enterprise interface

[17:38](https://www.youtube.com/watch?v=kDczF4wBh8s&t=1058s)

Hopkins's closing platform thesis compares voice with the web and mobile. Each shift changes where companies can meet users and which interactions users expect to complete there. Natural voice interfaces could bring services into additional moments of daily life, though that does not make voice the right interface for every task.

She predicts that every enterprise will launch a voice experience within three years of the talk. Her analogy is an airline's mobile app: a good voice experience could become a baseline expectation rather than a novelty. That remains a forecast, but it explains the emphasis on sustained reliability. As users expect more from voice, a persuasive pilot will be insufficient. Hopkins presents integrated evaluation—and Coval's work on it—as the infrastructure needed to keep those experiences dependable as they grow.

## Resources

- [Coval documentation](https://docs.coval.ai/welcome) — Current guides for simulating conversations, monitoring production agents, incorporating human review and integrating evaluations into development.
- [Waymo's SimulationCity](https://waymo.com/blog/2021/07/simulation-city/) — Waymo explains how scenario variation, realistic behavior distributions and full-trip simulation complement focused tests.
- [Confidence intervals for failure proportions](https://itl.nist.gov/div898/handbook/prc/section2/prc241.htm) — Statistical guidance for expressing uncertainty around observed failure rates, including small samples and rare failures.

## Slides

### From Evals for Self-Driving to Self-Driving Voice Evals

Brooke Hopkins draws on her experience leading Waymo’s eval job infrastructure team to explore what self-driving can teach us about evaluating voice agents.

[0:20](https://www.youtube.com/watch?v=kDczF4wBh8s&t=20s) [Title slide for Brooke Hopkins, CEO at Coval.](https://assets.ai.engineer/sites/aiecode2025/sha256/c706c69bcc6947b7758827fe4c470429a0d06c214df94e10ea7edecb8fc6b239.webp)

From Evals for Self-Driving to Self-Driving Voice Evals

Brooke Hopkins, CEO @ Coval

COVAL

### Why aren’t Voice AI agents everywhere?

Hopkins calls trust the biggest hurdle: teams can overestimate voice agents by trying to automate everything at once, while underestimating their potential beyond smaller problems.

[0:45](https://www.youtube.com/watch?v=kDczF4wBh8s&t=45s) [Slide identifies trust as the biggest problem launching voice agents and says people both overestimate and underestimate them.](https://assets.ai.engineer/sites/aiecode2025/sha256/a89ed8cd454b3942c7bdac2b74daca612eb3dae235cf4deed457a0666c2effcc.webp)

The state of AI Agents
Why aren’t Voice AI agents everywhere?

Biggest problem to launching Voice Agents = Trust

We are overestimating them
AND we’re underestimating them

From Evals for Self-Driving to Self-Driving Evals

AIE
aws
AI Engineer World’s Fair

[1:14](https://www.youtube.com/watch?v=kDczF4wBh8s&t=74s) [Trust is the biggest problem in launching voice agents; the slide says they are both overestimated and underestimated.](https://assets.ai.engineer/sites/aiecode2025/sha256/69fdce9316e360eb20b95ceddf2b1b92f283656d86158a3331bd16f2cf7eeb71.webp)

The state of AI Agents
Why aren’t Voice AI agents everywhere?

Biggest problem to launching Voice Agents = Trust

We are overestimating them
AND we’re underestimating them

From Evals for Self-Driving to Self-Driving Evals

AIE
Microsoft
smol ai
AI Engineer World’s Fair

### Why aren’t AI agents everywhere?

A voice agent that works for 10 conversations can be hard to scale to 10,000 or 100,000. Hopkins says enterprises may hesitate to deploy agents in customer-facing or other non-internal workflows.

[1:27](https://www.youtube.com/watch?v=kDczF4wBh8s&t=87s) [AI conversational agents are capable, but scaling production is hard, leading to proof-of-concept hell.](https://assets.ai.engineer/sites/aiecode2025/sha256/5768d0b18abcf7d32fa1b691ff54be90ae6f059f47166878598ca9f3bc6e9d19.webp)

The state of AI Agents
Why aren’t AI agents everywhere?

AI Conversational Agents are so capable, but scaling production is hard = PoC Hell

From Evals for Self-Driving to Self-Driving Evals

COVAL
AIE
aws

### Two approaches to deploying voice agents

Strict paths make voice agents predictable but resemble expensive IVR trees. Autonomous agents can handle new scenarios, but their unpredictable output makes production harder to scale.

[1:50](https://www.youtube.com/watch?v=kDczF4wBh8s&t=110s) [The slide contrasts deterministic agents forced down strict paths with autonomous agents whose unpredictable output is hard to scale.](https://assets.ai.engineer/sites/aiecode2025/sha256/2cf053ffb9ed25d54f483d6e0bc7e2278a0e8d87eaf3acdd5b31b184c8dbb0e2.webp)

The state of AI Agents
COVAL

There’s 2 approaches how Voice Agents are deployed today

Conservative but deterministic:
Forcing the agent down strict paths → Expensive IVR Tree

Autonomous but unpredictable:
AI generated output for a given input, but production is hard to scale

From Evals for Self-Driving to Self-Driving Evals

AIE
aws

### A false choice

Hopkins argues that voice agents can be both reliable and autonomous, rejecting the tradeoff between rigid pathways and unpredictable behavior.

[2:25](https://www.youtube.com/watch?v=kDczF4wBh8s&t=145s) [Slide says reliability and autonomy can coexist, with a presenter inset.](https://assets.ai.engineer/sites/aiecode2025/sha256/ae349cff96fc081c743d468884b4ca439c1feb22415e5859720c0cb1f7141c6d.webp)

But this is a false choice

You can have reliability AND autonomy...

COVAL
From Evals for Self-Driving to Self-Driving Evals

AIE
Microsoft
smol ai

### How many of you have taken a Waymo?

Hopkins uses a Waymo ride to introduce her case that reliability and autonomy can coexist.

[2:30](https://www.youtube.com/watch?v=kDczF4wBh8s&t=150s) [A Waymo vehicle beneath a question asking who has taken a Waymo, with a presenter inset.](https://assets.ai.engineer/sites/aiecode2025/sha256/eefd161c167b4adaa553e69daec05611c6d8ed94735218f6364771f18682c76d.webp)

How many of you have taken a Waymo?

WAYMO
JAGUAR

From Evals for Self-Driving to Self-Driving Evals

Interface text:
AIE
Microsoft
smol ai

### How did Waymo become so magical?

Hopkins describes Waymo rides as reliable and smooth, even on unfamiliar streets and in interactions the system has not seen before.

[2:38](https://www.youtube.com/watch?v=kDczF4wBh8s&t=158s) [A Waymo vehicle beneath the question of how Waymo became so magical, with a presenter inset.](https://assets.ai.engineer/sites/aiecode2025/sha256/c63930acbdcc31b2e086c47f2127d7c7477263e7e342f8ee72ee0b2ae8d5e27e.webp)

How did Waymo become so magical?

WAYMO

From Evals for Self-Driving to Self-Driving Evals

AIE
aws

### Large scale simulation

Hopkins contrasts brittle scenario-specific tests with large-scale evaluation, which measures how often events occur across many simulations. The slide pairs a self-driving simulation with many diverging traces.

[2:58](https://www.youtube.com/watch?v=kDczF4wBh8s&t=178s) [A self-driving simulation and a chart of many simulated trajectories.](https://assets.ai.engineer/sites/aiecode2025/sha256/24426fa36aa1f886a089142e9c8a8c9732f79ef0c3aab9b55b0d58fbcbda4725.webp)

What Voice can learn from Autonomous Vehicle Eval Infrastructure
Large scale simulation

COVAL

From Evals for Self-Driving to Self-Driving Evals

AIE
aws

### Learnings from self-driving applied to voice AI

Brooke Hopkins introduces lessons from self-driving that her team applies to voice AI, drawing on experience with hundreds of voice systems.

[3:58](https://www.youtube.com/watch?v=kDczF4wBh8s&t=238s) [A section slide introduces learnings from self-driving being applied to voice AI.](https://assets.ai.engineer/sites/aiecode2025/sha256/43d8c769e5284e1d186949db28f17fe9418b1587ef272ef6fe75ab4e466b0a2a.webp)

Here’s what learnings we’re applying from Self-Driving to Voice AI

From Evals for Self-Driving to Self-Driving Evals

COVAL
AIE
Microsoft
smol ai
AI Engineer World’s Fair

### Self-Driving vs Conversations Evals

A driving simulation and a booking conversation illustrate the similarity: both systems must respond to their environment at each step.

[4:10](https://www.youtube.com/watch?v=kDczF4wBh8s&t=250s) [A self-driving simulation is paired with a conversation example to illustrate path finding from point A to B.](https://assets.ai.engineer/sites/aiecode2025/sha256/b194f7a17b3c9f80b7c9b6d1c9b5b32a4eba8fb747ffe6f950a91a268e0192d4.webp)

What Voice can learn from Autonomous Vehicle Eval Infrastructure

Self-Driving vs Conversations Evals
Path finding from point A to B

Conversation example:
User: Sure. My name is Alex Johnson.
Agent: Thank you, Alex. What day and time would you prefer for your manicure appointment this week?
User: I'd like to have it on Thursday afternoon.
Agent: Is there anything else you need help with?
User: Yes. I'd also like to schedule a massage for next week.
Agent: Certainly, Alex. Let's first complete the manicure appointment. What day and time would you prefer for your manicure this week?
User: I would prefer Thursday afternoon for the manicure.
Agent: Got it, Alex. Let me check [illegible] just take a sec.
User: Sure. Take your time.
Agent: Hold on a sec. It seems there was an issue hold on a sec.
User: Alright.

From Evals for Self-Driving to Self-Driving Evals

Interface text: COVAL; AIE; Microsoft; smol ai; AI Engineer World's Fair

### Why are Simulations important in Voice AI?

Each conversational turn changes the situation. Simulations can respond to variations and cover more scenarios, reducing reliance on static or manual tests that Hopkins describes as expensive or brittle.

[4:25](https://www.youtube.com/watch?v=kDczF4wBh8s&t=265s) [Three reasons for simulations: responsive environments, durable tests, and coverage.](https://assets.ai.engineer/sites/aiecode2025/sha256/2b7f758c6bcd3691b51285a2489fcef0c364aba8c5afe0ecc17f194d15a5bba6.webp)

Simulations

Why are Simulations important in Voice AI?

1 Responsive Environments
Every turn the car takes, it enters into a new state of the world. It’s the same with conversations.

2 Durable Tests
You need to create a system that responds to any variation of your agent.

3 Coverage
There are N x N variations of how surroundings change and how your agent would respond to it.

From Evals for Self-Driving to Self-Driving Evals

COVAL
AIE
aws
AI Engineer World’s Fair

### Input/Output vs. Probabilistic Evals

An input/output eval asks whether an agent responds to X in one conversation. A probabilistic eval measures the percentage of yes and no outcomes across happy-path and adversarial conversations.

[5:29](https://www.youtube.com/watch?v=kDczF4wBh8s&t=329s) [Comparison of a yes-or-no evaluation for one conversation with the percentage of yes and no outcomes across multiple conversations.](https://assets.ai.engineer/sites/aiecode2025/sha256/5a12b0856bb1b9ce9a029e0d155bdaf84527fc28e6d312b156048df1ee5cef4d.webp)

How to approach Evals with Simulations

Input / Output vs. Probabilistic Evals

In this Conversation, does my agent respond to X?
↓
Yes vs. No

Across all these happy path / adversarial conversations, does my agent respond to X?
↓
% of Yes vs. No across all Conversations

From Evals for Self-Driving to Self-Driving Evals

COVAL
AIE
aws
AI Engineer World's Fair

### Constant eval loops made AV scalable

Hopkins describes a loop: reproduce and fix a bug with small evals, run regression sets to catch new failures, then use CI/CD, release evals, and live monitoring to keep checking the system.

[6:29](https://www.youtube.com/watch?v=kDczF4wBh8s&t=389s) [Autonomous vehicle evaluation loops include feature evals, regression sets, CI/CD, release evals, and live monitoring.](https://assets.ai.engineer/sites/aiecode2025/sha256/b49ffb02dcdfc2eaa9d43a1e136da3a1cc3b9185f3fe298b715d0a877fa3a052.webp)

What Voice can learn from Autonomous Vehicle Eval Infrastructure

Constant Eval loops made AV scalable

Run small feature evals
Run larger regression sets
Presubmit & postsubmit CI/CD
Large scale release evals
Live monitoring and detection

From Evals for Self-Driving to Self-Driving Evals

AIE
Microsoft
smol ai
AI Engineer World's Fair

Interface text:
Lunch
12:00 PM - 12:30 PM
Join Meeting & open Granola

### Use automated evals for speed and scale

Real and simulated conversations feed evaluation. Manual review feeds findings back into simulations, while human judgment focuses on calls that need it.

[8:04](https://www.youtube.com/watch?v=kDczF4wBh8s&t=484s) [Real-world and simulated conversations feed evaluation and manual evaluation, with feedback to simulated conversations.](https://assets.ai.engineer/sites/aiecode2025/sha256/4698479d327112a0e52199b376b75569da246450ec960cf555378b4a14652080.webp)

How to approach Evals with Simulations

Your goal is not to automate all evals, but leverage auto evals for speed and scale

Real-World Conversation
Simulated Conversation
Evaluation
Manual Evaluation

From Evals for Self-Driving to Self-Driving Evals

AIE
AWS
COVAL
AI Engineer World's Fair

Interface text:
Lunch
12:00 PM - 12:30 PM
Join Meeting & open Granola

### What level of realism is needed?

Choose realism based on what you need to test: text can cover workflows, simple voice can test interruptions and latency, and hyper-realistic voice can recreate accents and audio conditions at higher cost.

[9:19](https://www.youtube.com/watch?v=kDczF4wBh8s&t=559s) [A cost hierarchy matches text to workflows, simple voice to interruptions and latency, and hyper-realistic voice to accents and audio conditions.](https://assets.ai.engineer/sites/aiecode2025/sha256/9cc50f0a1e150878acc9ece0907a5f9b7039e46d4b37c733f9b7d7d83104bed4.webp)

How to approach Evals with Simulations
COVAL

What level of Realism is needed?

Cost ↑

Hyper-Realistic
Accents, audio quality, background sound

Simple Voice
Interruptions, latency, instructed pauses

Text
Workflows, tool calls, instruction following

From Evals for Self-Driving to Self-Driving Evals

Interface text:
AIE
Microsoft
smol ai

### Denoising

Run happy-path simulations, then resimulate a failed scenario 50 more times to see how often it fails and assess its seriousness.

[11:30](https://www.youtube.com/watch?v=kDczF4wBh8s&t=690s) [A workflow runs simulations, isolates a failed scenario, and resimulates it to assess failure frequency.](https://assets.ai.engineer/sites/aiecode2025/sha256/aea0e312986fc1d7291d1c1053f55f09d5f25108a836aa209dedfe5e399e7c32.webp)

Scalable Eval Workflows
Denoising

First,
run your happy path simulations across your metrics. Sometimes, your simulations will look like this.

Then,
Isolate the scenario that failed your metrics. It failed one time. But how often will it fail when you resimulate it 50 more times? Then you’ll know if it’s a serious issue.

From Evals for Self-Driving to Self-Driving Evals

Interface text:
Run Results
Generate Test Set of 1 Selected
Resimulate 1 Selected
Cancel Selection
# | Selected | Status | ID | Input | Result | Multiple Procedures: Identified all needs | Appointment Booked | Preferred Times | Availability: Provide Alternative Slots
1 | [illegible] | Call agent to book multiple procedures (e.g., massage + facial) | 01:24 | Y | Y | Y | Y
2 | [illegible] | Call agent to book a manicure for this week and a massage for next week | 04:44 | N | N | Y | Y

COVAL
AIE
Microsoft
smol ai

[11:38](https://www.youtube.com/watch?v=kDczF4wBh8s&t=698s) [Run simulations, isolate a failed scenario, and resimulate it to assess how often it fails.](https://assets.ai.engineer/sites/aiecode2025/sha256/396ada107e55aec603b50949bf4e4b84a9ac54975a6452448f03b41abd1bcac8.webp)

Scalable Eval Workflows
Denoising

First,
run your happy path simulations across your metrics. Sometimes, your simulations will look like this.

Then,
Isolate the scenario that failed your metrics. It failed one time. But how often will it fail when you resimulate it 50 more times? Then you’ll know if it’s a serious issue.

From Evals for Self-Driving to Self-Driving Evals

Interface text:
Run Results
Generate Test Set of 1 Selected
Resimulate 1 Selected
Cancel Selection
# | Selected | Status | ID | Input | Result | Multiple Procedures: Identified all needs | Appointment Booked | Preferred Times | Availability: Provide Alternative Slots
1 | [illegible] | Call agent to book multiple procedures (e.g., massage + facial) | 01:24 | Y | Y | Y | Y
2 | [illegible] | Call agent to book a manicure for this week and a massage for next week | 04:44 | N | N | Y | Y

COVAL
AIE
Microsoft
smol ai

### Building an eval strategy

Hopkins frames evals as part of product development: choosing metrics means deciding what the product should do and what it should do well.

[12:15](https://www.youtube.com/watch?v=kDczF4wBh8s&t=735s) [Evals are part of product development, not just an engineering best practice.](https://assets.ai.engineer/sites/aiecode2025/sha256/7d03796a2a65c9fd3ad16085c09cd4a46421f155145e4f0b1eb208ff6334f0fd.webp)

Scalable Eval Workflows

Our take on how to build an eval strategy

Evals are a part of your product development, not just an engineering best practice

From Evals for Self-Driving to Self-Driving Evals

COVAL
AIE
Microsoft
smol ai
AI Engineer World’s Fair

### Voice AI isn’t just about Latency

Coval proposes simulations and evals to test interactions among voice AI concerns. Priorities depend on the task: outbound sales needs speed, while appointment booking needs complete details.

[12:33](https://www.youtube.com/watch?v=kDczF4wBh8s&t=753s) [Latency, interruptions, workflows, tool calls and unknowns are interdependent dimensions that simulations and evals can test.](https://assets.ai.engineer/sites/aiecode2025/sha256/b18184286ea8a8a9449c0203b9bb239f880789cd5860a21d3f4d32b5378202b6.webp)

What Voice AI Developers care about

Voice AI isn’t just about Latency.

Latency
Interruptions
Workflows
Toolcalls
Unknowns Unknowns

What Simulations & Evals help with?
→ Interdependence aka testing n to n variations → this is what saves you time as you launch simulations, check evals, and know where to focus on.

From Evals for Self-Driving to Self-Driving Evals

COVAL
AIE
Microsoft
smol ai

[12:58](https://www.youtube.com/watch?v=kDczF4wBh8s&t=778s) [Slide lists latency, interruptions, workflows, tool calls, and unknowns as factors for voice AI evaluations.](https://assets.ai.engineer/sites/aiecode2025/sha256/8ba19618e2a3130e6c0ffa9a7220ad194ccf98296a7f17fe46c9785cb009d59a.webp)

What Voice AI Developers care about

Voice AI isn’t just about Latency.

Latency
Interruptions
Workflows
Toolcalls
Unknowns Unknowns

What Simulations & Evals help with?
→ Interdependence aka testing n to n variations → this is what saves you time as you launch simulations, check evals, and know where to focus on.

From Evals for Self-Driving to Self-Driving Evals

COVAL
AIE
Microsoft
smol ai

### How to Set Up Trustworthy Evals

The Metrics Studio screenshot pairs a repetition-check rubric with a transcript and human ground truth. Hopkins recommends iterating until automated metrics align with human feedback.

[13:50](https://www.youtube.com/watch?v=kDczF4wBh8s&t=830s) [Slide recommends iterating and calibrating conversational AI evaluations using human feedback, alongside a Metrics Studio screenshot.](https://assets.ai.engineer/sites/aiecode2025/sha256/8c91a0d4851c5e1ef6ab98d5c7e5da32f576cd002d3841d2deb91b6c68c0f6eb.webp)

Scalable Eval Workflows

How to set up Trustworthy Evals?

Iterate & Calibrate

The key to good evals in conversational AI is to iterate and calibrate based on human feedback.

Look at the data!

From Evals for Self-Driving to Self-Driving Evals

Interface text:
Metrics Studio
Refine your LLM-as-a-Judge metrics by running them on transcript-based test sets or by selecting metrics and iterating based on evaluation outcomes

By Metric
By Test Cases
Multiple Procedures: Identified all needs

Human-As-A-Judge
Transcript From: [illegible]
Ground Truth: No
Latest Experiment: 100% Correct
All Experiments (16 experiments): 100% Correct

Question:
Given the transcript, did the assistant avoid repeating the same response or entering a conversational loop?

Return YES if:
• The assistant provides distinct, forward-moving responses throughout the interaction
• There is no repetition of the same sentence, phrase, or instruction multiple times without user prompting
• The assistant does not return to the same point or response structure repeatedly (e.g., circular explanations or looped fallback phrases)

Return NO if:
• The assistant repeats the same response or phrase multiple times unnecessarily
• The assistant enters a conversational loop, revisiting the same statements or fallback messages without progressing the conversation

Evaluate Metric
Iterations: 5

Transcript Viewer
12 of 100
Hi, I'd like to book multiple procedures, specifically a massage and a facial.
Are you still there?
Yes, I'm here. I'd like to book a massage and a facial.
Great choice. We offer both massage and facial treatments. May I have your name, please?
Certainly. My name is Alex Johnson.
Thank you, Alex. When would you like to schedule your massage and facial treatments?
I would prefer to schedule them for next Saturday, if possible.
Just a sec.
Sure. Take your [illegible]

COVAL
AIE
Microsoft
smol ai

### How to Approach Evals for Voice AI

Start with public benchmarks, then test your own data and individual tasks before running end-to-end evals. The chart places each step higher in both effort and impact.

[15:14](https://www.youtube.com/watch?v=kDczF4wBh8s&t=914s) [Effort and impact chart progresses from public benchmarks through internal benchmarks and task-based evaluations to end-to-end evaluations.](https://assets.ai.engineer/sites/aiecode2025/sha256/51fff0683f4a8e2f86c36ead3578885769730ecae0af95d4059d0d078e16c31b.webp)

Evals for Voice AI
How to approach Evals for Voice AI

Effort
Impact

Review Public Benchmarks
Benchmark within internal System
Task-Based Evals
End-to-End Evals

Voice Performance – Benchmark Latency
Time to First Byte: 149 ms
Time to First Byte: 201 ms
Average Latency: 149ms
Average Latency: 201ms
[illegible]

Voice Quality – Benchmark Word Error Rate
Word Error Rate: 16.04%; 13.77%
Alphanumeric Performance: 15.04%; 10.60%
[illegible]

From Evals for Self-Driving to Self-Driving Evals

Interface text:
COVAL
AIE
Microsoft
smol ai

[15:25](https://www.youtube.com/watch?v=kDczF4wBh8s&t=925s) [A chart compares public benchmarks, internal benchmarks, task-based evaluations, and end-to-end evaluations by effort and impact.](https://assets.ai.engineer/sites/aiecode2025/sha256/ce02daa272892c0a7a3eeb6b10fb76f7ac3fc45c737d8c4c7dbe2ac50d95341a.webp)

Evals for Voice AI
How to approach Evals for Voice AI

Effort
Impact

Review Public Benchmarks
Benchmark within internal System
Task-Based Evals
End-to-End Evals

Voice Performance – Benchmark Latency
Time to First Byte: 149 ms
Time to First Byte: 201 ms
Average Latency: 149ms
Average Latency: 201ms
[illegible]

Voice Quality – Benchmark Word Error Rate
Word Error Rate: 16.04%; 13.77%
Alphanumeric Performance: 15.04%; 10.60%
[illegible]

From Evals for Self-Driving to Self-Driving Evals

Interface text:
COVAL
AIE
aws

## Full transcript

[0:00](https://www.youtube.com/watch?v=kDczF4wBh8s&t=0s) [on-hold music] Hey everyone.

[0:16](https://www.youtube.com/watch?v=kDczF4wBh8s&t=16s) I'm Brooke. I'm the founder of Coval, and we are building evals for voice agents. So today, I'm gonna be talking a little bit about what can we learn from self-driving in building evals for voice agents.

[0:27](https://www.youtube.com/watch?v=kDczF4wBh8s&t=27s) My background is from Waymo, so I led our Eval Job Infrastructure team at Waymo that was responsible for our developer tools for launching and running simulations. And now we're taking a lot of the learnings from self-driving and robotics and applying them to voice agents.

[0:41](https://www.youtube.com/watch?v=kDczF4wBh8s&t=41s) Um, but first, why are voice agents not everywhere? They have this massive promise of being able to automate all of these really critical hard workflows autonomously. And I think probably a lot of you are building in voice agents and know how amazing voice agents can be.

[0:56](https://www.youtube.com/watch?v=kDczF4wBh8s&t=56s) Um, I think the biggest problem to v- launching voice agents is trust. So we simultaneously are paradox-paradoxically overestimating voice agents and trying to say, "I'm going to automate all of my call volume or all of my workflows with voice all at once."

[1:13](https://www.youtube.com/watch?v=kDczF4wBh8s&t=73s) And we're underestimating them. I think what they're capable of today and really scoping a smaller problem versus what they could possibly do in the next six months. I think there's just so much more that you could have for a magical voice experience.

[1:28](https://www.youtube.com/watch?v=kDczF4wBh8s&t=88s) Um, so conversational agents are so capable, but you also know that scaling to production is really hard. So it's easy to nail it for 10 conversations, but to do it for 10,000 or 100,000 becomes really difficult.

[1:41](https://www.youtube.com/watch?v=kDczF4wBh8s&t=101s) So a lot of times voice agents get stuck in POC hell, where enterprises are scared to actually deploy them to customer-facing issues or non-internal workflows.

[1:52](https://www.youtube.com/watch?v=kDczF4wBh8s&t=112s) So I think there's two approaches to deal with that today. There's conservative but deterministic, so you force the agent down a specific path and try and get it to do something exactly as you want it to do.

[2:03](https://www.youtube.com/watch?v=kDczF4wBh8s&t=123s) This is basically an expensive IVR tree. Um, you're using LLMs, but you're essentially forcing it into certain pathways. Or you can make them much more autonomous and flexible to new scenarios that they've never seen before, but this makes it really hard to scale it to production because they're so unpredictable, and so taking actions on behalf or interfacing

[2:23](https://www.youtube.com/watch?v=kDczF4wBh8s&t=143s) with users can be really, um, unpredictable. I think this is a false choice. I think you can have reliability and autonomy. So how many of you have taken a Waymo?

[2:35](https://www.youtube.com/watch?v=kDczF4wBh8s&t=155s) Yeah. If you haven't and you're from out of town, you sh- definitely should. It is so magical. So how did it become so magical? It's so reliable and y- also so smooth, but it's able to navigate all of these inter, um, interactions that it's never seen before, go down streets it's never seen before, and Waymo is launching

[2:54](https://www.youtube.com/watch?v=kDczF4wBh8s&t=174s) to all of these new cities, um, very quickly.

[2:59](https://www.youtube.com/watch?v=kDczF4wBh8s&t=179s) So I'm biased, but I think large scale simulation has been the huge unlock for self-driving and robotics because without it, you-- So we started in more manual evals. So, um, starting with like running the car throughout all the streets, noting where it doesn't go well, and then bringing that back to the engineers.

[3:17](https://www.youtube.com/watch?v=kDczF4wBh8s&t=197s) This obviously is very hard to scale, so then we created these specific tests where we're saying, "For this specific scenario, we expect these things to happen." Um, but this is very brittle.

[3:27](https://www.youtube.com/watch?v=kDczF4wBh8s&t=207s) Your scenarios tend to no longer be useful after a very short period of time, and they're very expensive to maintain because you have to build up these very complicated scenarios and then say exactly what should happen in those.

[3:38](https://www.youtube.com/watch?v=kDczF4wBh8s&t=218s) So then they move to-- The vi-- the industry as a whole has moved to large scale evaluation. So how often is a certain type of event happening across many, many simulations?

[3:50](https://www.youtube.com/watch?v=kDczF4wBh8s&t=230s) And so instead of trying to say, "For this specific instance, I want this to happen," you run large scale simulation to really reliably show how the agent is performing.

[4:00](https://www.youtube.com/watch?v=kDczF4wBh8s&t=240s) So I'm gonna talk through like some of the things that I've learned from self-driving and how they apply to voice. Um, and hopefully that will-- that's useful because it's definitely been useful for us as we interact with hundreds of voice, uh, systems.

[4:12](https://www.youtube.com/watch?v=kDczF4wBh8s&t=252s) So what is the similarity between the two? Self-driving and conversational evals are very similar because both of them are systems where you're interacting with the real world, and for each step that you take, you have to respond to the environment and go back and forth.

[4:28](https://www.youtube.com/watch?v=kDczF4wBh8s&t=268s) And so simulations are really important for this because for every step that I take in a Waymo or a self-driving car or a smaller robotics vehic-- um, device, or in a conversation, when I say, "H-hello, what's your name?"

[4:43](https://www.youtube.com/watch?v=kDczF4wBh8s&t=283s) You'll respond differently than when I say, "Hello, what's your email?" So being able to simulate all of these possible scenarios is really important because otherwise you have to create these static tests or do it manually, and both of which are either expensive or brittle.

[4:57](https://www.youtube.com/watch?v=kDczF4wBh8s&t=297s) Um, you also-- And so this makes for a very dur-- that doesn't make for very durable tests. If you have to specifically outline every single step along the way, those break immediately and are very expensive to maintain.

[5:09](https://www.youtube.com/watch?v=kDczF4wBh8s&t=309s) And then lastly, coverage. You really wanna simulate all of the possible scenarios across a very large area. And so the non-determinism of LLMs is actually really useful for this because you can show what are all the possible things that someone might respond back to this, and then we simulate that over and over and look for what the

[5:27](https://www.youtube.com/watch?v=kDczF4wBh8s&t=327s) probability of my agent succeeding is. Another thing that I touched on a bit is input-output evals versus probabilistic evals. So with LLMs to date, we have seen you run a set of inputs for your prompt. [clears throat]

[5:45](https://www.youtube.com/watch?v=kDczF4wBh8s&t=345s) Excuse me. You run a set of inputs for your prompt, and then you look at all the outputs and evaluate whether or not the output for that input was correct based on some criteria.

[5:54](https://www.youtube.com/watch?v=kDczF4wBh8s&t=354s) So you might have a golden data set that you're iterating against. With conversational evals, it becomes even more important to have reference-free evaluation, where you don't necessarily need to say, "These are all of the expected things I s- want, am expecting for this exact input."

[6:10](https://www.youtube.com/watch?v=kDczF4wBh8s&t=370s) But rather you're defining as a whole, how often is my agent resolving the user inquiry? How often is my agent repeating itself over and over? How often is my agent saying things it shouldn't?

[6:21](https://www.youtube.com/watch?v=kDczF4wBh8s&t=381s) Um, rather than saying for this specific scenario, these six things should happen. Um, and so this is what's going to really allow you to scale your evals, and also what we did at Waymo.

[6:31](https://www.youtube.com/watch?v=kDczF4wBh8s&t=391s) So coming up with metrics that are, uh, apply to lots of scenarios. Another thing is that constant eval loops are what made autonomous vehicles scalable, and that's what's going to make, um, voice agents scalable.

[6:44](https://www.youtube.com/watch?v=kDczF4wBh8s&t=404s) I think we're seeing today that voice agents are so expensive to maintain in production. Once you deploy to an enterprise, it becomes often a professional service if you don't set up your processes right.

[6:55](https://www.youtube.com/watch?v=kDczF4wBh8s&t=415s) And so you're constantly making all of these tweaks for specific enterprises, which can take up eighty percent of your time even after you've set up the initial agent. So something that the autonomous vehicle industry has been doing is, how do you run-- Like, let's say you find a bug, and as an engineer, I might iterate on that,

[7:13](https://www.youtube.com/watch?v=kDczF4wBh8s&t=433s) and I run a couple of evals to reproduce that, and then I fix the issue, and then I run more. So it wasn't stopping at a stop sign. I iterate on that, and now it is stopping at a stop sign.

[7:23](https://www.youtube.com/watch?v=kDczF4wBh8s&t=443s) But then I li- run a larger regression set because maybe I just made the car stop every ten seconds, and so I broke everything. Um, so then you run a larger regression set and make sure you didn't break everything.

[7:34](https://www.youtube.com/watch?v=kDczF4wBh8s&t=454s) And then we have a set of, um, pre-submit and post-submit CI/CD workflows so that before you ship code and then after you, um, you push the code to production, we make sure everything is continuously working.

[7:45](https://www.youtube.com/watch?v=kDczF4wBh8s&t=465s) And then there's large-scale release evals, so making sure that everything is up to par before we launch a new release. And this might be both manual evals and automated evals and some combination thereof.

[7:57](https://www.youtube.com/watch?v=kDczF4wBh8s&t=477s) And then live monitoring and detection, um, which then you can, uh, feed back into this whole system.

[8:05](https://www.youtube.com/watch?v=kDczF4wBh8s&t=485s) So we're emulating a lot of this with voice. I think we think that's the right, uh, approach as well. But you're-- Notably that there's still manual evals involved. The goal is not to automate all evals, but rather to leverage auto evals for speed and scale, and then use the manual time that you have to really focus on

[8:26](https://www.youtube.com/watch?v=kDczF4wBh8s&t=506s) how, um, those like very h- you know, human touch judgment calls. Um, so the process that we've seen is you might start with simulated conversations, and you run some happy paths of like, "I know I should be able to book an appointment."

[8:39](https://www.youtube.com/watch?v=kDczF4wBh8s&t=519s) Um, so book an appointment for tomorrow. I run a bunch of simulations of that. I run evals. I come up with metrics of-- I look through all those conversations.

[8:47](https://www.youtube.com/watch?v=kDczF4wBh8s&t=527s) Looking at your data is super important. Um, I look at all those conversations and I say, "These are the ways they're failing." So I set up some automated metrics and iterate through this loop several times.

[8:57](https://www.youtube.com/watch?v=kDczF4wBh8s&t=537s) Now I think it's ready for production, so I ship it to production and then run those evals again. And so this cycle, this virtuous cycle of iterating on through simulation and then detecting or like flagging things for human review and then feeding all of that back into your simulations is super important for scalable voice agents.

[9:18](https://www.youtube.com/watch?v=kDczF4wBh8s&t=558s) Um, so what level of realism is actually needed?

[9:23](https://www.youtube.com/watch?v=kDczF4wBh8s&t=563s) Uh, something-- A question we get a lot is, "How are your voi- are your voice agents exactly how my customers sound?" And that's a good question because the level of realism is dependent on what you're trying to test.

[9:35](https://www.youtube.com/watch?v=kDczF4wBh8s&t=575s) So like any scientific method, right? You're trying to control variables and then test for the things that you care about. So there's-- Something we saw in self-driving is that there's kind of this hierarchy of like you might not need to simulate everything in order to get a representative feedback on how your system is doing.

[9:53](https://www.youtube.com/watch?v=kDczF4wBh8s&t=593s) Um, so the way we think-- So for example, all the time there are all these, you know, super hyper-realistic simulations coming out that look like a r- you know, that look like a real video.

[10:04](https://www.youtube.com/watch?v=kDczF4wBh8s&t=604s) And people would say, "That simulation system is amazing." And really, that's not necessarily true because what you want from a simulation system is how much can you control what parts of the system you're simulating, and then how-- like what inputs are needed.

[10:18](https://www.youtube.com/watch?v=kDczF4wBh8s&t=618s) So you might just need to know this is a dog and I-- this is a cat and this is a person walking across the street. Um, and then what should I do next as a result of those inputs?

[10:28](https://www.youtube.com/watch?v=kDczF4wBh8s&t=628s) And so this is the same for voice. We think about it as, uh, for example, workflows, tool calls, instruction following. You actually don't need to even simulate that with vo-voice often.

[10:37](https://www.youtube.com/watch?v=kDczF4wBh8s&t=637s) You might wanna do end-to-end tests with voice, but when you're iterating, doing that all with text is probably the fastest and cheapest way to do that. Um, then for interruptions or latency or instructed pauses, um, simple voices that are just the bas-basic voices are sufficient because you're doing that voice-to-voice testing.

[10:57](https://www.youtube.com/watch?v=kDczF4wBh8s&t=657s) But, you know, accents or background noises might not im-impact that as much. And then where you need hyper-realistic voices of different accents, different background noises, different audio quality, et cetera, is when you're testing those things in production and trying to recreate those issues.

[11:13](https://www.youtube.com/watch?v=kDczF4wBh8s&t=673s) And so thinking about what c- what are the base level of components that you really need to, to develop this is super important for, um, for building a good eval strategy.

[11:26](https://www.youtube.com/watch?v=kDczF4wBh8s&t=686s) Uh, and then an awesome tactic that we've learned is denoising. So, um, you run a bunch of evals, and then you might find one that failed. And something that's really important about agents is that it doesn't-- it's not the end of the world maybe if it fails one time.

[11:41](https://www.youtube.com/watch?v=kDczF4wBh8s&t=701s) You really wanna know what is the probability of this failing overall. So then you can find that scenario and then resimulate that, and maybe you resimulate that 100 times.

[11:51](https://www.youtube.com/watch?v=kDczF4wBh8s&t=711s) So is this scenario failing 50 out of 100 times? Is it a coin flip? Is it failing 99 out of 100 p- times, which it means it's definitely always failing?

[12:00](https://www.youtube.com/watch?v=kDczF4wBh8s&t=720s) Um, or does it fail once out of 100 times? And that might be totally okay for your application. Um, and so having a sense in the same way of cloud infrastructure, where are you shooting for six nines of reliability?

[12:11](https://www.youtube.com/watch?v=kDczF4wBh8s&t=731s) For voice AI, that's really important as well as like what reliability are you looking for for different parts of your product?

[12:18](https://www.youtube.com/watch?v=kDczF4wBh8s&t=738s) So now I wanna talk a bit about how to build an eval strategy, because we believe that evals are as an important part of your process. Uh, it's the key part of your product development, and it's not just an engineering best practice.

[12:30](https://www.youtube.com/watch?v=kDczF4wBh8s&t=750s) This is actually like a core part of thinking through what does your product do.

[12:35](https://www.youtube.com/watch?v=kDczF4wBh8s&t=755s) So voice AI-- Like thinking through what metrics you should use is thinking through what does your product do and what do you wanna be good at. You can build a general voice model that's kind of good at everything, and that already exists, right?

[12:47](https://www.youtube.com/watch?v=kDczF4wBh8s&t=767s) Like, you can use the OpenAI APIs. You can use, like, all of these different end-to-end, um, voice systems that already exist that-- and are generally useful. But really, you're probably building a vertical agent that you're trying to make useful at something in particular.

[13:02](https://www.youtube.com/watch?v=kDczF4wBh8s&t=782s) And so thinking about what you want it to do well and what you don't care if it does is a really important part of the process. Um, and it's not just about latency.

[13:09](https://www.youtube.com/watch?v=kDczF4wBh8s&t=789s) It's about interruptions. Like, your voice application actually might not be so latency sensitive because someone really wants a refund. But if you're doing outbound sales, latency is super important because that person's about to hang up the phone.

[13:22](https://www.youtube.com/watch?v=kDczF4wBh8s&t=802s) Um, interruptions, uh, workflows. Workflows, like how much you adhere to instruction following for some applications is really important. Like, if you're booking an appointment and don't get all the details, it's useless.

[13:34](https://www.youtube.com/watch?v=kDczF4wBh8s&t=814s) But if you're, you know, an interviewer or a therapist, you might be more tuned for conversational evals-- uh, conversational workflows.

[13:44](https://www.youtube.com/watch?v=kDczF4wBh8s&t=824s) And then, um, so really thinking through like what you're trying to measure. These are the five things w- that we see the most, but, um, LLM-as-a-judge is a really powerful way of being really flexible, and you can build out evals that are very specific for different customers.

[13:59](https://www.youtube.com/watch?v=kDczF4wBh8s&t=839s) But something we get a lot is how you trust LLM as a judge. It's this magical thing that can be so flexible to so many cases, and also it is very, um, you know, can be very noisy.

[14:10](https://www.youtube.com/watch?v=kDczF4wBh8s&t=850s) But I think the common patterns that we see with LLM as a judge is that you say, "Was this conversation successful?" That's a pretty-- That's going to be a really noisy metric.

[14:19](https://www.youtube.com/watch?v=kDczF4wBh8s&t=859s) Um, you might run that 10 times for the same conversation and it'll come back, um, with lots of different responses. So in Coval, we have this Metric Studio that we think is really, like, um, pretty different from anything out there because it allows you to iterate on this human-- incorporate human feedback into really correlate-- calibrating your metrics

[14:39](https://www.youtube.com/watch?v=kDczF4wBh8s&t=879s) with human feedback. So you can iterate over and over until your automated metrics are aligning with human feedback, and now you have the confidence to go deploy those in production and run them over ten thousand conversations instead of the hundred that you labeled or the ten that you labeled, um, to, to get that confidence.

[14:57](https://www.youtube.com/watch?v=kDczF4wBh8s&t=897s) So really, I think set-- putting in the time to saying, "This is the level of reliability that we're looking for," and being thoughtful of that, maybe just labeling ten conversations is important to you.

[15:08](https://www.youtube.com/watch?v=kDczF4wBh8s&t=908s) Wha-- Um, or maybe you really wanna dial this in. Um, but using this workflow can be really powerful.

[15:16](https://www.youtube.com/watch?v=kDczF4wBh8s&t=916s) Uh, our other advice of how to approach evals for voice AI is starting with this system of reviewing public benchmarks, which can be a rough dial of this is how, um, this is roughly the direction I wanna go in.

[15:29](https://www.youtube.com/watch?v=kDczF4wBh8s&t=929s) Then benchmarking with your own specific data. So using-- If you're like a medical company, using medical terms that you're going to be using in production to test out different transcription methods, um, et cetera.

[15:41](https://www.youtube.com/watch?v=kDczF4wBh8s&t=941s) Then running task-based evals, which are maybe text or very specific, um, smaller modules of your system. Again, what I talked about in self-driving is you don't necessarily need to enable every module on the car in order to test the one thing that you're trying to test.

[15:54](https://www.youtube.com/watch?v=kDczF4wBh8s&t=954s) And then end-to-end evals, where you're running everything at scale and pr-- um, and how it would run in production.

[16:01](https://www.youtube.com/watch?v=kDczF4wBh8s&t=961s) So we've done a lot of benchmarking. You should check out our benchmarking, um, on our t-t-- uh, on our website. But we try to do continuous benchmarking of what are the latest models out there.

[16:12](https://www.youtube.com/watch?v=kDczF4wBh8s&t=972s) But doing your own custom benchmarking is also really important. So through Coval, you can actually-- And you can also do this yourself. I just happen to have a tool that does this.

[16:21](https://www.youtube.com/watch?v=kDczF4wBh8s&t=981s) Um, but you can like run on your specific data because you might prefer different voices for the types of conversations that you're having, or you might h- prefer different LLMs based on your specific tasks.

[16:33](https://www.youtube.com/watch?v=kDczF4wBh8s&t=993s) Um, and so benchmarking each part of your voice stack is really helpful for choosing out those models, especially because voice has so many models. And then, um, building out your task evals, so starting to get a sense of baseline performance.

[16:47](https://www.youtube.com/watch?v=kDczF4wBh8s&t=1007s) Where are the problem areas in your voice AI application? Where are things working? Where could they be better?

[16:53](https://www.youtube.com/watch?v=kDczF4wBh8s&t=1013s) Um, and then creating an eval process. So this means like what kinds of continuous monitoring are we doing? What do we do when we find a bug in production from a customer?

[17:02](https://www.youtube.com/watch?v=kDczF4wBh8s&t=1022s) Who takes it and where do-- what test sets does it go into, so we can make sure that it doesn't happen again? How do we set up our hierarchy of test sets?

[17:09](https://www.youtube.com/watch?v=kDczF4wBh8s&t=1029s) Do we have test sets for specific customers that we care a lot about? Do we have types of customers that we have? Um, do we have specific workflows or features of our voice agent?

[17:18](https://www.youtube.com/watch?v=kDczF4wBh8s&t=1038s) Um, and then creating dashboards and processes so that you can check in on those things continuously. I think this is an underestimated piece of the process is like what is our continuous eval process versus just saying, "Does the voice agent work when I deploy it to this production-- this, uh, uh, customer on their-- during their pilot period?"

[17:38](https://www.youtube.com/watch?v=kDczF4wBh8s&t=1058s) Um, so yeah, always happy to talk more about tips on like what we've seen across all of the many voice systems that we've seen. But one of the reasons why we're so excited about the future of voice, and I think Quinn, um, uh, stole a little bit of this.

[17:54](https://www.youtube.com/watch?v=kDczF4wBh8s&t=1074s) But [laughs] Quinn, I really think that voice is the next platform. Um, so we had web, we had mobile, and I think both of these were huge platform shifts in what types of things do you expect that companies will allow you to do on those platforms?

[18:08](https://www.youtube.com/watch?v=kDczF4wBh8s&t=1088s) What types of work-- Where in the workflow, where in your daily live-life are you meeting the user? And I think voice is unlocking all of these new, really natural voice experiences.

[18:18](https://www.youtube.com/watch?v=kDczF4wBh8s&t=1098s) It doesn't mean everything you should be doing via voice, but there is really exciting potential there.

[18:25](https://www.youtube.com/watch?v=kDczF4wBh8s&t=1105s) And in the next three years, we think every enterprise is going to launch a voice experience. It's going to be like a mobile app where if the airline does not have a good voice experience, it's going to be like not having a good mobile app, and it will just be a, a baseline expectation.

[18:40](https://www.youtube.com/watch?v=kDczF4wBh8s&t=1120s) And I think users' expectations of what really amazing, magical voice AI experiences will be is just going to increase over, um, over the next few years.

[18:51](https://www.youtube.com/watch?v=kDczF4wBh8s&t=1131s) So we really wanna enable this future, and so we think the next gen of scalable voice AI will be built with integrated evals using Coval.

[19:01](https://www.youtube.com/watch?v=kDczF4wBh8s&t=1141s) And we're hiring, so we're always looking for people to join us. I think this is like s- really one of the most technically interesting fields that I have ever worked in because you get to work with every model across the stack, and there are so many different types of models, different types of problems, scalability, new frontiers of

[19:19](https://www.youtube.com/watch?v=kDczF4wBh8s&t=1159s) building infrastructure, and no one knows any of the answers. So it's a really exciting space. Thanks so much, everyone. [upbeat music]
