Large language models (LLMs) can clean the training logs of recommender systems. Given a user's click history, an LLM can spot a click that does not belong, such as an accidental tap on an unrelated item, and remove or replace it. The small, fast recommender that serves live traffic is then retrained on the cleaned logs, so the LLM never touches the request path. The weak point is the LLM's own mistakes. When it confidently "corrects" an unusual but genuine preference, the student model learns a falsehood, and nothing downstream catches it.
We propose to put each LLM-proposed correction on trial before it enters the training set. An advocate agent argues for the correction from the items' meaning. A skeptic agent argues against it from statistics the advocate cannot see: how often items co-occur, and how the recommender itself scores the clicked item. A judge accepts the correction, rejects it, or down-weights it. Only surviving corrections, weighted by how decisively they survived, are used to retrain the unchanged lightweight recommender. Serving latency therefore stays exactly as it was. The research question is whether this asymmetric, evidence-split debate catches harmful corrections that a single LLM, or a single LLM sampled many times and voted, lets through. A secondary question is whether giving the debating agents reasoning skills learned on mathematics makes them better arbiters of user preference, a domain with no verifiable answers.
Core Claim
Multi-agent debate, meaning several LLM instances that argue toward a verdict, has a known failure mode. When identical agents see the same evidence and talk symmetrically, the exchange behaves like a martingale: beliefs get reshuffled but no new information appears, and plain majority voting does as well or better. Efficient Multi-Agent Reasoning via Confidence-Guided Adaptive Debate (LASE) shows this and then beats majority voting with an asymmetric leader–supporter design. Its result on GPQA-Diamond is 65.2% for LASE, 62.7% for majority voting, and 62.1% for symmetric debate.
Our claim is that recommendation data correction is a setting where debate's benefit is structural rather than incidental. The two evidence sources truly differ and often conflict. One is item semantics, which the LLM reads from titles. The other is collaborative statistics, the co-occurrence patterns a recommender learns. Assigning these to different agents breaks the symmetry by construction. The debate's job is narrow and checkable: decide whether a proposed relabel is right. Because the output is a filtered and weighted training set rather than a live answer, debate costs teacher tokens offline and adds zero serving latency.
Relation to Prior Work
Two recommender papers supply the pipeline we extend, and both use a single-LLM teacher.
LLM4RSR does three things:
- It optimizes a correction prompt with textual gradient descent, meaning iterative prompt edits guided by LLM-written critiques.
- It applies the LLM only to the 5% of training instances where a baseline sequential recommender is least confident.
- It performs partial-mismatch corrections (remove distracting clicks) or complete-mismatch corrections (replace the target item), reporting an 8–9% average HR and NDCG gain across 8 backbones with no added inference latency.
Its corrections are never independently checked. We reuse its uncertainty-based selection and correction operators and add a verification stage.
ALKDRec distills an LLM into session recommenders such as FPMC and AttMix. It actively selects "Effective" sessions, where the teacher is right and the student struggles, and reports over 34% Recall@5 improvement from only 500 sessions on Hetrec2011-ML and Amazon-Games. That result motivates our budget discipline: the debate only needs to run on a few hundred to a few thousand contested instances. It also motivates our worry. ALKDRec's own taxonomy admits an "Incorrect" class where the teacher fails, and its selection rule cannot see teacher errors directly.
AgentArk is the closest connection between debate and fast deployment. It distills multi-agent debate trajectories into a single LLM student and reports transfer from math and medical debates to out-of-domain tasks. Its students are still multi-billion-parameter autoregressive models, which cannot meet sub-50 ms ranking budgets. It also distills the debate process itself. We do something different: we never ask the student to imitate debate. We use debate only to decide which supervision the student sees, which is the only form compatible with ID-based backbones like SASRec.
Generative Reasoning Recommendation via LLMs (GREAM) builds recommendation reasoning curricula by single-model reverse prompting and trains a generative LLM recommender. It is a competitor in spirit, but it keeps the LLM in serving, so it addresses a different latency regime.
Three debate papers constrain our design:
- Examining Inter-Consistency of Large Language Models Collaboration (FORD) finds a 20–30% disagreement rate even between same-family models. It also finds a distraction effect, where a stubborn weaker model drags a stronger one toward the wrong answer. So we fix the judge as the strongest model and keep skeptic and advocate at equal capacity.
- LASE warns that miscalibrated confident agents never trigger debate. So we always debate selected instances rather than gating on teacher confidence.
- The skeptic–trusting-agent framing of Towards Detecting LLMs Hallucination via Markov Chain-based Multi-agent Debate Framework supplies the role template. We change it by giving each role different evidence, not just different instructions.
The cross-domain question draws on Reasoning Vectors. That paper extracts the weight difference between a reinforcement-learned and a supervised Qwen2.5 model trained on math. Adding this difference to a base model improves coding and logic, including +12.3% on BigBenchHard. This gives a cheap, controlled way to build matched agent pairs that differ only in math-derived reasoning. CPL reports math-to-code and math-to-science transfer of planning skills, which motivates the hypothesis. The research file also flags the opposite risk: preference data has no verifier, so formal reasoning may simply not apply.
Research Program
The pipeline has four stages.
Proposal. A student sequential recommender (SASRec as the primary backbone) is trained on raw logs. The bottom-α confidence instances are passed to an LLM corrector using LLM4RSR's operators, which propose a removal or replacement.
Debate. For each proposed correction, the advocate receives item titles and descriptions for the user's history, the target, and the proposed change. The skeptic receives no free text about items beyond IDs and categories. Instead it gets:
- co-occurrence counts between the disputed item and the rest of the history,
- the student's score and rank for the original and the proposed item,
- popularity of each item,
- the number of other users whose histories contain the same transition.
Both agents state a position, then exchange one round of rebuttal in which each must cite a specific fact from its own evidence. A judge model sees the full transcript but not the raw evidence. It outputs accept, reject, or uncertain, together with a probability $p$ that the correction is right. Two short rounds are the default because FORD reports that consensus movement drops toward zero within a few rounds.
Weighting. Accepted corrections are applied. Rejected ones leave the original instance untouched. The student is retrained with each corrected instance weighted by the judge's probability $p$, so contested corrections influence the gradient less.
Matched agents for the cross-domain question. We instantiate advocate and skeptic either from a base Qwen2.5-7B instruct model or from the same model plus the math reasoning vector. All prompts and token budgets are held fixed. This isolates whether math-derived reasoning makes agents better at citing and weighing evidence in a non-verifiable domain.
The serving model is architecturally identical to the baseline in every condition. We will still measure p99 serving latency to confirm no drift from changed embedding statistics.
Baselines
Naive reference. The student recommender trained on raw logs with no correction, plus the same student trained after simply deleting the bottom-α uncertain instances. The deletion variant tests whether LLM reasoning matters at all. It answers the possibility that uncertain instances are just noise that is best discarded.
Strongest existing method: LLM4RSR. We run it with the same corrector LLM, the same α, the same backbones, and the same datasets. The file reports an average 8–9% HR and NDCG gain over uncorrected backbones on Amazon CD, Game, Kindle, and ML-1M. No per-dataset absolute HR@10 or NDCG@10 values are reported on Lacuna for LLM4RSR, so we will reproduce it and compare against our reproduction. Where possible we will use its released prompt modules. Otherwise we run textual gradient descent with the same number of optimization steps we allow ourselves for prompt tuning.
Beating it means two things on at least three of four datasets:
- a statistically significant NDCG@10 gain across five seeds,
- higher correction precision on the synthetic-noise benchmark described below.
Strongest teacher-selection baseline: ALKDRec. We include ALKDRec's active selection with its single-LLM teacher, run on Hetrec2011-ML and Amazon-Games with FPMC and AttMix students. The file reports over 34% Recall@5 improvement. We reproduce it at equal teacher-token budget.
Ablations that isolate the key ingredient. Two ablations matter most.
- Symmetric debate. Both agents see all evidence, same roles, same tokens. If this matches the asymmetric version, the evidence split is not doing the work.
- Compute-matched single-LLM self-consistency. The corrector is sampled k times with all evidence in one prompt, the majority correction is kept, and agreement serves as the weight. Here k is chosen so total teacher tokens equal the debate's.
A further ablation removes the judge's probability weighting and uses hard accept or reject only.
Why not just…?
Why not just sample the single corrector several times and vote? This is the most serious threat. LASE shows that symmetric debate often fails to beat majority voting. Our compute-matched self-consistency baseline tests it directly. We expect voting to fail in one specific case: corrections where the LLM's semantic prior is consistently wrong, such as a niche accessory that looks unrelated but co-occurs strongly. Repeated samples share that bias, and their agreement then signals false confidence. We will report correction precision separately on high-co-occurrence disputed instances. If voting matches debate there too, the debate claim fails, and we will report that the gain comes from the extra evidence rather than the argument.
Why not just put the co-occurrence statistics into one prompt? This is a real alternative. It is cheaper, and it is exactly what our "single LLM, all evidence" arm measures. The argument for separate agents is that a single model tends to anchor on the more fluent text evidence and under-weight numbers. A skeptic whose only job is to argue from the numbers forces that evidence into the transcript. If the single-prompt arm matches at equal tokens, we will adopt it as the recommended method and present debate as unnecessary.
Why not just discard uncertain instances, or rely on student confidence alone? LLM4RSR argues that co-occurrence-based denoising fails on sparse, long-tail data where semantics are needed. The deletion baseline tests whether that holds on these datasets. It is also the right reference for long-tail users. We will report results bucketed by user history length, because those users stand to gain or lose the most from relabeling.
Why not just distill the debate into a smaller LLM as AgentArk does? Any LLM student, even at 0.6B parameters, runs autoregressively over long histories and breaks millisecond ranking budgets. Our approach keeps the production model unchanged. The comparison that matters is quality per teacher dollar at fixed serving latency, not quality at any latency.
Proposed Experiments
Data and backbones. Main experiments use LLM4RSR's datasets (Amazon CD, Game, Kindle, ML-1M) with SASRec plus two further backbones from its set. The ALKDRec comparison uses Hetrec2011-ML and Amazon-Games with FPMC and AttMix.
Metrics. We report HR@10 and NDCG@10 (Recall@5 for the ALKDRec settings), teacher tokens and dollar cost, and p99 serving latency. Serving latency should be unchanged by construction.
Decisive check 1: correction precision on known noise. Real logs have no ground-truth noise labels. So we inject synthetic corruptions into clean held-out histories: random-item insertions and target swaps, at 5% and 10% rates. We then measure precision and recall of each method's corrections against the known injections. A second subset injects plausible-but-wrong swaps, meaning same category but low co-occurrence. This subset specifically stresses semantic bias.
The prediction is that asymmetric debate raises correction precision over LLM4RSR and over compute-matched voting, mainly on the plausible-swap subset. If precision does not improve there, the method has no reason to exist.
Decisive check 2: downstream benefit traces back to precision. Across α values and token budgets, we test whether NDCG gains track correction precision. This would show the downstream benefit comes from fewer harmful relabels rather than from extra regularization.
Decisive check 3: the matched cross-domain comparison. Agents with and without the math reasoning vector are compared on correction precision and on whether their rebuttals cite evidence correctly, as rated against the evidence the agent actually received. The file offers no prior result on whether math-derived reasoning helps preference judgments, so either outcome is informative. A null result would be a useful bound on how far verifiable-domain reasoning transfers.
References
- Efficient Multi-Agent Reasoning via Confidence-Guided Adaptive Debate
- LLM4RSR: Large Language Models as Data Correctors for Robust Sequential Recommendation
- Active Large Language Model-Based Knowledge Distillation for Session-Based Recommendation
- AgentArk: Distilling Multi-Agent Intelligence into a Single LLM Agent
- Generative Reasoning Recommendation via LLMs
- Examining Inter-Consistency of Large Language Models Collaboration: An In-depth Analysis via Debate
- Towards Detecting LLMs Hallucination via Markov Chain-based Multi-agent Debate Framework
- Reasoning Vectors: Transferring Chain-of-Thought Capabilities via Task Arithmetic
- CPL: Critical Plan Step Learning Boosts LLM Generalization in Reasoning Tasks