Skip to content
•
13 min read

Laurie Voss on evals for agents: read the traces first

AI
Talk

Ship Real Agents: Hands-On Evals for Agentic Applications by Laurie Voss, the AI Engineer YouTube channel, May 14, 2026 (2 hr 4 min)

Voss is head of developer relations at Arize AI, which makes Phoenix, the open-source tracing tool the workshop uses, and a co-founder of npm. Several of the workshop's ideas come from Anthropic's post Demystifying evals for AI agents.

Watched

These are my notes on what the speaker said. I've checked the names, numbers and quotes against other sources.

Key ideas

  • An eval is a test for an AI system, and a trace is the log it runs on. Record traces before you write any test.
  • Read the traces yourself and sort the failures first, because the failures you find decide what's worth testing.
  • Use a code check when the answer is fixed, a model as judge when meaning matters, and people for failures nobody has seen yet.
  • Grade what the agent produced, not the path it took, or the test breaks when the agent finds a shorter route.
  • A judge's rubric needs exact criteria, labelled examples and a pass or fail answer, with one judge for each quality.
  • A model judge is itself a prompt that can be wrong, so check it against your own labels before you trust its scores.

Laurie Voss spends two hours building a test suite for one small AI agent, and the order he works in is the lesson: read what the agent did, write the cheapest check first, add a model as judge only where meaning matters, then test the judge against your own labels. These are my notes on the workshop, with its figures checked against their sources. If you run an agent and judge it by reading a few outputs, this is the path from that to tests you can run on every change.

The agent in the workshop is a toy on purpose. It takes a stock ticker, searches the web, and writes a short financial report. Voss runs it on Claude Haiku, a small model, so that it makes mistakes worth testing. Every count below comes from his run of 13 reports, so treat them as an illustration of the method, not a measurement.

Evals and traces

Voss’s first point is that the vocabulary hides something simple. An eval is a test. The data it runs on is a log of everything the agent did, called a trace. Each step in the trace, such as a model call or a tool call, is a span, and a span records its input, its output, the time it took and the tokens it used.

Ordinary unit tests don’t work here because the same prompt gives different text each run, and many of those texts are correct. Matching a string can’t tell them apart. Reading outputs by hand works until the system grows, and then it stops catching the things that break quietly.

He gives three changes you can’t make safely without evals:

  • Changing the prompt. A model takes the whole prompt in at once, so a fix for tone can change answers that had nothing to do with tone.
  • Changing the model. New models behave differently, not only better, so a prompt tuned for one may not work on the next.
  • Shipping to real users. People phrase things in ways you didn’t test, and a few of them will try to break it.

He cites Descript, Bolt and Anthropic’s Claude Code team as teams that started by checking outputs by eye and moved to evals once that stopped scaling. That account comes from Anthropic’s post on agent evals, published January 9, 2026, which is the source for several ideas in the workshop.

Three kinds of eval

KindWhat it isGood atWeak at
Code checkA plain function you writeFixed answers: valid JSON, length limits, banned phrases, required fields. Fast, close to free, same result every timeAnything where many different outputs are correct
Model as judgeA second model grading against a rubricMeaning: accuracy, tone, whether the answer stuck to its sources. It also explains its verdictIt costs time and money, and the judge can be wrong
Human reviewA person reading the outputThe best judgment, and the only way to spot a new kind of failureIt doesn’t scale and can’t run on every change

A real suite uses all three. Voss borrows the Swiss cheese picture from safety engineering, by way of the Anthropic post: every layer has holes, and stacking layers means the holes don’t line up.

Two details are worth keeping. A judge returns a score, a label and an explanation, and the explanation is the useful part, because it says what was missing. And he recommends a stronger model for the judge than for the agent. He says tired human reviewers miss about half of what they’re checking; I couldn’t find a study behind that number, so it’s his.

Why agents are harder

One model call has one thing to check. An agent picks a tool, sends it arguments, reads the result and decides what to do next, and each step depends on the one before. An early mistake carries through. His example is an agent asked to research Tesla that looks up Nikola Tesla the inventor, then writes an investment case from it that nobody reads closely.

