acceptodds
Withdrawn from ICLR 2027

Can LLMs Judge Better Than They Generate? Task Asymmetry, Mechanistic Interpretability and Transferability for In-Context QA

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

LLM-as-a-Judge, self-correction, and RLHF reward models all assume that judging an answer is easier than producing one. This assumption is rarely tested directly. We test it in a controlled in-context QA setting where a single passage is the only source of information and each model judges the answer it just generated, so any difference between generating and judging comes from task difficulty, not memorized facts. Closed-book and counterfactual controls support this, because removing the passage lowers generation accuracy by 44 to 65 points. We find that judging is not consistently easier. Across four models (Llama-3.1-8B, Qwen3-8B, Qwen3-32B, GPT-4o-mini) and four benchmarks (SQuAD 2.0, DROP, HotpotQA, MuSiQue), the sign of the gap changes with the model and the dataset. One mechanism underlies this variation. The evaluator does not re-read the passage. Last-token attention shows it attends very little to the context or to the candidate answer, and a causal ablation shows its verdict depends on the candidate it is given, not on a fresh reading of the passage. Evaluation is therefore a shallow check. The same mechanism explains both directions of the gap and is hard to remove: it remains when the judge reasons step by step, it grows with model size as larger judges catch fewer of their own errors, and it survives LoRA fine-tuning, which shifts the asymmetry without removing it. Fine-tuning on generation alone makes a model accept almost every answer when it is later reused as a judge (recall near 100%). These self-evaluation failures come partly from how attention is used at inference time, a practical concern for pipelines that let a model judge its own outputs.

Primary area:
interpretability and explainable AI
Keywords:
LLM Generation, LLM Evaluation, Fine-tuning, Transferability

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_tUWmOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

The paper evaluates whether LLMs can judge better than they generate. It is studied in a gold-answer setting, not in rubric-based, pairwise, or subjective judging settings. The paper subtracts generation accuracy from self-evaluation accuracy and uses it as a main metric, delta. The paper finds inconsistent outcomes regarding the sign of the delta (Table 3). Other ablations, such as a closed-book setting, are performed.

Critical strengths
  1. LLM judge fidelity is important in both practical and academic settings.
Critical weaknesses
  1. The paper doesn't test "rubric-based, pairwise, and subjective judging" and leaves them to future work. Then, what exactly is the paper testing? Those 3 are the most commonly used LLM-as-a-Judge use cases, and "gold-answer" generation is a limited use case where LLM-as-a-Judge is often not necessary. The title is seriously over-claiming, and the contribution does not fit the standards of ICLR.
  2. The abstract contains too much irrelevant information, that are hard to understand the significance. "One mechanism underlies this variation. The evaluator does not re-read the passage." Why does detailed experimental setup belong in the abstract?
  3. The contributions, which should be clearly readable and understandable and summarize the paper, are filled with run-on sentences that make it hard to discern which findings are most important and well-supported (is it "last-token attention" or "anchored on the candidate"?)
  4. Similarly, it is clear that the paper is written entirely by LLMs, specifically Claude (use of "load-bearing," etc.).
Questions for authors

N/A

Reviewer_5TsNOpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
1
Soundness
2
Read review
Paper summary

This paper presents a set of analyses (task asymmetry, the internal mechanism, and transferability) in in-context factual QA to examine whether judging an answer (given a predicted answer, judges whether it's correct) is easier than generating one. In evaluations, each model generates answers, and judges then assess whether each answer is correct. We run experiments on four simple benchmarks, SQuAD 2.0, DROP, HotpotQA, and MuSiQue, using three models: Llama 3.1, Qwen 3, and GPT-4o. Across all models, the authors found that self-evaluation is not uniformly easier.

Critical strengths

This paper provides a systematic evaluation of generation v.s. evaluation paradox using multiple model families and sizes.

Critical weaknesses
  1. Unclear contribution beyond prior work: West et al., 2024 has already examined generation vs. understanding across a broader range of tasks, including in-context factual QA. While the authors claim this study provides a controlled self-evaluation protocol and additional analyses such as mechanistic analysis or transfer experiments, I didn't find that it offers new scientific insights beyond what prior work has shown. The original manuscript does not cite West et al. (2024). I also found that the analyses in this work are not clearly connected.
  2. The scope of evaluations is narrow and focuses on long-established QA: despite the relatively broad theme of the paper (is self-evaluation easier than generation), the main evaluations are on four widely used, simple QA datasets. This makes me wonder (1) if this finding generalizes to non-factual QA datasets (while DROP includes some numerical reasoning questions, it's still mostly context-based QA - what happens if we test models on datasets like AIME?), (2) if this finding generalizes to more complex datasets that require intensive reasoning (e.g., BrowseComp / BrowseComp-plus / Monaco are more recent factual QA datasets that require dozens and hundreds of documents and reasoning), and (3) if this is actually contamination-free. Given that similar analyses have been done in prior work, expanding the analysis would provide a deeper understanding of the problem.
  3. Overall, I found this paper hard to follow, partly because the framing is much broader than the experimental scope (while the original motivation draws on LLM-as-a-judge, self-correction, and RLHF, the main evaluations are on factoid QA) and the set of analyses is loosely connected and didn't give me main scientific takeaway.
Questions for authors
  1. Can authors explain how this work is different from prior studies, such as West et al. (2024) and others that use in-context factual QA.
  2. Can the authors test this on more recently constructed datasets?
Reviewer_42w9OpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper did systematical experiments to test the question/assumption of whether judging is easier for an llm than generating.

They tested 4 models on 4 benchmarks, using the same model to generate the answer, then evaluate the answer it generated and found that the sign of the gap between judging and generating changes with models and datasets. They analyzed the attention patterns and found that evaluators mostly attend to the candidate answer, not the context.

Fine-tuning a model to generate answers made it accept almost everything when it later graded.

Critical strengths

I find the study of the attention pattern useful. When grading, the model barely looks at the context, it mostly judges based on the candidate answer. The authors call this a “shallow check.” They say this happens for every model and dataset, still happens when the judge reasons step by step, and that larger models catch fewer of their own errors.

They argue that the failure of self-evaluation comes partly from how attention is used at inference time, which is a useful finding for people who train models to judge its own outputs.

Critical weaknesses

The setup of Δ = EA − GA is not that convincing to me. EA and GA don't seem independent. For an easy task, there are less errors made by the generation step (high GA), then there will be less "chances" for the evaluator to score.

Questions for authors

When evaluating its generation, did the llm know that’s its own generation? More specifically, in figure 1, is the generator and evaluator L done in one pass or two separate passes?

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Discussion (0)

Sign in to comment.