Making Debating Agents Earn Their Concessions

When several language models debate a factual question, the debate often ends wrong even though one of them started out right. The usual cause is social, not epistemic. A correct agent in the minority gives way because the others outnumber it, not because anyone showed it was mistaken. This proposal borrows a tool from human-computer interaction, the cognitive forcing function: a deliberate bit of friction, such as a confirmation step or a required justification, that stops people from accepting a suggestion on autopilot. We apply it to the one moment in a debate where hallucinations spread, the moment an agent changes its answer.

The core idea fits in two sentences. An agent may abandon its answer only if it names the specific claim in its own earlier reasoning that it now rejects and the specific claim from its opponent that replaces it. A fresh model instance that has never seen the debate must then check both claims in isolation and confirm that the rejected claim fails and the replacement holds. If the check fails, the concession is refused. Agents keep their answers unless they are actually refuted, so majority pressure alone can no longer flip a correct minority. The rest of the debate is left unconstrained.

Why the concession step is the right place for friction

The evidence that debate fails at the point of conformity is direct. In a controlled study on 1,800 Knight–Knave–Spy logic puzzles, Can LLM Agents Really Debate? found that agents in an incorrect majority stay put more than 97% of the time, while correct minority agents almost always collapse. Multi-LLM Debate: Framework, Principals, and Interventions formalizes the same effect as a convergence trap and a "tyranny of the majority." Both papers motivate this proposal: debate has information it throws away.

Existing fixes act elsewhere in the debate. Estornell and Liu prune low-quality or redundant arguments and add a critic that writes refutations of shared misconceptions. MAD-M² masks earlier turns that look wrong, judged either by self-assessment or by token perplexity. DReaMAD diversifies agents' perspectives before the debate starts. CFMAD assigns agents counterfactual stances over a closed set of answer options and has a judge pick the answer whose defender wavers least. None of these controls when an agent is allowed to switch. They clean the transcript or diversify the inputs and then let conformity run.

We gate the state transition itself, and only that transition. This follows Collins et al., who showed that friction applied selectively reduces over-reliance without hurting task accuracy. It also follows the lesson of the Frictional Agent Alignment Framework (FAAF), which trains a model to insert friction into human–model dialogue when beliefs diverge. FAAF works on deduction puzzles with humans in the loop. We move the idea into agent-to-agent debate and use it against factual hallucination.

Three constraints from the file shape the design. The first concerns who does the checking. Synthetic Error Injection Fails to Elicit Self-Correction shows models recognize only 8% of their own natural errors and often "parrot" the wrong answer after apologizing. CritiqueLLM documents self-enhancement bias in critics. So the check cannot be the conceding agent's own judgment, and the verifier must not see the debate transcript.

The second concerns how claims are shown to the verifier. HaluEval reports a contrast paradox: showing an LLM a correct and a hallucinated answer side by side makes its detection worse. The pro-and-con explanations of Si et al. helped humans, but this suggests they may not help models. So the verifier sees each claim on its own, never as a pair.

The third concerns stance assignment. Ku et al. found that assigned stances cause "rhetorical rigidity" and score below a single agent. That is in tension with CFMAD's preset stances. We let agents choose their own initial stance and put the friction on leaving it. This resolves the tension in a testable way: friction on exit should help, while forced entry into a stance hurts.

Core Claim

Requiring a verified warrant for every concession should recover a substantial share of a quantity we call lost-minority headroom. It is the fraction of questions where at least one agent's first-round answer was correct but the debate's final answer is wrong. The gain should come mainly from fewer correct-to-wrong flips, with no comparable drop in wrong-to-correct flips.

We do not claim to break the reasoning ceiling that Zhao et al. identify. If no agent knows the answer, gating cannot create it. The claim is narrower and checkable: debate should realize more of what its agents already know.

Research Program

The protocol uses three to five agents drawn from one open model family, with a cross-family variant as a check. Llama-3.1-8B-Instruct, the model used by DRAG, and a Qwen2.5 model are natural choices.

In round one, each agent answers independently and commits to an answer. Later rounds proceed as in standard debate, with one change. Any agent whose new answer differs from its previous one must emit a structured warrant, modeled on the error-type, position and hint feedback format of REFINER. The warrant has two parts: the atomic claim in its earlier reasoning it now rejects, and the atomic claim from another agent that replaces it.

A verifier, a separate instance with no access to the transcript, tests each claim in isolation. It uses indirect cross-examination in the style of Agrawal et al., who show that fabricated statements give inconsistent answers to orthogonal follow-up questions. The verifier generates several such questions about the claim, answers them independently, and scores how consistent the answers are.

A concession goes through only if the replacement claim is clearly more consistent than the rejected one. Otherwise the agent keeps its answer, and the failed warrant is posted to the other agents as an open objection.

There is a symmetric, lighter forcing step for the majority. Before reaffirming its answer, an agent in the majority must answer the minority's strongest posted objection. Final answers come from a plurality vote over the agents' committed answers.

