💬 NLP

Rethinking LLM-as-a-Judge: Representation-as-a-Judge with Small Language Models via Semantic Capacity Asymmetry

This paper proposes "Representation-as-a-Judge," a paradigm shift where small language models leverage internal hidden states rather than surface generation to evaluate outputs efficiently and accurately, based on the hypothesis that evaluation requires significantly less semantic capacity than generation.

Original authors: Zhuochun Li, Yong Zhang, Ming Li, Yuelyu Ji, Yiming Zeng, Ning Cheng, Yun Zhu, Yanmeng Wang, Shaojun Wang, Jing Xiao, Daqing He

Published 2026-07-10

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Zhuochun Li, Yong Zhang, Ming Li, Yuelyu Ji, Yiming Zeng, Ning Cheng, Yun Zhu, Yanmeng Wang, Shaojun Wang, Jing Xiao, Daqing He

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a giant, super-smart librarian (a Large Language Model, or LLM) who can write beautiful stories and solve complex riddles. To check if a student's homework is good, we usually ask this giant librarian to read the answer and write a long, detailed report on why it's right or wrong. This is called "LLM-as-a-Judge." But here's the catch: asking the giant to write a report is expensive, slow, and sometimes the giant gets confused by how we ask the question.

Now, imagine a tiny, pocket-sized robot (a Small Language Model) that tries to do the same job. If you just ask the robot to "write a report," it often stammers, makes things up, or gives a terrible answer. It seems useless as a judge, right?

The Big Discovery: The "Silent Brain" Theory
The authors of this paper, published at ICLR 2026, asked a different question: What if the tiny robot actually knows the answer, but just can't write it down well?

They discovered something surprising: even though the small robot's output (the text it writes) is messy, its internal brain (the hidden numbers it processes while thinking) is actually full of accurate information. It's like a student who can't write a clear essay but can instantly point to the exact page in a book where the answer is hidden.

This led them to a new idea called the Semantic Capacity Asymmetry Hypothesis. Think of it like this: Writing a perfect story is like building a skyscraper; it takes a huge amount of materials and effort. But just checking if the story makes sense is like looking at a blueprint; it requires much less effort. You don't need a skyscraper-sized brain to spot a mistake in a sentence; you just need to peek inside the brain to see if the "blueprint" is correct.

The New Method: INSPECTOR
Instead of asking the small robot to write a report, the authors built a tool called INSPECTOR.

They let the small robot read the homework and a question.
Instead of waiting for the robot to speak, they "peeked" inside its brain at specific layers (like checking specific drawers in a filing cabinet).
They used a tiny, simple calculator (a "probing classifier") to read the signals in those drawers and guess the score.

What the Numbers Say
The results were pretty cool. When they tested this on math and science puzzles (like GSM8K, MATH, and GPQA):

The Old Way: When they just asked the small robot to talk, it was often wrong.
The New Way: When they used INSPECTOR to peek inside, the small robot's "brain signals" predicted the score with 80% to 90% accuracy for telling "good" vs. "bad" answers.
The Comparison: In many cases, this tiny robot's internal signals were almost as good as the giant librarian's written reports, but it was way faster and cheaper.

Interestingly, the paper found that bigger isn't always better for this specific job. Sometimes, a smaller model (like a 1.7 billion parameter model) was actually better at spotting errors than a slightly larger one (like an 8 billion parameter model) when using this "peek inside" method. It suggests that different models have different strengths, and you can't just assume a bigger brain is always a better judge.

What They Ruled Out
The paper explicitly argues against the idea that small models are just "dumb" and lack the knowledge to judge. They showed that the knowledge is there; it's just hidden in the internal signals, not in the final text. They also showed that simply asking a small model to "think harder" or "write better" (prompting) doesn't fix the problem because the bottleneck is the model's ability to generate text, not its ability to understand the quality.

How Sure Are They?
The authors are very confident in these findings based on their experiments. They didn't just guess; they ran the tests on real math and science benchmarks. They found that while predicting the exact score (like a 1 to 5 rating) was a bit harder (around 50–60% accuracy), predicting whether an answer was "good" or "bad" was highly reliable (80–90%). They suggest this method could be used to filter out bad data before training other AI models, making the whole process more efficient.

The Bottom Line
This paper suggests a new way to evaluate AI: stop asking small models to write essays and start listening to their internal "whispers." By using a tool like INSPECTOR, we can turn a tiny, cheap robot into a highly accurate judge, saving time and money while getting results that are nearly as good as the expensive giants. It's a shift from "Judge-as-a-Writer" to "Judge-as-a-Reader."

Technical Summary: Rethinking LLM-as-a-Judge: Representation-as-a-Judge with Small Language Models via Semantic Capacity Asymmetry

1. Problem Statement

The prevailing paradigm for reference-free evaluation of Large Language Models (LLMs) is "LLM-as-a-Judge," where powerful models are prompted to assess the quality of generated outputs. While effective, this approach suffers from three critical limitations:

High Computational Cost: It requires autoregressive decoding, making it expensive even for single-point evaluations.
Opacity: Reliance on proprietary models (e.g., GPT-4) renders internal mechanisms unverifiable and uninterpretable.
Instability: Effectiveness is heavily dependent on prompt engineering, raising concerns regarding reproducibility and robustness.

