LLM-as-a-judge is an evaluation method where one large language model scores or compares the output produced by another. A team provides the judge model with a short prompt that states the criteria, the question, and the answer to grade. The judge returns a numeric score, a categorical label, or a preference between two candidates, usually with a written explanation. The method has become the default way teams evaluate open-ended model output, chatbot conversations, and agent behavior at production scale because human review does not scale and traditional text metrics miss meaning.
What It Actually Is
The core idea is that the model acts as an evaluator instead of a generator. It receives an evaluation prompt that specifies the target text, the criteria, and the required output format, and returns a judgment. Because the criteria are written in natural language, the same judge can be reused for a new task by editing the prompt, with no retraining.
Teams deploy judges in three contexts. During development, they compare models or prompt versions to confirm an improvement is real. Once an application is live, they monitor user interactions for quality and safety. On every change, they run regression checks to verify nothing broke. The method supports all three workflows, which is why it spread quickly across the industry.
It is worth being precise about what this is not. LLM-as-a-judge is not a fixed metric like accuracy or precision, which quantify how well a prediction matches ground truth. It is a general technique that approximates human labeling for a specific application. The result is a use-case-specific proxy, not a deterministic measure, and its success depends on the prompt, the model, and the complexity of the task.
Why Evaluating Is a Different Job from Generating
The obvious objection is that asking an LLM to grade another LLM is like letting the fox run the henhouse. Evaluating is a more focused job than generating. Critiquing takes less effort than creating. Classifying content is narrower than producing it, and detecting a mistake usually takes less work than avoiding the mistake in the first place.
When a model generates a response, it juggles context, product prompts, and its own style constraints all at once. When it evaluates, it is not asked to fix anything. A relevance judge only checks whether the response is semantically related to the question. That is a focused classification task, and models are well suited to it. Using a separate prompt and often a separate model for evaluation activates distinct capabilities and reduces the job to something closer to text classification.
Prompting, Scoring, and Judgment Modes
A typical judge prompt contains four components: the criteria or rubric, the original user query, the output to evaluate, and an optional reference answer. The verdict comes back in one of three shapes. Numeric scores, such as a 1 to 5 scale, are the common default. Categorical labels provide buckets like correct, partially correct, or incorrect. Boolean verdicts return yes or no for binary decisions such as whether an answer violates policy.
Binary labels tend to be more consistent for both LLMs and human reviewers. Deciding whether a response is polite is reliable; deciding whether politeness is a 73 or an 82 out of 100 is not.
Prompt quality is the biggest differentiator between a good judge and a noisy one. Chain-of-thought prompting, which asks the judge to reason step by step before scoring, improves agreement with human expectations and leaves an audit trail. Few-shot examples anchor the rubric; one frequently cited result shows few-shot prompting lifting a model's consistency from 65 percent to 77.5 percent. The G-Eval framework takes this further by asking the model to generate evaluation steps from the criteria, then using those steps to fill in a scoring form and produce a score from 1 to 5.
There are two judging modes. Single-output scoring evaluates one response at a time and returns an absolute score. It is the mode to use for monitoring and regression testing, where a quality signal on a stream of live traffic is needed. Pairwise comparison shows two outputs for the same input and asks which one is better. It is the right tool for A/B tests and for comparing prompt versions or models, but it is susceptible to position bias, where the judge favors whichever answer happens to appear first.
Four Documented Bias Types
Judges are not neutral. Research reports a repeatable set of systematic biases that distort verdicts, and knowing them is the first step to controlling them.
Position bias is the tendency to favor whichever answer appears first in the prompt. A widely cited 2023 study found that even the strongest model tested reached the same verdict both ways in only about two-thirds of cases, and swapping the order often reversed the outcome.
Verbosity bias is the preference for longer answers even when the extra length adds no information or quality. In the same study, when answers were rephrased to be longer without new content, judges such as Claude and GPT-3.5 still preferred the longer version more than 90 percent of the time. This creates a real incentive for a model team to pad output rather than improve it.
Self-preference bias, sometimes called model narcissism, is the tendency for a judge to rate its own outputs more highly. Early research found GPT-4 favored its own answers with roughly a 10 percent higher win rate and Claude-v1 with about 25 percent, while GPT-3.5 showed no such effect. The proposed mechanism is perplexity: a model assigns higher probability to text that resembles its own distribution.
Sycophancy bias is the tendency to agree with a position that appears endorsed in the prompt. If a judge is told that a user found the first response more helpful, many models shift their verdict toward that answer even when instructed to ignore that signal. The same pattern appears with fake expert endorsements and a preference for confident phrasing over appropriately hedged but more accurate ones.
Calibration Against Human Labels
The headline number is reassuring. A strong judge such as GPT-4 aligns with human judgment roughly 85 percent of the time, which is higher than the roughly 81 percent agreement between two human annotators on the same task. That is the basis for claiming a judge is a reasonable substitute for human review at scale.
Calibration tempers that headline. Agreement with humans varies widely across datasets, tasks, and evaluated properties. A large-scale study across 20 NLP tasks found exactly this and recommended that teams validate and calibrate judges against task-specific human judgments before deploying them. On tasks with a verifiable answer, the gap can be dramatic: on JudgeBench, strong judges including GPT-4o performed only slightly above chance. High apparent agreement at the level of overall rankings can hide substantial disagreement on individual judgments.
In practice, the mitigations are real but partial. Swapping order handles position bias. Length-controlled metrics and rubric guidance temper verbosity. Multi-judge panels drawn from different model families, aggregated by majority vote, offset any single model's skew. Pairing these practices does not make the judge unbiased; it makes the bias visible and bounded, which is the most honest outcome a team can expect.