LLM-as-a-judge: calibrate it before you trust it

How to make an LLM judge reliable — aligning it to human labels, killing position and verbosity bias, and knowing when a judge is measuring quality versus its own preferences.

Definition

LLM-as-a-judge is the use of a language model to score or compare the outputs of an AI agent against criteria. It scales evaluation cheaply but must be calibrated against human labels, because judges exhibit position, verbosity and self-enhancement biases that distort scores.

An LLM judge is the only practical way to score agent outputs at scale. It is also confidently wrong the moment you trust it uncalibrated. The discipline is simple to state and easy to skip: align the judge to humans first.

Why does an uncalibrated judge lie?

A judge that has not been checked against human labels does not measure quality — it measures its own preferences. Three biases are well documented:

  • Position bias. The judge favors the option shown first or last, regardless of content.
  • Verbosity bias. Longer answers score higher just for being longer.
  • Self-enhancement. The judge prefers outputs written in its own style, which is dangerous when it grades a sibling model.

Run a judge without controlling for these and your scores drift in ways that look like signal but are noise.

Judges score in a few modes, and the mode shapes which bias you must control:

Scoring mode How it works Best for
Pointwise Score one output against a rubric Absolute thresholds and tracked metrics
Pairwise Compare two outputs, pick the better Choosing between models or prompts
Reference-based Grade against a known-good answer Tasks with a gold answer

Calibration, step by step

  1. Build a labeled set. Take 100–200 representative cases and have a human score them against a clear rubric.
  2. Run the judge on the same cases.
  3. Measure agreement. Use a statistic such as Cohen’s kappa; aim for roughly 0.6 or higher. Below that, the judge is not ready.
  4. Inspect disagreements. They reveal whether the problem is the rubric, the judge, or the labels.
  5. Re-check periodically. Models change; a judge calibrated last quarter may have drifted.

Killing the biases

  • Randomize option order on every comparison to neutralize position bias.
  • Control for length — penalize padding, or normalize, so verbosity earns nothing.
  • Cross-family judging. For high-stakes gates, let one model family judge another to blunt self-enhancement.
  • Use rubrics, not vibes. “Rate 1–10” invites bias; explicit criteria with examples constrain it.

Where the judge fits

A calibrated judge is the engine of scalable evals: it scores your golden dataset on every change so regressions surface before users meet them. Pair it with spot human review for the cases that matter most. An uncalibrated judge is worse than none — it gives you false confidence. Calibrate first, then automate. Terms are in the glossary.

Frequently asked questions

How many human labels do I need to calibrate a judge?

Around 100 to 200 carefully labelled, representative examples is a workable starting point for most tasks, and the emphasis is on representative and careful rather than on the raw number. The examples should span the real range of outputs you will ask the judge to score, including the close calls and the failure modes you care about, because a judge that agrees with you on easy cases but diverges on the hard ones is not calibrated where it matters. Label them against the same explicit rubric the judge will use, run the judge over the set, and measure agreement with a statistic like Cohen's kappa, aiming for roughly 0.6 or higher before you rely on it at scale. If agreement is low, inspect the disagreements: they usually reveal an ambiguous rubric, a biased judge prompt, or inconsistent human labels, and fixing the rubric often helps more than adding examples. Re-check periodically, because a model upgrade can quietly move the judge's behaviour and silently invalidate last quarter's calibration.

What biases should I actively counter?

Three are well enough documented to design against by default. Position bias is the tendency to favour the option shown first or last regardless of content, and you counter it by randomising option order on every comparison and, for important gates, averaging the score across both orderings. Verbosity bias is the tendency to rate longer answers higher just for being longer, which you counter by scoring against an explicit rubric and penalising or normalising for padding so length earns nothing on its own. Self-enhancement is the tendency to prefer outputs written in the judge's own style, which is especially dangerous when a model grades a sibling from the same family; the defence is cross-family judging, letting a different model family score the one under test. Underlying all three is the same fix: replace vague rate-it-out-of-ten prompts with explicit criteria and worked examples, because the more you leave to the judge's taste, the more its biases fill the gap.

Can the judge be the same model as the agent?

It can, and for low-stakes, high-volume scoring it is often perfectly fine, but self-enhancement bias makes it risky for any comparison that gates a decision. The problem is that a model tends to prefer outputs written in its own style, so when it judges a sibling from the same family it can reward familiarity rather than quality, quietly tilting the result. For important gates the safer choice is cross-family judging: have a different model family score the one under test, which blunts the bias because the judge has no stylistic stake in the output. If you must use the same model — for cost or simplicity — at minimum validate that same-model judging still agrees with human labels on your calibration set, and watch the agreement over time. A practical compromise is to use the same model for cheap, frequent screening and bring in a different family plus human spot-checks for the high-stakes comparisons that actually decide a release.

Pairwise or pointwise scoring — which should I use?

It depends on the question you are answering, and most mature setups use both for different jobs. Pointwise scoring grades a single output against a rubric on an absolute scale, which is what you want when you need a threshold — is this answer good enough to ship — and when you are tracking a metric over time on a fixed set. Pairwise scoring shows the judge two outputs and asks which is better, which is more reliable when you are comparing two models, two prompts or two versions, because relative judgements are easier and more consistent for a model to make than absolute ones. The trade-off is that pairwise is noisier to turn into a single number and more exposed to position bias, so you must randomise order, while pointwise depends heavily on a well-anchored rubric to stay stable. A common pattern is pairwise for choosing between candidates during development and pointwise for the production gate that has to output a pass-or-fail against a bar. Pick the mode that matches the decision, and calibrate whichever you choose.