Attempts to mitigate these issues by using smaller, open-source Language Models (SLMs) as judges via direct prompting have largely failed. SLMs often produce poor and inconsistent evaluation scores compared to their larger counterparts. However, prior research suggests that SLMs possess semantic competence comparable to larger models despite weaker generative capabilities. This discrepancy raises a fundamental question: Do small models encode evaluation-relevant signals in their internal representations even when their surface generation is poor?

2. Core Hypothesis: Semantic Capacity Asymmetry

The authors propose the Semantic Capacity Asymmetry Hypothesis, which posits that the semantic capacity required for accurate evaluation is significantly lower than that required for generation.

Generation involves discourse planning, long-range dependencies, and full decoding, demanding substantial model capacity.
Evaluation focuses on identifying inconsistencies, factual errors, or logical flaws, which the authors argue are already accessible in the intermediate hidden states of a model, even if the model cannot articulate them in a coherent text output.

This hypothesis motivates a paradigm shift from "LLM-as-a-Judge" to "Representation-as-a-Judge," a decoding-free strategy that extracts evaluative signals directly from latent representations rather than relying on prompted text generation.

3. Methodology: INSPECTOR

To operationalize this hypothesis, the authors introduce INSPECTOR (Internal Signal Probing and EvaluaTion Of Representations), a probing-based framework. The pipeline consists of three stages:

3.1. LLM Evaluation Annotation (Gold Label Generation)

Response Generation: A medium-scale model ( $M_{med}$ , e.g., 10–50B parameters) generates responses for benchmark queries. This model is chosen to produce a diverse distribution of high and low-quality samples.
Scoring: A state-of-the-art large model ( $M_{large}$ , e.g., DeepSeek-V3) evaluates these responses across five specific aspects: Semantic Consistency, Logicality, Informativeness, Fluency, and Factuality.
Dataset Construction: The resulting pairs of (evaluation prompt, score) form the gold-label dataset ( $D_{prob}$ ). To ensure balance, the dataset is downsampled to equalize the number of samples across the 1–5 score levels.

3.2. Small LM Probing

Input: The same evaluation prompts are fed into a small language model ( $M_{small}$ , e.g., 0.6B–1.7B parameters).
Feature Extraction: Instead of generating text, the framework extracts hidden states ( $H^{(\ell)}$ ) and attention weights ( $A^{(\ell)}$ ) from every layer $\ell$ of $M_{small}$ .
Pooling & Statistics: For each layer, the authors compute a set of pooled vectors (mean, last, min, max, concat) and statistical features (attention entropy, norm, variance, entropy).
Layer Ranking: Simple linear probes (logistic regression) are trained on these features to predict the gold scores. This identifies which layers and feature types contain the most predictive evaluative signals.

3.3. Building Probing Classifiers

Feature Assembly: Based on the layer ranking, the framework constructs multi-layer feature sets by concatenating features from the most informative layers.
Classifier Training: Lightweight classifiers (Logistic Regression, SVM, MLP, Random Forest) are trained on these concatenated features to predict either multiclass scores (1–5) or binary quality labels (High vs. Low).
Selection: The optimal configuration (layer set, pooling method, classifier) is selected via cross-validation to maximize performance while minimizing complexity.

4. Key Results

Experiments were conducted on reasoning benchmarks (GSM8K, MATH, GPQA) using various SLMs (Qwen3-0.6B/1.7B, Llama-3.2-1B, Llama-3.1-8B).

Superiority over Prompting: INSPECTOR substantially outperforms direct prompting on the same small models. In multiclass classification, F1 scores improved by over 20% on average. In binary classification, probing classifiers achieved 80–90% F1 scores, whereas prompting often failed to exceed random baselines.
Approaching Large Models: The probing-based evaluation of small models closely approximates the fidelity of full-scale LLM judges (e.g., DeepSeek-V3) in filtering tasks, despite the small models having significantly fewer parameters.
Model Size Independence: Larger models do not consistently outperform smaller ones in probing tasks. For instance, Qwen3-0.6B outperformed Qwen3-1.7B in certain logicality tasks, and Llama-3.2-1B surpassed Llama-3.1-8B in fluency probing. This challenges the assumption that scaling is strictly necessary for evaluation.
Data Filtering Utility: Classifiers trained via this method serve as highly reliable filters for noisy reasoning data. When used to filter training data for Supervised Fine-Tuning (SFT) of a student model (Llama-2-7B), the probing-based filter yielded performance comparable to using the expensive DeepSeek-V3 as a filter, significantly outperforming random filtering.

5. Significance and Contributions

The paper claims three primary contributions:

Empirical Discovery: It identifies and analyzes the phenomenon that small LMs encode rich, evaluation-relevant signals in their internal representations, even when their generative output is poor.
Theoretical Formulation: It formalizes the Semantic Capacity Asymmetry Hypothesis, arguing that evaluation is a lower-capacity task than generation and can be grounded in intermediate representations.
Paradigm Shift: It introduces Representation-as-a-Judge and instantiates it through INSPECTOR. This is presented as the first work to investigate LLM probing specifically for evaluation tasks, offering a scalable, interpretable, and cost-effective alternative to the current "LLM-as-a-Judge" paradigm.

The authors conclude that this approach enables efficient, reference-free evaluation and data curation, suggesting that high-fidelity judgment does not necessarily require large-scale generative models but can be leveraged from the latent features of smaller, more accessible models.