The opposite failure belongs to the test. If an eval demands tool A, then tool B, then a decision, it breaks when the agent finds a shorter route, which often happens after a model upgrade. So grade the result, not the path. Parse answers loosely too: 2 hours and 120 minutes are the same answer.

He sorts evals a second way. A capability eval is one the agent mostly fails, which gives it something to improve on. Once it passes every time, it becomes a regression eval that guards what already works. A suite keeps turning the first kind into the second.

Reading the traces

Before writing a test, Voss reads the traces, and he says most tutorials skip this. You can’t judge a report “good” until you’ve written down what good means. For this agent he settles on one requirement: a report has to be actionable, meaning it says whether to buy. He says the people who should write that definition are the ones who know the work, such as product managers and real users, not only the engineer.

Reading 13 runs turned up failures he hadn’t planned for:

  • Several runs tried to save the report as a file, which fails in a notebook. The research and the report were fine. Only the last step broke, so judging by output alone would have blamed the wrong thing.
  • Reports described a company well and never said whether to buy.
  • A report on Rivian gave a delivery figure of 62,000 to 67,000 vehicles for 2026, which he flags as the kind of specific number to check. It matches the guidance Rivian, a public company, gave in February 2026 and raised in August to 65,000 to 70,000.

Then sort the failures into categories and rank them by severity times frequency, not frequency alone. A rare failure that sends a user nonsense outranks a common small one.

If you have no real usage yet, he suggests having a model write test queries: the same question in several voices, plus tickers that don’t exist, questions in several parts and attempts to break the agent.

Code checks and built-in judges

His results on the 13 reports show why the choice of eval matters more than tuning it.

EvalKindPassedWhat it showed
Does the report mention the ticker?Code check11 of 13One miss was a file-writing failure. The other was a report on Amazon that covered only its cloud business
CorrectnessBuilt-in judge0 of 13The judge believed the year was 2025 and marked current figures as wrong
FaithfulnessBuilt-in judge13 of 13Every report stuck to what its own research step had found

The correctness judge compares the output with what the judging model already knows, so it fails on anything newer than its training. The faithfulness judge compares the report with the research the agent collected. That was possible because the agent runs in two steps, research then writing, so the first step’s output could be handed to the judge as the source.

Writing a rubric

No built-in judge checks “is this report actionable”, so he writes one. He says every good judge prompt he’s seen has five parts.

PartWhat goes in it
RoleWhat kind of output the judge is grading and what that output is for. He says a persona line helps only a little
CriteriaExactly what makes a report pass and exactly what makes it fail, in terms a judge can observe. Each one should trace to a failure you saw in the traces
DataThe question and the report, with clear markers around each so the judge can’t mix them up
ExamplesA labelled pass and a labelled fail. He calls this the most useful part and the one most people skip
OutputOne word: actionable or not actionable

Three rules sit around those parts:

  • Use pass or fail, or three levels at most. A score out of ten adds noise, because nobody can say what separates a six from a seven.
  • Ask the judge to reason before it gives the label. An attendee pointed out his own prompt didn’t do this, and he agreed it should.
  • One judge for each quality. A single judge for accuracy, tone and completeness can’t tell you which one failed.

His judge failed six of the 13 reports, each with an explanation such as a missing buy, sell or hold call. He also separates checks that should block a release, such as an invented stock price, from ones that only inform.

Checking the judge

A judge is a prompt, so it can be wrong the same way the agent can. The check is to label examples yourself, using the same written criteria the judge has, and compare. That labelled set is the golden dataset. Voss says plainly that his own labels in the workshop were assigned at random to have something to show, so his agreement figures mean nothing. The method is what carries over.

  • Measure the judge the way you’d measure a spam filter. Precision is how often it’s right when it flags something, and recall is how many real problems it catches. For most evals he’d favour recall: a false alarm costs a person a look, and a miss reaches users.
  • Hold part of the golden set back. He suggests a 75 to 25 split, tuning the judge on the larger part and testing on the part it hasn’t seen.
  • Test both directions. Include cases where the behaviour should happen and cases where it shouldn’t, or the agent learns to do it every time.
  • Watch for four biases: favouring the first or last option, favouring longer answers, trusting confident wording, and preferring output from the same model. A judge from a different provider helps with the last.
  • Compare the judge with how well two people agree, not with perfection. He puts agreement between two experts as low as 0.2 to 0.3. I couldn’t confirm that range at a source, so it’s his.

