{"slug":"agent-eval-design","title":"What should an agent eval actually measure?","question":"What should an agent eval actually measure?","summary":"A useful agent eval grades the trajectory as well as the output, matches grader cost to check frequency, repeats runs per configuration, and is audited as hard as the agent: fixing one eval moved a score from 42% to 95%.","status":"active","cluster":"evaluation","cluster_label":"Evals and reliability","updated":"2026-10-14","latest_evidence_added":"2026-10-14","audience":"strong-software-engineer","math_depth":"","sections":[{"heading":"Builder consequence","html":"<p>A low eval score usually gets read as &quot;the agent failed.&quot; Anthropic reports a case where that read was wrong: Opus 4.5&#x27;s CORE-Bench score rose from 42% to 95% once the team fixed grading bugs, ambiguous task specs, and stochastic tasks in the eval. The agent never changed. Before you spend a cycle improving an agent that scored badly, spend an hour checking whether the eval is what&#x27;s broken.</p>"},{"heading":"Short answer","html":"<p>An agent eval is an input plus grading logic, and the grading logic is usually the weak link. Three grader types trade cost against accuracy: code-based graders are cheap and objective but only check what you encoded; model-based graders handle nuance but are non-deterministic and expensive; human graders set the bar but don&#x27;t scale.</p>\n<p>Because agents vary run to run, one pass/fail number isn&#x27;t enough. <strong>pass@k</strong> asks whether the agent can solve the task at all; <strong>pass^k</strong> asks whether it solves it every time. And a bad score on either can mean the eval, not the agent, is broken.</p>"},{"heading":"Builder model","html":"<p>Treat an eval as software with the usual failure surface: bugs, ambiguous specs, and flaky behavior. All three produce the same symptom as a real agent failure — a low score.</p>\n<ul><li><strong>Grader choice is a cost/accuracy trade-off.</strong> Code-based graders (unit tests, string checks, static analysis) can run on every commit but only check what you encoded. Model-based graders catch nuance but add their own non-determinism; see <a href=\"/foundations/llm-judge-reliability\">can you trust an LLM-as-judge score?</a>. Human graders calibrate the others. Real suites mix all three, matched to how often each check must run.</li><li><strong>One score hides whether failure is rare or reliable.</strong> An agent that solves a task 1 of 5 times and one that solves it 4 of 5 times both fail pass^5. The second is near production-ready behind a retry; the first is not solving the task.</li><li><strong>The unit under test is the system.</strong> Task information, tools, budget, and model all move the score, so a result describes the configuration, not the model alone.</li></ul>"},{"heading":"Mechanism","html":"<p><strong>Start from real failures.</strong> Anthropic recommends 20-50 tasks drawn from cases that actually went wrong. Each needs an unambiguous spec and a reference solution; ambiguity produced the 42%-to-95% CORE-Bench jump. Include negative cases where the right behavior is to refuse or say it doesn&#x27;t know; solvable-only suites cannot detect overconfidence.</p>\n<p><strong>Keep the environment stable and grade outcomes.</strong> A flaky sandbox produces noise indistinguishable from a regression. Exact step matching penalizes a correct result reached by a different path, so grade the outcome and, separately, the trajectory.</p>\n<p><strong>Grade the artifact each agent type produces.</strong></p>\n<ul><li>Coding: unit tests for the outcome, a transcript pass for process.</li><li>Conversational: backend state verification plus an LLM rubric for tone.</li><li>Research: groundedness, coverage, and source quality as separate checks.</li><li>Computer use: interface state (DOM, screenshots) and backend state, since a correct-looking screen can hide a failed action.</li></ul>\n<p><strong>Measure the configuration, repeatedly.</strong> In an 18,000-trajectory study of coding agents, 54% of outcome variance was run-to-run noise within identical configurations, and task information moved results more than time budget or model size. A verification tool changed behavior where a verification prompt barely did. TRACE found identical reruns flip 15-36% of task outcomes.</p>\n<p><strong>Test the scorer when a score moves.</strong> A score change can come from the scoring rule, not the agent. TRACE rescored unchanged trajectories after renaming tools: restoring the names at scoring time erased a 0.250 drop in a scripted agent.</p>\n<p><strong>Audit the simulated tools.</strong> Benchmarks grade what a simulated tool reports having done. An audit of 34 mutating tools in four benchmarks confirmed seven tool defects; in one clinical benchmark the tool claimed writes it never made, and the grader scored that claim as success. A defect like this is present on every rerun, so repeated runs never expose it.</p>\n<p><strong>Watch for saturation.</strong> Once scores plateau near the ceiling, the eval stops separating good from great, and further optimization tunes to its blind spots — the dynamic covered in <a href=\"/foundations/benchmark-production-reliability-gap\">does a high benchmark score predict production reliability?</a>.</p>"},{"heading":"How to apply","html":"<ul><li><strong>Audit the eval before touching the agent.</strong> When a score looks bad, read failing transcripts by hand and check for ambiguous specs, wrong reference solutions, or a grader that missed a valid path.</li><li><strong>Start from 20-50 real failures.</strong> A small set from production catches the failures that matter faster than a large synthetic one.</li><li><strong>Report pass@k and pass^k.</strong> They answer &quot;can it ever solve this&quot; and &quot;can I trust it every time&quot;; one aggregate hides which you have.</li><li><strong>Match grader type to cadence.</strong> Code-based graders for anything deterministic, on every commit; model-based graders for tone, groundedness, and nuance; humans for periodic calibration of the automated graders.</li><li><strong>Grade the trajectory as well as the output.</strong> A lucky pass through a bad process is a risk the outcome score won&#x27;t show.</li><li><strong>Rescore before you blame the agent.</strong> After a score change, rescore the unchanged trajectories under the old format; if the gap closes, the scorer moved, not the agent.</li><li><strong>Run each configuration several times and report the spread.</strong> At 54% run-to-run variance, a single run is mostly noise.</li><li><strong>Change behavior with tools, not prompt lines.</strong> Treat task information, budget, and tooling as explicit eval dimensions, and test self-verification as a tool or dedicated component.</li><li><strong>Check the tools against their contract.</strong> Probe each mutating tool in the eval and confirm the state it reports matches the state it wrote.</li><li><strong>Retire saturated evals.</strong> At ceiling, raise the difficulty or discount further gains.</li></ul>"},{"heading":"Failure modes","html":"<ul><li><strong>Debugging the wrong thing:</strong> changing the agent to chase a low score without checking the eval for ambiguous specs, wrong references, or grader bugs.</li><li><strong>One aggregate score:</strong> hiding whether failure is occasional (decent pass@k, bad pass^k) or total.</li><li><strong>Exact step matching:</strong> penalizing a correct result reached by a different valid path.</li><li><strong>No negative cases:</strong> overconfidence and unwarranted refusals never get caught.</li><li><strong>Trusting tool output as ground truth:</strong> a defective simulated tool makes the grader reward actions that never happened.</li><li><strong>Brittle scorers:</strong> a verifier that keys on tool names or output formatting turns a cosmetic change into a fake regression.</li><li><strong>Single-run comparisons:</strong> run-to-run variance read as a real difference.</li><li><strong>Misattribution:</strong> crediting the model for a change when task information, budget, or tooling also changed.</li><li><strong>Optimizing a saturated eval:</strong> tuning to its blind spots instead of real capability.</li></ul>"},{"heading":"Related","html":"<p>See <a href=\"/topic/agent-evaluation\">agent evaluation</a>, <a href=\"/topic/agent-benchmarks\">agent benchmarks</a> for where public benchmarks diverge from your own eval, <a href=\"/foundations/llm-judge-reliability\">can you trust an LLM-as-judge score?</a> for model-based grader failures, and <a href=\"/foundations/benchmark-production-reliability-gap\">does a high benchmark score predict production reliability?</a> for reading a score as a production claim.</p>"}],"evidence":[{"id":"arxiv-2609-37315-executable-contract-audit","kind":"benchmark-result","tier":"benchmark/result-backed","title":"Do Agent Benchmarks Do What They Say? An Executable-Contract Audit of Tool-Using Agent Environments","note":"Checks each simulated tool against its advertised interface across 34 mutating tools in four benchmarks and confirms seven tool defects plus one evaluator property. On AgentDojo, at least 5 of 25 mutating tools diverge from their contract. On tau2-bench, the evaluator rewards a refuel of a suspended line and fails the repaired tool. A clinical benchmark's tool reports writes it never made, and its grader counts that message as success.","added":"2026-10-14","url":"https://arxiv.org/abs/2609.37315","sid":"ec84f4f58551c9cf"},{"id":"arxiv-2610-11678-trace-verifier-brittleness","kind":"benchmark-result","tier":"benchmark/result-backed","title":"TRACE: Diagnosing Verifier Brittleness in Agentic Evaluation","note":"Protocol that mutates one part of an eval, compares paired runs, and rescores unchanged trajectories. Renaming tools cut a scripted agent's score by 0.250 with identical operations; restoring names at scoring time closed the gap. On tau2-bench (88 tasks), misleading tool names lowered every agent's reward 0.20-0.44, while identical reruns flipped 15-36% of outcomes. Two frontier judges disagreed on 57% of records.","added":"2026-10-09","url":"http://arxiv.org/abs/2610.11678v1","sid":"10abc73be739f08b"},{"id":"arxiv-2610-01618-agents-are-systems","kind":"benchmark-result","tier":"benchmark/result-backed","title":"Agents Are Systems, Not Models: Rethinking Agentic Evaluation","note":"Runs a coding agent on four scientific tasks that require operating specialist models, across more than 18,000 trajectories varying task information, reasoning approach, self-verification, time budget, and backbone model. 54% of outcome variance came from run-to-run variability within identical configurations. Task information had the largest effect, above time budget or model size; extra time helped only with enough information or a capable model. Verification tools changed behavior substantially; verification prompts had minimal effect.","added":"2026-10-02","url":"http://arxiv.org/abs/2610.01618v1","sid":"068e3817b6d56fbd"},{"id":"anthropic-2026-demystifying-agent-evals","kind":"primary-doc","tier":"primary-doc-backed","title":"Demystifying evals for AI agents","note":"Anthropic's guide to building agent evals. Names three grader types: code-based (fast, cheap, objective), model-based (flexible, non-deterministic, expensive), and human (best quality, slowest). Recommends starting from 20-50 real-failure tasks with unambiguous specs and reference solutions, positive and negative cases, isolated environments, and outcome grading over step matching. Defines pass@k and pass^k. Reports Opus 4.5's CORE-Bench score rising from 42% to 95% after fixing grading bugs, ambiguous specs, and stochastic tasks in the eval.","added":"2026-09-02","url":"https://www.anthropic.com/engineering/demystifying-evals-for-ai-agents","sid":"6c790a16de0afd2b"},{"id":"agent-eval-design-editorial-synthesis","kind":"editorial-inference","tier":"editorial inference","title":"LLM Digest synthesis","note":"A low eval score is a claim about two things at once: the agent's behavior and the eval's own correctness. Builders default to debugging the first without checking the second. Treat the eval as software that needs its own bug-fixing pass before trusting what it reports about the agent.","added":"2026-09-02"}],"related_topics":[{"slug":"agent-evaluation","title":"Measuring whether an agent actually worked is hard"},{"slug":"agent-benchmarks","title":"Agent benchmarks: fixed tasks that exercise real tool use"}],"related_playbook_cards":[],"related_storylines":[]}