Two Graders That Cannot Hear the Same Lie: Dual-View Assessment Against Manipulated LLM Grading

Schools and universities are starting to let large language models grade student work and write the feedback students read. These grading agents are easy to manipulate. A student can append an optimized string of tokens or slip a role-playing instruction into an answer and change the grade. Prior work reports an attack success rate of about 0.50 on Chinese entrance-exam math with a role-play attack (Exposing Security Vulnerabilities in LLM Based Educational Grading Agents). There is a second risk that has not been measured. The same injected text could push the grader to write confident but false science in its feedback, and that misinformation reaches the student and possibly the course records. We propose a defense modeled on how engineering programs co-supervise students: one academic mentor checks theoretical rigor and one industry mentor checks whether the work actually runs. We split grading between two LLM evaluators that receive deliberately different views of the submission. The "theory" evaluator reads the student's derivation step by step. The "practice" evaluator never sees the student's prose. It sees only a narrow, machine-extracted set of checkable claims, such as final values, intermediate quantities, and stated equations, and it verifies them by independently re-solving and executing them. A grade or a feedback statement is released only when the two evaluators agree. When they disagree, the case goes to a human.

The two-sentence version is this. Manipulation succeeds because a single grader reads the attacker's text through the same channel it uses to read the answer. If you give two evaluators non-overlapping views and require them to agree, an injection has to fool both through different routes. The dual-mentor structure is the principled way to choose those two views.

Core Claim

Against role-play and suffix attacks, a grader built from two evaluators with different input views will have a lower attack success rate and a lower rate of false statements in its feedback than a grader built from two evaluators with the same view. We compare them at a matched rate of escalation to humans, so the defense cannot win simply by refusing to grade. The prediction is falsifiable and has a specific shape. If the benefit comes only from having a second opinion, same-view and different-view ensembles will perform equally. If it comes only from stripping prose, a single practice-only grader will match the pair. The claim is that view separation and competency diversity each contribute, and that the combination beats both components on attacked inputs while keeping clean-input grading accuracy roughly unchanged.

The academic co-supervision literature supplies the design intuition, not the evidence. Studies of dual-track mentorship describe pairing an academic mentor who guards first principles with an industry mentor who guards operational validity, so that each catches failures the other misses (Xiao et al.; Sun et al.; Zhu et al.). Those papers are qualitative and say nothing about LLMs. We borrow their structural point that the two mentors look at different evidence, and we test that point empirically.

Research Program

The work has three parts: a new attack objective, the defense, and an adaptive evaluation.

The attack objective. GradingAttack measures only label tampering, meaning flipping correct to incorrect or the reverse. It scores this with its Camouflage Attack Score, which trades attack success against preserved accuracy on non-targeted questions (GradingAttack). We add a second objective, feedback hallucination. Here the attacker crafts a submission that makes the grader assert a false principle, such as a wrong formula, an invented precondition, or a reversed causal claim. The tactic is to embed a confident false "hint" or to have the persona "agree with the professor that…". The hallucination literature describes the failure modes we expect to exploit. Models turn tentative claims into unconditional facts (Liyan Tang et al.), and once a false token enters the context it propagates through later steps (Samuel Holt et al.).

We measure the feedback hallucination rate as the fraction of atomic factual claims in the feedback that are false. Truth is judged by a symbolic check where the claim is computational and by double human annotation on a sample otherwise. We also build an adaptive "subtle wrong step" attacker. It is a generator in the style of the error generator from Adversarial Training for Process Reward Models, here repurposed to write plausible incorrect derivations that a grader accepts as correct. Using it this way demonstrates the dual-use hazard that paper left unaddressed.

The defense. It has three components:

  • Structured extractor. A small, schema-constrained parser converts the submission into typed fields: final answers, named intermediate quantities with units, and equations in a symbolic syntax. Free text cannot pass through. Its output is validated against the schema, and anything outside the schema is dropped.
  • Practice evaluator. It receives only the problem statement, the reference solution, and the extracted fields. It checks them by executing them, re-deriving the quantities with a code interpreter and comparing within a tolerance.
  • Theory evaluator. It receives the full submission but is instructed to treat it as quoted data. For each step it emits a verdict on whether the step follows, much as a process reward model does.

The final grade and every feedback claim must be endorsed by both evaluators. A feedback claim about a formula, for example, is released only if the practice evaluator can confirm it numerically. Disagreements escalate to a human. We tune the agreement thresholds so that escalation stays at or below a fixed budget, nominally 10% of clean submissions.

The adaptive evaluation. It assumes the attacker knows the architecture. The obvious weak point is the extractor. An attacker can no longer inject instructions into the practice evaluator, but can try to make the extractor record the right number for a wrong derivation. That attack forces the theory and practice views to diverge, and divergence triggers escalation. Whether this holds in practice is an empirical question we test directly rather than assume.

SciBench motivates the decision not to rely on either view alone. Code execution fixes arithmetic but encourages formula misapplication, and step-by-step reasoning improves calculation while degrading physical reasoning (SciBench). Each failure is the kind the other view would catch.