Beyond accuracy, we will log every answer change and classify it by ground truth as a good flip (wrong to correct) or a bad flip (correct to wrong). We will measure verifier precision on warrants. We will also measure LLM calls per question, since cost is the main practical objection to debate; DRAG, for instance, averages about ten calls per question.

Baselines

The naive reference points are a single model with chain-of-thought prompting, and the same model asked to review and correct its own answer. These measure whether any multi-agent machinery is needed at all.

The first strong competitor is self-consistency: majority vote over independent samples. It is the cheapest ensemble and the one most likely to match us. We give it exactly the same number of LLM calls our protocol uses on each question, including the verifier's calls, and the same temperature search. Beating it means higher accuracy at equal calls on at least three of the four benchmarks below.

Standard multi-agent debate with free answer changes is run with the same agents, the same number of rounds, and additional rounds added until its call count matches ours.

The strongest published method on our main factual benchmark is the pruning-plus-misconception-refutation intervention of Multi-LLM Debate. It reports TruthfulQA accuracy of 69% with GPT-3.5, against a 61% baseline. We will reimplement it on our models with the authors' described components and a matched call budget. The published figures will be cited as context only, because the base model differs. For multi-hop fact verification, the strongest reported number is CFMAD's Hover 3-hop F1 of 0.6757, against 0.6476 for standard debate (CFMAD). We will rerun CFMAD on the same models. MAD-M² memory masking is included as the representative transcript-cleaning method.

Three ablations isolate the key ingredient. The first, a stubbornness prompt, tells agents not to change their answer unless genuinely convinced and requires a written warrant, but nothing checks it. This tests whether friction alone does the work. The second gives the verifier the full transcript, which tests whether isolation from the debate matters. The third shows the verifier both claims side by side instead of one at a time, which tests the contrast paradox.

Beating the strongest baseline means the following at matched calls, with 95% bootstrap intervals that exclude zero: higher accuracy than the reimplemented Estornell–Liu method on TruthfulQA and than CFMAD on Hover, and lower lost-minority headroom than every debate baseline.

Why not just…?

Why not just use self-consistency voting? If the model's default answer is a popular misconception, independent samples repeat it. TruthfulQA shows larger models imitate human falsehoods more readily, and CFMAD argues that voting then becomes an echo chamber. Still, self-consistency at matched compute is a real threat on questions where the model is merely noisy rather than biased. We will report results separately by question type. If voting matches us on TruthfulQA, our contribution narrows to structured multi-hop tasks, and we will say so.

Why not just tell agents to be stubborn? This is the most serious alternative, because it is free. Our expectation is that a stubbornness prompt cuts bad flips and good flips together, since the agent cannot tell a sound refutation from social pressure. The parrot behavior documented by Gou et al. suggests self-judged warrants will be unreliable. The first ablation settles this directly. If the stubbornness prompt matches the verifier-gated protocol on the ratio of good to bad flips, the verifier adds nothing and the idea should be dropped in favor of the prompt.

Why not just add a judge or critic agent, as CFMAD and Estornell–Liu do? Judges read the whole transcript and are exposed to the same fluent, majority-backed narrative that misleads the agents, much as fluent wrong explanations cut human accuracy from 49% to 35% in Si et al.. Our verifier checks one atomic claim with no social context. The transcript-visible verifier ablation tests exactly this difference.

Why not just retrieve evidence? DRAG shows that retrieval-augmented generation can compound "hallucination on hallucination" when retrieved passages are noisy, and retrieval is orthogonal to our gate in any case. We keep the main study retrieval-free so that gains are attributable to the gate. A secondary run lets the verifier use retrieval.

Proposed Experiments

The first test is TruthfulQA, scored with its GPT-judge evaluator, which agrees with human raters 90–96% of the time. This is our primary factual benchmark and the one where the majority is most likely to share a misconception.

Hover 3-hop and 4-hop test multi-step fact verification against CFMAD.

HalluLens PreciseWikiQA tests the refusal trade-off. Its paper reports Llama-3.1-405B reaching a 26.84% hallucination rate only alongside a 56.77% false-refusal rate, and GPT-4o answering 52.59% correctly with 4.13% false refusals. We will report hallucination rate and false-refusal rate jointly, to confirm that friction does not simply buy fewer errors with more abstention. No debate result on HalluLens was found on Lacuna.

The Knight–Knave–Spy puzzles serve as a mechanism diagnostic. Ground truth there is exact, so every flip can be labeled. The decisive check is whether the gated protocol lowers the more-than-97% majority stability in cases where the majority is wrong, while leaving it intact in cases where the majority is right.

The second decisive check is the flip ledger across all benchmarks. The idea is supported only if bad flips fall substantially more than good flips do, and if the improvement over the stubbornness-prompt ablation comes from verifier precision on warrants. If verifier precision is near chance, as HaluEval's 58–63% self-detection figures warn it might be for weak models, we expect the method to fail. That would itself be a useful negative result: it would bound how much friction can help when no reliable checker exists.