When a language model states something false, the most reliable fixes today run a debate. One model drafts an answer, other models criticize it, a judge model reads the criticisms, and the draft is revised, often over several rounds. This works, but it is slow, because each turn must wait for the previous one. It is also fragile in a less obvious way. The judge reads the critiques concatenated in some arbitrary order, and language models change their verdict when the order of their inputs changes. We propose to replace the multi-turn debate with a single round. Several critics check the draft in parallel, and a small trained aggregator combines their verdicts. The aggregator is built so that its output cannot depend on the order in which the critics are listed, and it learns to discount critics that are likely to be wrong together.
The design borrows from multi-agent reinforcement learning. There, a team's value is estimated by a network that treats agents as an unordered set rather than as a fixed-order list. This makes learning much cheaper and lets the network run on teams of a different size than it was trained on. We treat fact-checking critics the same way, as an interchangeable, variable-size team. The practical bet is simple. If one parallel round with a well-built aggregator matches a ten-call debate on multi-hop question answering and contract extraction, then factual refinement can be deployed with latency close to that of a single generate-then-revise pass.
Core Claim
Multi-round debate does two jobs. It gathers diverse evidence about each claim, and it resolves conflicts among that evidence. The first job parallelizes naturally. The second is what debate does badly: it resolves conflicts by letting a judge model read an ordered transcript. Our claim is that conflict resolution is better done by a small learned function that has three properties. It treats critics as a set. It predicts a verdict for each atomic claim in the draft. And it can model correlation between critics, meaning it can tell that three critics sharing one backbone and one retrieved passage amount to roughly one independent source, not three. Such an aggregator should reach the factual accuracy of sequential debate with about three sequential language-model stages (draft, parallel critique, revise) instead of about ten. It should also generalize to a different number of critics without retraining.
The work that motivates this is recent. Removal of Hallucination on Hallucination: Debate-Augmented RAG (DRAG) runs proponent, challenger and judge agents over both retrieval and response. It reaches 28.80 exact match on 2WikiMultihopQA with Llama-3.1-8B-Instruct, against 22.80 for IRCoT. That costs roughly ten model calls per question, and the authors report "problem drift" as debates lengthen. LegalHalluLens cuts fabricated contract clauses by 45% with a hand-built six-role sequential pipeline. Its typed skeptic challenges and asymmetric gates set a higher bar for adding a clause than for deleting one, and we reuse both ideas. Both systems feed their judge an ordered transcript. Set-LLM shows why that is dangerous: swapping option positions changes accuracy by more than 30% in standard models.
Relation to the Closest Work
Two papers come closest, and we differ from each in a specific way.
Beyond Memory Majority (CAMA) is the nearest mechanism. It clusters retrieved memories into order-independent "latent evidence slots" using set-based self-attention, and it counts the effective number of independent sources instead of raw votes. With this it lifts correct-minority recovery from 38.7% to 71.2% on MemoryAgentBench. CAMA supplies both the correlation-aware counting idea and the evidence that majority voting fails under shared sources. It arbitrates stored memories before generation, however, and it relies on clean provenance metadata and an RL-trained sequential recovery policy. We arbitrate critiques of a generated draft, claim by claim. We infer correlation from critic-level fingerprints (backbone identity, overlap between retrieved passages, agreement patterns seen in training) rather than from provenance graphs. And our aim is to remove sequential rounds rather than add a recovery loop.
Set-LLM also guarantees order invariance, but it does so by modifying the language model itself: it changes positional encodings and attention masks, then fine-tunes with LoRA. It covers only multiple-choice selection. Our aggregator sits outside the models, so the critics and the generator can be black-box APIs. This addresses the limitation that confines Meta-Reflection to white-box models. Meta-Reflection gets refinement down to a single pass (first-token latency 246 ms versus 951 ms for retrieval-based reflection) through a codebook inside layer 26.
The coordination lineage supplies the architectural principle. PIC replaces a concatenated multi-agent critic with a graph network. It reports that simply shuffling agent order during training was far worse than building invariance into the architecture, and its graph critic scaled to 200 agents. MARC shows that relational set critics transfer to different team sizes where MAPPO collapses. These results are from physical control. Whether they carry over to language critics is exactly what we test, not something we assume.
SrSv creates tension with our claim. It argues that fine-grained credit assignment benefits from sequential, agent-by-agent conditioning. If that holds for fact-checking, a single parallel round will lose information that later critics would have gained by seeing earlier ones. We confront this directly with a sequential-conditioning ablation, described below.
Research Program
The pipeline has four stages.
- Draft and decompose. A generator produces a draft, which is split into atomic claims. Each claim is tagged with a type (entity, numeric, temporal, obligation). We use types because LegalHalluLens shows that aggregate error rates hide large differences between types.
- Parallel critique. $K$ critics run concurrently. Each receives the claims and a different evidence view: a disjoint slice of retrieved passages, parametric knowledge only (DRAG's asymmetric challenger role), or a different model family. Each critic returns, for every claim, a verdict (supported / contradicted / unverifiable), a short rationale, and optionally a proposed correction.
- Aggregate. A small aggregator combines the verdicts, as described next.
- Revise. One revision call rewrites only the claims the aggregator flagged, using the corrections it selected.
The aggregator is where the method lives. For claim $j$ and critic $i$, let $h_{ij}$ be an embedding with three parts: the critic's verdict and rationale (encoded by a frozen small text encoder), the claim type, and a fingerprint of critic $i$'s backbone and evidence. The aggregator produces a per-claim decision
$$ p_j = \sigma\Big(\rho\big(\textstyle\sum_{i=1}^{K} \phi(\mathrm{SA}(\{h_{1j},\dots,h_{Kj}\})_i)\big)\Big), $$
where $\mathrm{SA}$ is self-attention across critics with no positional encoding, $\phi$ and $\rho$ are small networks, $\sigma$ is a sigmoid, and $p_j$ is the probability that claim $j$ is false. Because there is no positional encoding and the pooling is a sum, $p_j$ is exactly invariant to reordering the critics and is defined for any $K$. The self-attention step is what lets the model learn that a cluster of near-identical critics should count once. Following LegalHalluLens, we set asymmetric decision thresholds: deleting a claim needs less confidence than inserting a new one. A second output head estimates the probability that the revised answer will still be wrong. This head provides a calibrated stopping rule: a second round runs only on the fraction of queries where it is predicted to help.
Training labels come from datasets with gold support. For 2WikiMultihopQA and HotpotQA, claims are labeled by matching against gold answers and supporting facts. HaluEval provides human-labeled hallucinated samples. CUAD v1.0 provides expert-annotated clauses. The aggregator has only a few million parameters and runs in milliseconds. Its cost is negligible next to one model call.
Baselines
Draft only. The naive reference is the generator's draft with no critique, plus a single self-refine pass in which the same model critiques and revises its own output. Every added stage must justify itself against this. HaluEval's finding that ChatGPT detects its own summarization hallucinations only 58.53% of the time suggests self-refine will be weak, but we measure it on the same backbone rather than assume.
DRAG. DRAG is the strongest existing method on our main benchmark: 28.80 exact match on 2WikiMultihopQA with Llama-3.1-8B-Instruct, per DRAG. We re-run it with the same backbone, the same retriever and index, and its published number of rounds, and we log calls, tokens and wall-clock time. Beating it means matching or exceeding its exact match with at most three sequential stages and lower wall-clock latency. We will also report where our accuracy–latency curve crosses DRAG's when we allow a second, stopping-controlled round.
Same critics, LLM judge. This baseline isolates the aggregator. It uses the identical parallel critics and a Llama-3.1-8B judge that reads their outputs concatenated. We report it with one fixed order and with the average over several random orders, and we record how often its verdict flips when the order changes. Beating it at equal critic calls shows that the learned aggregator, not the parallelism, is doing the work.
Set-LLM-style judge. This is the strongest invariant competitor: a LoRA-fine-tuned judge given Set-LLM's shared position encoding and set attention mask over critiques, trained on the same labels. It is a real threat. If it matches our aggregator, the contribution shrinks to "external and black-box compatible."
Aggregator ablations. Two ablations isolate the key ingredient. The first replaces self-attention with independent per-critic weights: a learned reliability-weighted vote that is also order-invariant but cannot model correlation between critics. The second removes the evidence fingerprints. A third, sequential ablation lets critic $i$ see the verdicts of critics $1..i-1$, which directly tests SrSv's argument for sequential conditioning.
Single specialist critic. On RAG-Error Benchmark we compare against the single RAG-Critic 3B model. It reports 96.2% error-identification accuracy versus 78.0% for GPT-4o, and a +5.3% average gain across seven knowledge benchmarks, at the cost of a multi-round loop.
All methods share the backbone, retriever and training data. Every trained component gets the same hyperparameter search budget, reported in GPU-hours.
Why not just…?
Why not just shuffle the critiques and average an LLM judge over several orders? This removes order bias approximately, at a cost that grows with the number of shuffles. Set-LLM notes that exhaustive voting over orders scales factorially. Averaging over a few orders is cheaper but does nothing about correlated critics. The "same critics, LLM judge" baseline with averaged orders tests this directly. If it matches our accuracy using two or three extra judge calls, our latency argument weakens. We will then report the honest trade-off between a few extra judge calls and a millisecond-scale aggregator.
Why not just take a majority vote of the critics, or of several sampled drafts? Voting is order-invariant for free. CAMA shows, however, that voting collapses when sources are correlated: correct-minority recovery drops to 38.7%, versus 71.2% with source-aware arbitration. Critics that share a backbone and an index are exactly this case. The reliability-weighted-vote ablation is the stronger form of this alternative. If it matches full self-attention even in the correlated-critic stress test described below, we will drop the attention and report the simpler aggregator as the method.
Why not just use one strong specialist critic? RAG-Critic's single 3B critic is very accurate at labeling errors. One critic sees one evidence view, though, and DRAG's gains come specifically from pitting retrieved evidence against parametric knowledge. We run RAG-Critic as one member of our critic set and alone. If it alone matches the ensemble on multi-hop exact match, the multi-critic premise is wrong for that setting.
Why not just fine-tune the judge the Set-LLM way? This may work equally well, and it is included as a full baseline. Our remaining advantages would then be three: the approach works with black-box critics and generators, the aggregator is cheaper, and it can take a different number of critics at test time without retraining. The size-transfer experiment tests that last advantage.
Proposed Experiments
The main experiment compares exact match against wall-clock latency and sequential call count on 2WikiMultihopQA and HotpotQA, with NQ and TriviaQA as easier controls, all using Llama-3.1-8B-Instruct. We add TruthfulQA, scored with its GPT-judge truthful and informative metrics, to test imitative falsehoods. TruthfulQA is a hard case because critics that share pretraining priors will share the same misconceptions.
For contracts, we measure per-type hallucination rates and the fabrication reduction on CUAD v1.0 against LegalHalluLens's reported 45%, using a single parallel round instead of its six sequential roles. For detection alone, we report accuracy on the HaluEval QA, dialogue and summarization splits.
Four checks decide whether the idea holds.
- Correlated-critic stress test. Following CAMA's false-majority design, we add $m$ paraphrased copies of one wrong critic and measure how accuracy degrades as $m$ grows. The attention aggregator should degrade much more slowly than voting or the weighted-vote ablation. If it does not, the correlation-modeling claim fails.
- Size transfer. We train with $K=4$ critics and test with $K=2$ and $K=8$, mirroring MARC's and PIC's team-size transfer. We compare against the LLM judge and the Set-LLM-style judge.
- Sequential conditioning. If the sequential ablation beats parallel critique by a margin larger than seed variance, SrSv's view holds for fact-checking. The right design would then be a short sequential chain with invariant aggregation inside each round, and we would report that.
- Stopping head. We measure how much of DRAG's remaining accuracy a second round recovers when it is triggered only for queries flagged as still likely wrong, and at what fraction of queries it is triggered.
References
- Removal of Hallucination on Hallucination: Debate-Augmented RAG
- LegalHalluLens: Typed Hallucination Failure Modes and Calibrated Multi-Agent Debate Mitigation
- Set-LLM: A Permutation-Invariant LLM
- Beyond Memory Majority: Latent-Source Reasoning for Multi-Agent Memory Arbitration
- Meta-Reflection: A Feedback-Free Reflection Learning Framework
- PIC: Permutation Invariant Critic for Multi-Agent Deep Reinforcement Learning
- Investigating Relational State Abstraction in Collaborative MARL
- SrSv: Integrating Sequential Rollouts with Sequential Value Estimation for Multi-agent Reinforcement Learning
- RAG-Critic: Leveraging Automated Critic-Guided Agentic Workflow for Retrieval Augmented Generation