Baselines

The naive reference is an undefended single LLM grader, prompted as in GradingAttack, evaluated on its five datasets with the same 42-LLM "virtual student" answers where native student answers are absent. Its attack success rate under GradingAttackRole should reproduce the reported figure of about 0.50 on GAOKAO23 (GradingAttack). That paper reports no isolated per-dataset numbers for MATH, GSM8K, SciEntsBank, or Math23K, so we re-measure them under our setup.

The strongest existing defense is an adaptation of ARMOR, which defends against jailbreaks by having the model analyze the attack strategy, extract intent, and verify against a policy before answering. ARMOR reports a 6% attack success rate against optimization-based jailbreaks versus over 40% for other reasoning models (ARMOR). We place its reasoning prefix in front of the grader, with a strategy library seeded with role-play and suffix patterns. There is no reported result on Lacuna for ARMOR or any other defense on grading benchmarks, so the 6% figure sets an aspiration rather than a direct comparison.

The same-view ensemble is two graders of the same size reading the full submission, with the same agreement-and-escalate rule. It is the most important control.

The single-view ablations are a practice-only grader behind the extractor and a theory-only step-checker.

All systems use the same backbone family (Qwen2.5 instruct, which GradingAttack found especially vulnerable to role-play, plus one stronger model), the same per-submission token budget, and the same prompt-tuning budget on a shared clean development split. Every system with escalation is tuned to the same escalation budget.

The proposal beats a baseline if it shows a lower attack success rate and a lower feedback hallucination rate at matched escalation, together with clean grading accuracy within two points of the undefended grader. On multi-step benchmarks we also report the theory evaluator's step-level F1 on PRM800K, to confirm it is a competent checker; no reported PRM800K number was found on Lacuna for APRM or its baselines.

Why not just…?

Why not just ask one strong model to reason carefully before grading? Single-model chain-of-thought is the default deployment. ARMOR reports that reasoning models without a decoupled verification stage exceed 40% attack success against adversarial prompts (ARMOR), and SciBench shows that chain-of-thought can produce consistent derivations from false premises (SciBench). The theory-only ablation is exactly this baseline, so the experiments measure the gap directly.

Why not just run two graders and take a vote? This is the real threat. If a same-view ensemble matches the dual-view grader at the same escalation rate, then the mentorship structure adds nothing and the gain is just redundancy. We expect correlated failure, because both graders read the same persona prompt and suffix, and GradingAttack finds role-play effects consistent within model families. But this has to be shown. The same-view versus different-view comparison is the decisive experiment, and a null result would falsify the core claim.

Why not just strip the prose and check the numbers with code? If view separation alone does all the work, the right paper is "use a structured extractor," and that would be a simpler and fine result. It would leave two gaps. Right-answer-wrong-reasoning submissions would pass, and so would the subtle-wrong-step attacks from the APRM-style generator. The practice-only ablation tells us which of these cases actually occur. On SciEntsBank, whose answers are short natural-language explanations with little that can be executed, we expect the practice view to be weak. We report that dataset as a boundary case rather than hide it.

Why not just fine-tune the grader adversarially on known attacks? Static robustness training lags behind new attacks. Self-play work exists precisely because defenders fall behind emerging exploits (Chasing Moving Targets with Online Self-Play Reinforcement Learning for Safer Language Models), and multi-turn escalation breaks guardrails that hold in single turns (MultiBreak). We include a grader fine-tuned on GradingAttack outputs and test it on held-out attack families: the feedback-hallucination objective and multi-turn tutoring dialogues.

Proposed Experiments

Experiment 1: main comparison. We run all systems on GAOKAO23, MATH, GSM8K, Math23K, and SciEntsBank, plus the 103 closed-exam and textbook problems of SciBench as a college-level setting. Attacks are GCG suffixes, GradingAttackRole, our feedback-hallucination attack, and two- to six-turn tutoring-dialogue variants modeled on MultiBreak's escalation. We report attack success, CAS, feedback hallucination rate, and clean accuracy at a 10% escalation budget, and we sweep the budget to plot robustness against escalation.

Experiment 2: the ablation that settles the claim. We compare the same-view ensemble, the single-view graders, and the dual-view pair. The claim requires the pair to beat both the same-view ensemble and the practice-only grader on attacked inputs. If the pair beats the ensemble but not the practice-only grader, we report that view separation alone is the mechanism.

Experiment 3: adaptive attack. We run white-box attacks on the extractor and the APRM-style subtle-error generator. We measure how often a successful attack produces agreement, which is undetected, rather than disagreement, which is escalated.

Dual-use handling. The feedback-hallucination attack prompts and the trained subtle-error generator are offensive tools. Following the concern raised for MultiBreak-style catalogs, we release the defense and the evaluation code openly. Attack artifacts go out only under gated research access, alongside per-attack success rates so that deployers know which manipulations remain open.