Agent Builder Foundations

LLM-as-judge accuracy on a held-out set is necessary but not sufficient. Judges carry systematic biases — favoring a response's position, its length, or the language it is written in — that raw accuracy numbers hide, and a judge that passes a benchmark can still miss the specific real-world failure mode you built the eval to catch. A separate, more structural gap sits underneath the bias problem: a judge grades the final answer's plausibility, not whether the agent's trajectory actually earned that answer, so a confidently-worded response can score 0.85 or higher from two frontier judges while the trace shows the agent never retrieved the evidence its answer depended on. Treat the judge as a component under test, not as the test — and for agent trajectories with checkable evidence paths, consider replacing the judge with a deterministic scorer instead of only auditing it for bias.

A judge is a classifier with a prompt instead of a training loop, and classifiers have failure modes that don't show up in a single aggregate accuracy number. Two judge designs exist on a spectrum: a frontier LLM prompted to grade (flexible, expensive, occasionally biased in subtle ways) and a small fine-tuned classifier — encoder or distilled LLM — trained on production-labeled examples (cheap, fast, narrower, and only as good as the labels it learned from). Both need the same thing an agent needs: a held-out test set built from real failures, not just the cases the judge was tuned to recognize.

A judge — of either design — grades what the agent said, not what the agent's trajectory can prove. When the task has a checkable evidence path (a document the agent should have retrieved, a time window it should have reasoned within, a causal mechanism it should have used instead of a plausible-sounding one), a deterministic scorer that grades the trajectory directly closes a gap no amount of judge tuning can, because the judge only ever sees the final answer's surface plausibility.

An LLM judge scores a response (or a multi-step trajectory) by generating a verdict conditioned on the response, a rubric, and often a second response to compare against. Because the verdict is itself a model output, it inherits model-level artifacts:

• Position bias — the judge prefers whichever candidate is shown first.
• Verbosity bias — the judge prefers longer text as a proxy for thoroughness.
• Cross-lingual / distribution-shift degradation — the judge loses calibration outside the language or domain it was tuned on.

Swapping the order of the two responses being compared is a direct probe for position bias: if the verdict flips depending on which slot a response sits in, the judge is responding to position, not content.

For agent trajectories specifically, the judge has to score a sequence of tool calls and intermediate decisions, not a single text block, which multiplies the places a bias can hide — a judge can be well-calibrated on final-answer correctness while being unreliable on whether the agent reached that answer through a sound or broken path. Cheaper judge architectures (fine-tuned encoders, distilled small LLMs) trade a wider rubric-following ability for speed and cost, but they are exposed to the same validation requirement: their accuracy has to be measured against the failure modes you care about, not just against the cases used to tune them.

GroundEval targets that broken-path problem head-on by removing the judge from the loop entirely for tasks with checkable evidence. Instead of asking a model to grade a response, it uses a domain configuration to generate questions, lets the agent answer however it chooses, then scores both the final answer and the recorded trajectory against three deterministic tracks: Silence (did the agent actually check before claiming something was absent), Perspective (did it reason only from evidence available to it at the relevant time), and Counterfactual (did it use the real causal mechanism rather than a plausible-sounding one). Because each track grades the trajectory against ground truth the system already knows — what was retrievable, when, and through what causal path — it catches an ungrounded-but-fluent answer that a judge, which only ever sees the final text, cannot detect by construction.

• Benchmark/result-backed: BabelJudge constructs gold-labeled pairs by perturbing known-good answers (no human annotation needed) and measures position bias, verbosity bias, order inconsistency, and cross-lingual degradation directly — showing a judge's raw accuracy (0.835 in Hindi vs. 0.660 in Swahili) can look closer than its bias-penalized reliability (0.714 vs. 0.550) actually is, and that order consistency in the lower-resource language collapses to near-random.
• Benchmark/result-backed: "Do Encoders Suffice?" benchmarks fine-tuned encoder classifiers against LLM-based judges for harmful-output detection across several attack techniques, testing whether a cheaper, lower-latency judge architecture holds up without a major accuracy loss.
• Production field-report-backed: LangChain and Fireworks fine-tuned a small open model on production trace labels and matched frontier-judge performance at roughly 1/100th the cost — evidence that judge behavior can be distilled, measured, and re-validated rather than locked to whichever frontier model wrote the first version.
• Production field-report-backed: a practitioner postmortem on a real eval miss shows a judge and eval suite scoring a production failure as a pass, which is the failure mode no amount of judge-accuracy reporting alone would surface.
• Benchmark/result-backed: GroundEval's case study shows two frontier LLM judges scoring a plausible agent response 0.85 or higher while the recorded trajectory reveals the agent never retrieved the artifact its answer depended on — a GroundEval score of 0.000 — and the paper's case studies suggest this ungrounded-but-plausible failure is common, not exceptional.
• Editorial inference: the practical implication is that "judge accuracy" is a claim that needs the same skepticism and held-out testing as any other model output the agent produces.

Before trusting a judge's verdicts, run these checks:

• Order-swap test. Run every pairwise comparison both ways and only count verdicts that agree.
• Verbosity check. Track response length against verdict to catch verbosity bias.
• Per-slice reliability. If you operate in more than one language or domain, measure judge reliability per slice instead of reporting one pooled number.
• Held-out set from real failures. Build it from production failures your team has actually seen, not synthetic cases the judge would obviously get right — a judge that's accurate on easy cases and silent on the hard one you cared about is failing at its job.
• Re-validate before swapping in a cheaper judge. If cost matters, validate a fine-tuned encoder or distilled small model against the same held-out set before shipping it, and re-run validation whenever the underlying model, prompt, or rubric changes.
• Check groundedness, not just plausibility, for agent trajectories. If the task has a checkable evidence path — a document that should have been retrieved, a time boundary the reasoning must respect, a causal mechanism it must use — grade the recorded trajectory against that ground truth directly instead of asking a judge whether the final answer sounds right.

• Aggregate accuracy worship: reporting one pooled accuracy number and missing that it hides a collapse in a specific slice (language, position, length band).
• Order blindness: never testing whether a pairwise verdict flips when you swap which response sits in which slot.
• Benchmark-only validation: tuning and validating a judge on the same kind of cases, so it never sees the production failure mode the eval exists to catch.
• Set-and-forget judges: shipping a judge once and never re-validating it after the agent, prompt, or underlying judge model changes.
• Treating cost-cutting as free: swapping in a cheaper judge architecture for cost reasons without re-running the same bias and accuracy checks used on the original judge.
• Grading the answer, not the path: trusting a judge's high score on a fluent final answer without checking whether the trajectory that produced it actually retrieved the right evidence, respected the right time boundary, or used the right causal mechanism.

See agent evaluation for the broader problem of grading agent trajectories, LLM-as-judge for the model-graded evaluation pattern this concept interrogates, and does a high benchmark score predict production reliability? for the adjacent problem of whether the benchmark itself, not just the judge, predicts real-world behavior.