Traces show what an agent did, while evals test whether its output was good.
2
Code evals, LLM judges, and human review catch different kinds of failures, so they should be used together.
3
A reliable eval loop reads failures, changes the agent, tests the change on the same data, and gates releases in CI.
Summary
Laurie Voss builds an evaluation loop around a Claude-powered financial analyst agent. The agent searches the web, researches a company, and writes a report, but its early prompts allow failures such as saving reports to files, answering about the wrong company, and claiming that 116% of analysts agree. Voss uses Phoenix to trace every agent step, tool call, input, output, timing, and token count. She then writes deterministic code evals, uses built-in LLM judges for questions about meaning, and creates a custom actionability judge for buy, sell, or hold recommendations. The talk spends substantial time testing the judge against human labels, checking precision and recall, and avoiding bias. Voss runs controlled experiments to measure prompt changes, compares Claude Haiku 4.5 with 5.5, and puts regression checks into npm test and CI. Her advice is to begin by instrumenting the agent and reading traces before automating judgments.
Traces explain what happened, while evals test whether it was good
Voss draws a simple distinction between traces and evals. A trace is a detailed log of an agent run, including every agent step, tool call, LLM call, input, output, timing, token count, and sometimes cost. Spans record individual steps, with nested spans showing how a whole agent turn was assembled. Evals run tests over those traces and judge outputs that may differ every time. This matters because ordinary unit tests expect an exact string, while many different LLM answers can be correct. Traces diagnose the cause of a failure, while evals provide a score, label, and explanation that can be tracked across changes and model upgrades.
Three kinds of evaluation cover different failure modes
Voss separates evaluation into code evals, LLM-as-a-judge evals, and human review. Code evals are fast and free, and they work for deterministic checks such as valid JSON, length limits, required fields, forbidden phrases, database state, or whether the requested ticker appears in a report. LLM judges assess meaning, including accuracy, grounding, usefulness, and tone, but they cost money and can be unpredictable or wrong. Human reviewers handle failures the team has not anticipated and check whether the LLM judge is behaving correctly. Voss compares the arrangement to the Swiss cheese model: each layer has holes, but the holes do not line up perfectly.
Agents can turn an early mistake into a confident, polished failure
Agent workflows make evaluation harder because an early mistake can cascade through later steps. Voss gives a financial research example in which a search for Tesla returns material about an eighteenth-century inventor. The agent can then produce a grammatical, well-formatted report about the wrong subject, so checks for tone and formatting all pass. She also describes a customer-service benchmark where Claude changed an economy passenger to first class, changed the seat, and downgraded the passenger again. The agent solved the user's practical request, while the benchmark expected it to fail. These examples mean tests must check outcomes flexibly and must account for solutions the designer did not expect.
Reading traces by hand reveals failures that automation would miss
Before writing evals, Voss asks engineers to read a dozen or more traces from end to end. They should record the input, output, and specific problem in ordinary language, then group those observations into categories. She calls the first stage open coding and the second axial coding. Starting with categories in advance is tempting, but it can force unexpected failures into categories that are too narrow, too broad, or simply wrong. In the financial agent, trace inspection exposed harness leakage, hallucinations, reasoning errors, and file-writing attempts. The 116% analyst-consensus error was a reasoning failure: separate search results were combined even though they came from different data sets.
Code evals provide cheap checks for deterministic requirements
Voss's first code eval checks whether a report mentions the stock ticker requested by the user. It catches cases where the agent was asked about Tesla but wrote about Microsoft, or where an AWS question produced a report that ignored the wider Amazon business. The evaluator is an ordinary TypeScript function registered as a code eval. It receives structured input and output, returns a label and score, and explains which ticker was missing. The run takes milliseconds because it does not call another model. Voss says code evals can also check JSON parsing, length limits, database state, tool results, or an external stock price. They should usually grade the outcome rather than demand one exact path through the agent.
An LLM judge is useful only when it can answer the question asked
Phoenix's built-in correctness evaluator failed every report because the judge could not verify fresh October stock data with its earlier knowledge cutoff. Some explanations still identified real inconsistencies, but a score of zero across all reports was not useful. Voss replaces correctness with faithfulness, which asks whether the report follows the research and search results available to the agent. The judge receives the user input, report, raw search results, and research notes. This lets it identify unsupported claims and conflated data points. She also evaluates tool selection, tool arguments, and tool-response handling. The lesson is to choose an evaluative question the judge can actually answer before trying to tune its prompt.
Custom rubrics need precise criteria and must be tested like code
Voss writes a custom actionability judge because the financial report must make a buy, sell, or hold recommendation. Her rubric gives the judge a role and context, states concrete criteria, marks inputs and examples with XML tags, and constrains the output to actionable or not actionable. Criteria such as 'helpful' and 'accurate' are too vague. Her rubric instead asks for a specific recommendation, concrete risks, and forward-looking information. She warns against a single god evaluator that checks accuracy, tone, completeness, formatting, and policy at once. Separate evaluators make failures easier to interpret. Small prompt changes matter: adding XML boundaries changed how the judge interpreted examples and data.
A judge must be compared with human labels before it gates releases
Voss treats an LLM judge as a classifier whose predictions can be right or wrong. She labels reports herself as actionable or not actionable, creating a human golden data set, then compares the judge with those labels. The examples should use the same criteria given to the judge, and the data should be split into development and test sets so the rubric is not tuned on its own test cases. She discusses precision, recall, position bias, length bias, confidence bias, and self-preference. A judge does not need perfect agreement with one human, since human reviewers also disagree. Failures should still seem fair. If a failure looks fine to a reviewer, the eval may be the problem.
Experiments turn prompt changes and model upgrades into measured comparisons
After finding that reports lacked recommendations, invented numbers, or failed to provide supported risks, Voss changes the prompts and reruns the same inputs through an experiment. The experiment compares before and after results with the same evaluators, so a prompt change cannot hide a regression in behavior that previously worked. Actionability improved from 5 of 16 to 48 of 48 in her runs, while faithfulness remained poor, moving from 2 of 16 to 3 of 48. Upgrading from Claude Haiku 4.5 to 5.5 improved consistency and faithfulness, but the newer model became much more conservative and frequently answered hold. The result is evidence about tradeoffs, not a blanket recommendation.