Agent Builder Foundations

LLM-as-judge accuracy on a held-out set is necessary but not sufficient. Judges carry systematic biases toward position, length, and language that raw accuracy hides, and a judge that passes a benchmark can still miss the real failure the eval exists to catch.

A deeper gap sits underneath: a judge grades the answer's plausibility, not whether the trajectory earned it. In GroundEval's case study, two frontier judges scored an answer 0.85 or higher although the agent never retrieved the evidence it depended on. Treat the judge as a component under test, and where trajectories have checkable evidence, replace it with a deterministic scorer.

A judge is a classifier with a prompt instead of a training loop, and classifiers fail in ways one aggregate accuracy number doesn't show. Judge designs sit on a spectrum:

• Prompted frontier LLM: flexible, expensive, subtly biased.
• Small fine-tuned classifier (encoder or distilled LLM) trained on production labels: cheap, fast, narrower, only as good as its labels.

Both need what an agent needs: a held-out test set built from real failures, not the cases the judge was tuned on.

Either design grades what the agent said, not what its trajectory can prove. When the task has a checkable evidence path — a document that should have been retrieved, a time window to reason within, a causal mechanism to use — a deterministic scorer over the trajectory closes a gap no judge tuning can.

An LLM judge produces a verdict conditioned on the response, a rubric, and often a second response to compare. Because the verdict is a model output, it inherits model-level artifacts:

• Position bias: preferring whichever candidate is shown first.
• Verbosity bias: preferring longer text as a proxy for thoroughness.
• Distribution-shift degradation: losing calibration outside the language or domain it was tuned on.

Swapping the order of compared responses probes position bias directly: if the verdict flips with the slot, the judge is responding to position, not content. BabelJudge shows how much raw accuracy hides here; order consistency fell to 0.480 in Swahili, near random.

Agent trajectories multiply the places bias can hide. The judge scores a sequence of tool calls and decisions, and can be well calibrated on final-answer correctness while unreliable on whether the path was sound. Cheaper judges (fine-tuned encoders, distilled small LLMs) trade rubric flexibility for cost and speed, and face the same requirement: measure them against the failures you care about, not the cases used to tune them.

Deterministic trajectory scoring removes the judge where evidence is checkable. GroundEval generates questions from a domain configuration, lets the agent answer freely, then scores the answer and recorded trajectory on three tracks:

• Silence: did the agent check before claiming something was absent?
• Perspective: did it reason only from evidence available at the relevant time?
• Counterfactual: did it use the real causal mechanism, not a plausible one?

Each track grades against ground truth the system already knows — what was retrievable, when, and through what path — so it catches a fluent, ungrounded answer that a judge reading only the final text cannot detect by construction.

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

• Order-swap test. Run every pairwise comparison both ways and count only verdicts that agree.
• Verbosity check. Track response length against verdict.
• Per-slice reliability. Across languages or domains, report reliability per slice, not one pooled number.
• Held-out set from real failures. Use production failures your team has seen, not synthetic cases the judge obviously gets right; a judge accurate on easy cases and silent on the hard one is failing.
• Stability and human-agreement checks. Re-score identical inputs several times and track variance; compare against human labels with a chance-corrected metric.
• Re-validate before swapping in a cheaper judge. Test any encoder, distilled model, or decision model on the same held-out set; tune its threshold on your data, measure calibration, and re-run whenever the model, prompt, or rubric changes.
• Check groundedness, not plausibility, for trajectories. Where the task has a checkable evidence path, grade the recorded trajectory against that ground truth instead of asking a judge whether the answer sounds right.

• Aggregate accuracy worship: one pooled number hiding a collapse in a slice (language, position, length band).
• Order blindness: never testing whether a pairwise verdict flips when the slots swap.
• Benchmark-only validation: tuning and validating on the same kind of cases, so the judge never sees the production failure the eval exists to catch.
• Set-and-forget judges: never re-validating after the agent, prompt, or judge model changes.
• Free cost-cutting: swapping in a cheaper judge without re-running the same bias and accuracy checks.
• Default threshold: shipping a decision model at 0.50 without tuning or calibrating it.
• Grading the answer, not the path: trusting a high score on a fluent answer without checking that the trajectory retrieved the right evidence, respected the time boundary, and used the right mechanism.

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