LLM as a Judge: How AI Checks AI Work

LLM as a judge means one language model grades another model's answers, instead of a human reading every answer. The judge gets the task, the answer and a standard, and returns a verdict such as "correct" or "incorrect", a score from 1 to 5, or "answer A is better". It comes in three forms: grading against a rubric, pairwise comparison, and grading against a reference answer. It is fast and scales, but has documented weaknesses: the judge often prefers the first answer, the longer one, and possibly its own. For drafts, bulk tests and first-pass checks an AI judge is enough. Where a mistake costs money, has legal consequences or leaves the house, a human decides.

I work with AI employees built on Claude Code every day, and I have a house rule: whoever produced something does not review it themselves. Everything that leaves the house is checked first by a separate role, usually a language model in its own context. Everything about agents is collected on my page AI Agents: Understand, Build, Manage.

What LLM as a judge is and what research shows

A key study is Zheng et al. from 2023: "Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena". Open-ended answers cannot be checked with a simple match, and humans are slow and expensive at it. So the researchers had strong language models grade other models' answers. The strongest judge in the study, GPT-4, agreed with human raters in over 80 percent of cases, as often as humans agree with each other. The study names two advantages: the method scales, and the judge explains its score, which is the part you can check.

Anthropic, the company behind Claude, frames it like this in its documentation on evaluations: code-based grading is fastest but rigid. Human grading is the most flexible but slow and expensive. LLM-based grading is fast and suits complex judgment, with one condition: test for reliability first, then scale.

Three methods: rubric, pairwise comparison, reference answer

The rubric is the easiest place to start: you write down what makes a good answer, and the judge checks each point. Anthropic gives three tips: detailed, clear rubrics, an unambiguous output format (for example only "correct" or "incorrect"), and a grader that may reason before scoring. An example rubric for a customer email:

Grade the answer against these criteria:
1. Does it only state prices and deadlines that appear in the attached price list?
2. Does it answer the customer's question in the first paragraph?
3. Does it avoid any promise that is not in the documents?
For each criterion output "met" or "not met" with one sentence of reasoning,
then the verdict "approve" or "back to the author".

Pairwise comparison fits when you are testing two prompts or two models.

The reference answer helps where the judge itself is unsure. In Zheng et al., the judge graded simple maths questions wrongly although it could solve them on its own: the answers in front of it misled it. With a separately generated model solution in the grading prompt, the failure rate in their test fell from 70 to 15 percent. Setting such criteria before the work starts is the topic of Spec-Driven Development With AI Agents.

Known weaknesses: position, length, self-preference

An AI judge has preferences that have nothing to do with quality. The numbers come from studies from 2023 and 2024 with the models of the time, newer ones may do better.

• Position bias. The judge prefers an answer because it comes first. In Zheng et al., even GPT-4 gave the same verdict in only 65 percent of cases when the order of two similar answers was swapped. In Wang et al. (2023), the order alone let the smaller model Vicuna-13B beat ChatGPT on 66 of 80 questions, with ChatGPT as the judge.
• Verbosity bias. The judge rates the longer answer higher, even if it is not clearer or more accurate. Zheng et al. padded answers with a reworded repeat of the same list. Claude-v1 and GPT-3.5 fell for it in 91.3 percent of cases, GPT-4 in 8.7 percent.
• Self-preference. The judge rates texts from its own model higher. Zheng et al. saw signs of it but could not establish it with their data. Panickssery, Bowman and Feng showed in 2024 that models recognise their own texts better than chance and that this ability correlates with the strength of self-preference.

Each weakness has a simple countermeasure:

1. Swap the order. Run the comparison twice, once A before B, once B before A. Only if both runs favour the same answer is it a win, otherwise a tie. That is what Zheng et al. did.
2. Take length out of the rubric. State explicitly that length is not a criterion, and check content point by point instead of an "overall impression".
3. Use a different model as judge. Anthropic's code examples call it generally best practice to evaluate with a different model from the one that produced the output.