Failures should also look fair. If a failing trace reads fine to you, suspect the eval. His example is from the Anthropic post: Claude Opus 4.5 first scored 42% on a benchmark called CORE-Bench, and the cause was the grading. The grader expected 96.124991 and marked 96.12 wrong, some tasks were ambiguous, and some couldn’t be reproduced exactly. With those fixed and a less restrictive setup, the score was 95%. The same post says a 0% pass rate across many tries usually means a broken task, and that each task should have a known working answer.

Experiments and sample size

An eval tells you something is wrong. An experiment tells you whether a change fixed it. He saves the six failing reports as a dataset, changes the two prompts in ways the judge’s explanations pointed to (ask the research step for ratios, recent news and the current price, and require a buy, sell or hold call in the report), and reruns only those six. All six passed. He says a real change moves the score a little across hundreds of cases, and sometimes makes it worse, which is why prompts should be versioned like code.

On how many examples you need, his figures check out with the usual approximation for a 95% confidence interval:

ExamplesFailure rate seenReal rate could be
2003%0.6% to 5.4%
4003%1.3% to 4.7%

So if the bar is under 5%, 200 examples can’t confirm it and 400 can. He treats 12 to 20 examples as enough to show direction, and 200 to 400 as the range for a decision to ship.

Where to spend effort, in his order: the data the agent works from, then the prompt, then the model, and last the sampling settings, which he says rarely matter.

He closes with a short list of things to look up next:

  • Running evals on a sample of live traffic, to catch drift and attacks.
  • Accuracy divided by cost. His example is that 92% at 2 cents a query can beat 95% at 15 cents.
  • Asking a judge which of two outputs is better, which models do more reliably than scoring one.
  • pass@k and pass^k. A coding tool that succeeds once in several tries is useful. A support agent that fails one time in five isn’t.

Feeding eval results to a coding agent so it improves the app by itself is, in his words, still hard to get working.

How to try it

His closing advice, in order:

  • Read your traces. He says 15 minutes of reading real outputs beats hours of adjusting a prompt.
  • Make your first eval a code check: the format you expect, or a string that has to be there.
  • Add one judge at a time, and get each one trustworthy before adding the next.
  • Start each new eval as something the agent fails, and move it to the regression set once it passes.
  • Rerun the whole set, not only the failures, before you ship.

The point at which he says you need evals is when checking by eye starts slowing you down, usually the first time one change breaks three other things unnoticed.

The workshop uses Phoenix, the open-source tool his employer makes, but none of the steps depend on it. For where this fits in the bigger picture, see my notes on his later talk, What’s left for engineers when AI writes the code.

Key terms

Eval
An automated test of whether an AI system's output is good.
Trace and span
A trace is the full record of one agent run. Each step inside it, such as a model call or a tool call, is a span.
LLM as a judge
A second model that grades the first model's output against written rules.
Rubric
The written rules a judge grades against. In practice it's a prompt.
Faithfulness
Whether an answer sticks to the source material it was given, and only that.
Golden dataset
Examples with answers a person has labelled, used to check whether a judge agrees with people.
Capability eval and regression eval
A capability eval is one the agent mostly fails, so it has something to improve on. Once it passes, it becomes a regression eval that guards what already works.
Precision and recall
Precision is how often the judge is right when it flags something. Recall is how many of the real problems it catches.
pass@k and pass^k
The chance an agent succeeds at least once in k tries, and the chance it succeeds on all k.

Quotes from the talk

A fancy way of being wrong at scale.

Laurie Voss, on a judge nobody has validated, quoted in the talk

Connects to

Other entries that share a theme with this one.

You can automate what you can check cheaply

A trace, a pass or fail test, or a working original to compare against is what lets an agent improve without someone reading every change.

More research

All research

Send feedback

This goes to my inbox through Web3Forms, with this page's address attached. The form sets no cookies.