LLM-as-a-Judge is an evaluation method in which a large language model (LLM) scores another model’s output against stated criteria. It lets teams assess open-ended outputs at a volume that human reviewers cannot keep up with.
For example, suppose you ask a judge to decide whether 200 support answers are faithful to their source documents. You already have human labels for those 200 answers. The judge agrees with the humans on 176 of them, or 88%. That number alone looks good, but the judge passes 14 of the 40 answers that humans marked unfaithful, so it is not yet ready to block releases.
Build better agents with Arize
Trace, evaluate, and learn. Build agents that work with Arize AX and start tracing your runs today.
Prefer open source? Try Arize Phoenix for self-hosted, open source agent observability.
Why LLM-as-a-Judge matters for AI evaluation
Many LLM and agent outputs have no single correct string. A good summary, a helpful answer, or a policy-compliant reply can be worded many ways, so exact matching cannot grade them.
LLM-as-a-Judge is useful for:
- Scaling review: Score thousands of outputs when human review of every one is too slow or expensive.
- Comparing versions: Pick the better of two outputs from different prompts or models.
- Checking qualities that need judgment: Assess relevance, faithfulness to a source, or policy compliance.
- Triaging for humans: Flag likely failures so reviewers spend time on the cases that matter.
A judge is an evaluator with a prompt, criteria, and an output format. It is not an oracle. Its verdicts are only as trustworthy as the validation behind them.
For more on where judges fit among other methods, see LLM evaluation.
How LLM-as-a-Judge works
In a typical setup, the judge receives four things:
- The original input, such as the user’s question.
- The output being assessed.
- Any reference material, such as the retrieved source documents.
- An instruction that describes what “good” means for this task.
The judge returns a structured verdict. Common formats include:
- Pass or fail: A binary label for one criterion.
- Scale score: A rating on a defined scale, such as 1 to 5.
- Pairwise choice: The better of two outputs.
- Label plus rationale: A verdict with a short written explanation.
The judge can assess another model’s output or the output of the same model that produced it.
A simple judge prompt
The following template asks for one criterion and a fixed output format. The placeholders in braces are filled in for each case.
You are evaluating whether an answer is faithful to its source.
Question: {question}
Source documents: {sources}
Answer: {answer}
An answer is faithful if every claim in it is supported by the source documents.
An answer is unfaithful if it contains any claim the sources do not support.
Respond with one word, "pass" or "fail", then one sentence explaining why.
This prompt gives the judge the source material it needs. A judge asked to verify facts without a source has to rely on what the model already knows.
When to use LLM-as-a-Judge, and when not to
Use a judge when all three of these are true:
- The quality is a matter of judgment: No simple rule can decide it.
- The volume is high: Reviewers cannot label every output.
- You can validate it: You can build a human-labeled sample to compare against.
Judges are a poor substitute for checks that can be done exactly. If a field must match a pattern, a date must be valid, or code must pass tests, run those checks directly. Reserve the judge for the judgment call that remains.
Do not use an unvalidated judge as the only gate for a high-stakes release. Do not ask a judge to verify facts it has no source for. Give it the source material, or use a retrieval or exact check instead.
The related pattern of agents that evaluate agents extends the same idea to multi-step agent behavior. There, the thing being judged is a trajectory rather than a single response.
How to validate a judge against human labels
Validation means comparing judge verdicts with human evaluation on the same sample. Measure agreement overall and by case type.
Measure agreement in Python
The following script computes agreement for the 200-answer example. Each row records the case type, the human label, and the judge label.
rows = ( # (case_type, human_label, judge_label)
[("direct quote", "pass", "pass")] * 120
+ [("direct quote", "fail", "fail")] * 24
+ [("direct quote", "pass", "fail")] * 4
+ [("direct quote", "fail", "pass")] * 2
+ [("synthesis", "pass", "pass")] * 30
+ [("synthesis", "fail", "fail")] * 2
+ [("synthesis", "pass", "fail")] * 6
+ [("synthesis", "fail", "pass")] * 12
)
def agreement(subset):
matches = sum(human == judge for _, human, judge in subset)
return matches, len(subset)
matches, total = agreement(rows)
print(f"overall: {matches}/{total} = {matches / total:.0%}")
for case_type in ("direct quote", "synthesis"):
subset = [r for r in rows if r[0] == case_type]
matches, total = agreement(subset)
print(f"{case_type}: {matches}/{total} = {matches / total:.0%}")
human_fails = [r for r in rows if r[1] == "fail"]
missed = sum(judge == "pass" for _, _, judge in human_fails)
print(f"unfaithful answers the judge passed: {missed}/{len(human_fails)}")
Output:
overall: 176/200 = 88%
direct quote: 144/150 = 96%
synthesis: 32/50 = 64%
unfaithful answers the judge passed: 14/40
Interpret the results
| Case type | Answers | Judge agrees with humans | Agreement |
|---|---|---|---|
| Direct quote from one source | 150 | 144 | 96% |
| Synthesis across several sources | 50 | 32 | 64% |
| All answers | 200 | 176 | 88% |
The overall 88% hides a weak spot. The judge is reliable when an answer quotes one source directly. It struggles when an answer combines several sources.
The direction of the errors matters too. Of the 40 answers humans marked unfaithful, the judge passed 14. If this judge gated releases, those failures would ship.
Fix the rubric and recheck
Read every disagreement and decide whether the human or the judge was right. Then fix the rubric. In this example, you might add a definition and an example of a faithful multi-source answer.
Recheck agreement after you change the judge model, the rubric, or the output format. Each of those changes can shift the judge’s behavior.
How to write a good judge rubric
Judge quality lives in the evaluation rubric. A good rubric has explicit criteria, defined scale points, and examples.
- One criterion per judge: A single call that assesses five unrelated qualities produces noisy verdicts. Split them where the decision matters.
- Defined labels: Say exactly what earns a pass or a fail, or what each scale point means.
- Worked examples: Show the judge a clear pass, a clear fail, and a borderline case.
- Required inputs: Give the judge the source material or reference it needs to decide.
For the full method, including judge prompts, scoring versus pairwise comparison, bias, and alignment, see the LLM-as-a-Judge guide.
Limitations of LLM-as-a-Judge
Judges have known weaknesses. The framing is commonly traced to Zheng et al. (arXiv:2306.05685), which also documents early biases.
- Length preference: Judges can favor longer outputs even when they are no better.
- Confidence preference: A confident tone can earn a higher score than the content deserves.
- Self-similarity: Judges can prefer outputs that resemble their own style.
- Inconsistency on borderline cases: The same case can receive different verdicts on different runs.
- Missing knowledge: A judge can miss errors that require knowledge it was not given.
Trust requires a clear rubric, a human-labeled validation set, ongoing agreement checks, and exact checks wherever possible.
LLM-as-a-Judge vs. LLM evaluation
LLM evaluation is the broader practice of assessing model and application quality. LLM-as-a-Judge is one method inside it, which uses a model as the assessor.
Other evaluation methods include exact and code-based checks, human review, and reference-based metrics. Most teams combine several of them.
Whether an output is simply right is covered under correctness. A judge is one instrument for assessing it.
Frequently asked questions
Is LLM-as-a-Judge the same as LLM evaluation?
No. LLM evaluation is the broader practice, and LLM-as-a-Judge is one method within it. Other methods include exact and code-based checks, human review, and reference-based metrics.
How accurate is an LLM judge?
It depends on the task, the rubric, and the judge model, so you have to measure it on your own outputs. Compare its verdicts with human labels on a sample and report where disagreements concentrate. Do not assume a judge is accurate because it sounds authoritative.
Should an LLM judge gate a release?
Only after you validate it against human judgment for that task. Pair it with exact checks for anything that can be verified mechanically. Before validation, a judge can still rank experiments or flag cases for review.
Should I use a pass/fail label or a 1-to-5 score?
Use whichever format your rubric can define clearly. A score scale needs a written definition for every point. Prefer one clear criterion per judge where the decision matters.
Where should I learn to implement LLM-as-a-Judge?
Start with the LLM-as-a-Judge guide. It covers rubric design, judge prompts, validation, and implementation in depth.
Putting LLM-as-a-Judge to work
Start with one criterion that matters for your application, such as faithfulness to retrieved sources. Write a rubric, label a sample by hand, and measure the judge’s agreement by case type before you rely on it.
Record the judge model, the rubric version, and the agreement results with every evaluation run. That way, a change in scores can be traced to a change in the system rather than a change in the judge.
Tools such as Arize Phoenix and Arize AX can help you run judge evaluations over your traces and review each verdict next to the output it assessed.
