The maturity phases of running evals — Phil Hetzel, Braintrust

Phil Hetzel, Head of Solutions Engineering at Braintrust, presents a practical framework for thinking about evaluation maturity across four progressive stages for AI agents. The talk reframes the common misconception that evals should work like unit tests — exhaustively covering every conceivable failure — and argues instead that teams should enumerate their known failure modes, build evals specifically around those, and ship. The goal is a continuous flywheel: production traces surface what is going wrong in real usage, those traces feed back into offline experimentation, and that experimentation guides the next agent improvement cycle.

Hetzel outlines four maturity stages as a rough continuum rather than discrete steps. Stage one is "vibe checking," which he defends as a valid starting point rather than dismissing it outright. The key improvement over pure gut-feel vibe checking is documentation: human annotators — ideally domain experts rather than just the agent builder — should provide thumbs up/thumbs down ratings on a sample of 10 or more agent outputs, but critically must also write a justification for each rating. These justifications are what allow the team to eventually extract domain-specific knowledge and scale it through automated techniques.

Stage two is LLM-as-judge, built on top of those documented human justifications. Teams use tools like Cursor, Claude Code, or Codex to derive formal failure mode definitions from the annotator justifications, then construct LLM scoring functions that approximate human judgment at scale. Hetzel emphasizes that LLM judges should themselves be evaluated — just because you put a "robe and cloak" on an LLM does not make it trustworthy by default. He also notes that some failure modes can be evaluated deterministically via code, such as checking whether an agent consumed too many tokens or made too many tool calls, without needing an LLM judge at all. At this stage, teams should be ingesting real production traces or at least UAT-level traces into their evaluation datasets, so evals approximate running production rather than synthetic test cases.

Stage three addresses the complexity introduced when agents interact with external systems via tool calls. Hetzel distinguishes two categories: context-gathering tools that read data and inject it into the LLM context window (manageable), and CRUD-based tools that create, read, update, or delete records in external databases or APIs (significantly harder). The CRUD problem has two core challenges: representing the exact state of an external system at the moment the original trace was recorded, and avoiding modification of production data when replaying that trace offline. Hetzel describes two emerging techniques to address this. First, agent traces can be arbitrarily large compared to application traces, which means the full system state at the time of the original trace can be captured and injected directly into the trace itself as context, rather than requiring a separate test infrastructure to recreate that state. Second, for systems that support it, timestamp-based version queries against a vector database can retrieve the state of that data store as it existed at the specific moment the original trace ran, producing an accurate historical snapshot.

Stage four touches briefly on advanced techniques Hetzel plans to discuss at the Braintrust booth: topic modeling at scale to automatically surface failure modes from production traces, and integrating evals into CI/CD pipelines using cloud-based agents and eval provider CLIs for automated regression testing.

In a closing audience Q&A, Hetzel addresses whether deterministic graders should be preferred over LLM-as-judge. His view is to embrace LLM-as-judge for subjective quality dimensions — which is precisely where agents add value — but to rigorously eval the judge itself against a human-labeled ground truth dataset, since judge outputs are discrete and a ground truth set is straightforward to construct.