A fourth trap comes from Anthropic's best practices for Claude Code: a reviewer asked to find problems will always find something. Act on every finding and you end up with safeguards for cases that never happen. So narrow the instruction, for example to "only report issues that affect correctness".

When an AI judge is enough and when a human must check

An AI judge is enough when a mistake is cheap and there are many cases: testing prompt variants, pre-sorting chatbot answers, checking a draft for gaps before a human reads it. Anthropic recommends more automatically graded cases over fewer hand-graded ones for evaluations.

A human has to check when

• a mistake costs money, touches deadlines or has legal consequences,
• the result leaves the house: to customers, onto the web or into a contract,
• the judge contradicts itself, for example when the verdict flips after swapping the order. Wang et al. propose exactly this: route difficult cases to a human,
• you set up a new judge. First let it grade cases whose correct answer you know, and compare.

Where the errors a judge should catch come from is explained in AI Hallucinations: Why AI Makes Things Up.

The four-eyes principle: the author is never the checker

You know the four-eyes principle from accounting: whoever enters a payment does not approve it. For AI it means: the instance that produced a text or code does not check it. Besides self-preference, there are two reasons:

1. Self-correction without outside feedback works poorly. Huang et al. showed at ICLR 2024 that language models do not reliably correct their own reasoning errors without external feedback, and sometimes get worse.
2. A fresh context helps. Anthropic's Claude Code docs say that handing the same task to a subagent does not make the answer any better, but a fresh reviewer does, because it has not seen your reasoning.

In my operation, checking happens in a second pass with its own instructions, usually by a subagent with a fresh context. My advice: ask for location and evidence with every finding, so you can verify it quickly. For correction loops I also use Codex from OpenAI regularly. How to set up a checker as its own subagent in Claude Code is shown in Claude Code Subagents: Best Practices. For code, Anthropic offers a ready-made service that I describe in Claude Code Review: Cost, Setup, Limits. More on coding agents in Agentic Coding: Beyond Vibe Coding.

A real finding from my own operation

An example from this website’s editorial review: an older Kubernetes Persistent Volumes article included a YAML example with a Hetzner snapshot class. Checking the Hetzner documentation and CSI driver issue tracker showed that Hetzner does not provide volume snapshots. The example was corrected. The deciding evidence was the primary source, not a model’s verdict.

Two things stand out. First, the example had been online since the update of September 7, 2026, even though that article had also gone through a separate check back then. No checker finds everything. Second, it was not a model's verdict that settled the case but the primary source the checker cited. For me that is the core of LLM as a judge in practice: a judge with a rubric and a duty to cite evidence, and a human who reads the result and decides. More on Sebastian: Sebastian, my employee for SEO and GEO.

Frequently asked questions

What does LLM as a judge mean?

A language model grading the output of another model or agent against fixed criteria. It is one form of LLM evaluation, also called AI evaluation.

How well does an AI judge agree with humans?

In Zheng et al., GPT-4 agreed with human raters over 80 percent of the time, as often as humans agree with each other. That applies to the open-ended questions tested there. For your own task, check it yourself on cases with a known answer.

Can a model grade its own answers?

Technically yes, but it is not advisable. Studies show a tendency towards self-preference, and Anthropic's examples recommend a different model as grader. At the very least, check in a fresh context with its own instructions.

Does LLM as a judge replace human review?

No. It replaces reading in bulk and delivers a reasoned shortlist. Anything that leaves the house, or gets expensive if it is wrong, is read by a human.

Where to go from here

Take a task you regularly give to AI and write down three to five criteria for a good answer. Give them to a second chat as a rubric together with the answer from the first, and compare its verdict with yours before you trust it. For several agents with separate roles, read Orchestrating Multiple AI Agents. How others build checking roles is what we discuss in my community AI Employee Framework.