Rethinking LLM-Judged Helpfulness as a Pedagogy Signal: A Pre-Registered Audit Across Tutor Models

The Helpfulness Trap in AI Tutoring

Researchers have recently begun testing whether AI judges can distinguish between a tutor that simply hands out answers and one that actually provides pedagogical guidance. While we often rely on Large Language Models (LLMs) to act as scalable proxies for human preference, this paper suggests that our current measurement tools might be fundamentally broken for education. The core finding is that standard "helpfulness" rubrics—the kind used to train most general-purpose assistants—often fail to catch blatant answer-giving. In contrast, specialized teaching rubrics and deterministic process measures (automated, rule-based measurements) provide the only reliable separation.

The failure of general-purpose signals

In the rapidly evolving field of AI tutoring, a critical tension exists between being "helpful" and being "pedagogical." Most LLMs are fine-tuned using Reinforcement Learning from Human Feedback (RLHF) to maximize a "helpfulness" signal. However, in a tutoring context, being helpful often manifests as the "assistance dilemma" (the conflict between helping a student and preserving their opportunity to struggle). A model tuned to be helpful tends to resolve a student's struggle by providing the direct answer rather than withholding it.

Current evaluation workflows typically use an LLM-as-a-judge to score these interactions on a general helpfulness scale. The authors of this study argue that this creates a massive measurement gap. If the evaluator cannot distinguish between a model that guides a student and a model that simply leaks the solution, the reward signal will inadvertently entrench the very behavior that undermines learning. As shown in [Figure 1b], a turn that leaks the answer can receive the same maximum helpfulness score as a highly sophisticated pedagogical turn. These turns have vastly different impacts on the student's actual reasoning process.

Architecture of the audit

To isolate this measurement problem, the authors constructed a highly controlled testbed. They keep the underlying model weights constant while varying only the "policy"—the high-level logic governing how the model responds. As illustrated in [Figure 1a], they compare two distinct approaches:

1. ConvTutor: A minimal, single-call conversational policy. It uses a simple instruction to be a "helpful tutor." Answer-giving is an emergent property of the model's general-purpose training.
2. PedTutor: A complex, four-node routed policy. Instead of a single call, it uses a private learner-state tracker to diagnose the student's difficulty. It then routes the interaction through one of three specialized responders: a problem decomposer, an answer-deferral gate, or a hint cascade.

The study utilizes a deliberately weak simulated student (Llama-3.1-8B) to ensure the tutoring is "load-bearing." This means the student actually requires assistance to succeed. Crucially, the researchers employ two types of evaluation: subjective LLM-based rubrics (Helpfulness and Pedagogy) and "deterministic detectors." These detectors measure answer leakage via string-matching and student independence via a reasoning detector. These are judge-invariant by construction. This means no LLM can influence their output.

Divergence in the data

The results of the audit reveal a stark dissociation between what judges say is happening and what is actually happening. On the primary base (Claude Sonnet 4.6), the authors report that under the Claude Opus 4.8 judge, the helpfulness scores for ConvTutor and PedTutor did not differ significantly (Cliff’s $|δ|=0.10$). This small effect size indicates the judge saw almost no difference in "helpfulness" between an answer-giver and a scaffolder.

However, when applying the specialized pedagogy rubric, the separation was perfect ($|δ|=1.0$). This means every PedTutor replicate outperformed every ConvTutor replicate [Figure 2a]. This discrepancy is the paper's central contribution. General-purpose helpfulness is a compressed, unreliable signal for pedagogy. Furthermore, the authors found that the helpfulness ordering was entirely judge-contingent. While Opus might have favored one policy, a second judge (GPT-5.6 Sol) reversed that ordering on two of the three model bases tested [Figure 2a].

The most damning evidence comes from the deterministic measures. The paper reports that answer-revealing turns are consistently followed by a drop in student independence across every single tutor base .

This confirms that the "helpfulness" identified by the LLM judges is often achieved at the direct expense of the student's ability to perform independent reasoning.

Limits of the simulation

While the methodology is rigorous, there are several caveats. First, the study relies on a simulated student and a single mathematical domain (algebraic mixtures). The findings may not generalize to the nuances of human learners.

Second, the "accuracy" metric used for the student hits a ceiling. Because the student accumulates worked examples in its context window, it can retrieve answers from previous turns. This prevents the measurement of durable learning. The authors note they are measuring "recoverability from context" rather than long-term knowledge retention. Finally, the pedagogy contrast is technically a manipulation check. Because PedTutor was explicitly built using the principles the rubric scores, the success of that metric is expected.

The verdict: Stop trusting the score

If you are building or evaluating educational AI, the verdict is clear: do not rely solely on general-purpose helpfulness scores. Relying on a single "helpfulness" metric to optimize a tutor is a recipe for creating "answer machines." These machines provide a veneer of assistance while actively eroding student agency.

The authors suggest a dual-track evaluation strategy. Pair pedagogy-targeted rubrics with deterministic process measures. If your model's "helpfulness" increases while its "answer leakage" or "student independence" decreases, you aren't building a teacher. You are building a cheat sheet. For those looking to implement this, the authors have released their framework and code at https://github.com/bydeng01/conv-vs-ped-tutor.

Figures from the paper