When several language models reason about the same problem and disagree, current systems settle the matter in one of two ways. They count final answers (voting), or they let the agents read each other's answers and argue until they agree (debate). Both methods treat the answer as the thing in dispute. That is a poor fit for problems where rules conflict and some rules override others. On those problems the disagreement almost always comes from one or two premises, such as a misread exception, a missing background fact, or a preference applied in the wrong direction. When agents see the whole answer they tend to cave to the majority instead of repairing the premise. We propose to borrow two ideas from older traditions. From the Delphi method, a protocol for building expert consensus through anonymous, round-based, controlled feedback, we take the rule that experts never see each other's conclusions. They see only a structured summary of where they diverge. From meta-interpretation, the logic-programming practice of treating programs as data that another program can inspect, we take the tool that produces that summary: a small logic program that reads each agent's theory and computes the minimal set of premises responsible for the disagreement.
Concretely, each agent translates the problem into a defeasible logic theory. Defeasible logic is a rule language in which conclusions hold by default and can be overridden by stronger rules. A meta-interpreter runs every agent's theory and finds the "crux" clauses whose difference flips the answer. The only feedback returned to each agent is its own proof trace plus those anonymized disputed clauses. Agents revise or defend individual clauses over two or three rounds, and the final answer is computed by the interpreter from the resulting theories. The bet is that this keeps the error-correcting benefit of discussion and removes the social channel through which sycophancy spreads.
Core Claim
In multi-agent reasoning over conflicting rules, the unit of feedback matters more than the aggregation rule. Feedback made of machine-localized disputed premises, with peer answers withheld, should beat both answer-level voting and answer-level debate at matched compute. It should also beat the strongest simple neurosymbolic alternative, which samples several independent formalizations and majority-votes over the solver's outputs. The last comparison is the one that decides whether the Delphi iteration earns its cost.
Why this gap is real
Answer-level debate is known to fail on exactly this kind of reasoning. Voting or Consensus? Decision-Making in Multi-Agent Debate compares seven decision protocols with Llama 3. Consensus protocols reach 28.4% on MuSR, a benchmark of multistep narrative reasoning, against 54.8% for voting, and the authors document "drift" over long discussions. Peacemaker or Troublemaker: How Sycophancy Shapes Multi-Agent Debate measures how often a correct dissenter abandons its answer, which it calls disagreement collapse. The rate is about 81% on CommonsenseQA in decentralized debate and 41% with a dedicated judge agent. Persona prompting did not break the tight link between sycophancy and error (r = 0.902). Emergence of Biased Consensus in Multi-Agent LLM Debates models debate as a spin system and shows that low-temperature panels lock into biased consensus within one or two rounds. These three papers motivate the proposal: the failure lives in the channel through which agents see each other's conclusions.
The only automated Delphi system in the file, An LLM-based Delphi Study to Predict GenAI Evolution, runs a five-round forecasting Delphi. An LLM organizer summarizes the rounds, and embedding cosine similarity decides which items are redundant. It keeps Delphi's rounds and anonymity, but its feedback is still an LLM-written summary with no check on whether the aggregated arguments are coherent. That is the coordinator-bias problem of human Delphi, now automated. Our proposal replaces the coordinator with a deterministic program.
Single models also struggle with the reasoning itself, which constrains our design. BoardgameQA poses questions over contradictory rules with explicit preferences. On it, T5 XXL falls from about 90% at reasoning depth 1 to about 45–50% at depth 3. DEFREASING finds a "monotonicity bias," meaning models fail to retract a conclusion when new information should weaken it; the best F1 across 12 models is about 0.64. These results suggest the inference step should be handed to a symbolic engine, while translating text into rules remains the hard, error-prone step. That translation step is where disagreement among agents carries information.
The method comes from Direction 1. A Flexible Framework for Defeasible Logics encodes defeasible provability as a logic meta-program. Its switches select how ambiguity is handled (blocked or propagated) and whether a group of rules can jointly defeat an opposing rule ("team defeat"). Propositional theories run in polynomial time under Kunen's semantics. BoardgameQA's "Rule 2 is preferred over Rule 1" statements map directly onto that framework's superiority relation. Computing Preferred Answer Sets by Meta-Interpretation in Answer Set Programming shows the complementary move of reifying a program as ground facts (rule(r1). head(peng, r1).) so that a meta-program can reason about it. That is the representation we use to compare agents' theories. Logic Programing in Artificial Intelligence supplies the underlying principle that knowledge bases are data a meta-level program can inspect and revise.
We draw one idea, loosely, from Reflection as a Tool for Integration. Its ALICE system links a LISP interpreter and a Horn-clause interpreter so that each can inspect the other's execution state. Our system is two-sided in the same sense. The interpreter reads the agents' theories as data, and the agents read the interpreter's proof traces as data. We do not build ALICE's four-interpreter tower. The analogy is structural and not a reuse of its machinery, and we avoid its N² interpreter blow-up because only one side is a formal interpreter.
Research Program
The system runs as a small Delphi study for each question.
In round one, each of $K$ agents independently and blindly produces a theory. It is written in a restricted defeasible-logic syntax: facts, strict rules, defeasible rules, and superiority pairs. Every clause is tagged with the text span that licenses it, or marked "background" if the agent adds world knowledge the text does not state. BoardgameQA's missing-information cases and most of MuSR require such background clauses.
The meta-interpreter then reifies all $K$ theories as facts and computes each theory's answer and proof trace. For every pair of theories that disagree, it finds a minimal set of clause differences whose swap flips the conclusion. It does this with delta-debugging over the symmetric difference of the two clause sets, which is cheap because each check is a polynomial-time propositional run. The union of these minimal sets forms the round's crux items.
Controlled feedback follows Delphi's outlier rule. Each agent receives its own proof trace, the crux items phrased as clauses without authorship, and for each crux the fraction of agents holding each variant. It never receives peer answers. It must either revise the clause or submit a justification tied to a text span.
The same round also puts two things to vote. Genuinely contested semantic switches from the Antoniou et al. framework, such as ambiguity blocking and team defeat, become Delphi items the panel votes on. Background clauses are rated for acceptability, with a Delphi-style retention cutoff in the spirit of content validity ratios. This is the second direction of reflection: agents reason about how the interpreter should reason.
After at most three rounds, the sweet spot the sycophancy study identifies, the final theory is assembled. It takes the majority variant at each crux and the retained background clauses, and the interpreter computes the answer. Every answer comes with a proof trace that shows which premises were contested and how each was settled.
We will analyze three things beyond accuracy. The first is revision quality: of all clause revisions, what fraction move a clause from wrong to right versus right to wrong, judged against BoardgameQA's generating rules. The second is a premise-level disagreement collapse rate, which counts how often an agent holding a correct crux clause abandons it. The third is where cruxes concentrate: preference direction, exceptions, or background knowledge.
Baselines
The naive reference point is a single agent: one model with chain-of-thought, and separately one model that writes one defeasible theory which the same meta-interpreter executes. This separates how much comes from symbolic execution alone. The published anchors are the BoardgameQA depth figures above (T5 XXL at about 90% on depth 1 and about 45–50% on depth 3) and GPT-4 on MuSR at 80.4% on Murder Mysteries and 60.9% on Object Placement, with program-aided models at 87.2% on Team Allocation, from MuSR. We will rerun everything on our own models and not compare across papers directly.
The strongest answer-level multi-agent competitor is the best protocol from Voting or Consensus?. On reasoning tasks that is voting after all agents draft independently, which reports 54.8% on MuSR against 28.4% for consensus. We run it with the same backbone models (Llama 3 70B and Qwen3-32B, as in the cited papers), the same number of agents, and a token budget matched to ours. We add the centralized-judge variant from the sycophancy study, which cut collapse from about 81% to 41% on CommonsenseQA, as the strongest anti-sycophancy debate design.
The strongest neurosymbolic competitor, and the real threat, is formalization self-consistency. It samples $K$ independent theories exactly as in our round one, executes each with the same interpreter, and majority-votes the answers. No result for this on BoardgameQA, MuSR, or DEFREASING was found on Lacuna. It shares our translator, interpreter, and compute, so it isolates the question of whether iteration helps. We give it the same total token budget, which lets it sample several times more theories than our round one.
The ablations each remove one ingredient. The first returns peer answers alongside cruxes, which isolates the value of withholding conclusions. The second returns full peer theories without crux localization, which isolates the value of the minimal-difference computation. The third drops the justification requirement for keeping a dissenting clause. The fourth fixes the semantic switches instead of voting on them. Beating the baselines means higher accuracy than formalization self-consistency at matched tokens on BoardgameQA depth 3, with a confidence interval over three seeds that excludes zero. It also means a lower premise-level collapse rate than the answer-visible ablation.
Why not just…?
Why not just majority-vote over independently sampled formalizations? This is the alternative most likely to match us, because translation errors that are independent across samples wash out under voting without any communication. It fails when errors are correlated, for example when most samples read an exception clause the same wrong way, or when the right background clause appears in a minority of samples and needs argument to spread. Nothing in the file measures this, so the experiment decides it. If our method does not beat formalization self-consistency at matched compute, the Delphi rounds add nothing, and we will report the crux-localization tool as a diagnostic instead of claiming a reasoning gain.
Why not just use debate with a judge, or tune the personas? The sycophancy study shows that persona tuning leaves collapse tightly coupled to error. Its judge still lets correct dissenters collapse in 41% of cases, because the judge and the debaters are exchanging conclusions. Our answer-visible ablation tests the specific mechanism: if collapse rises once peer answers are shown alongside cruxes, then hiding conclusions matters. If collapse does not rise, the structure of the feedback is doing the work.
Why not just raise or vary the sampling temperature? Emergence of Biased Consensus shows that heterogeneous temperatures around 1.3–1.7 prevent lock-in. That buys diversity but no repair mechanism, and high temperature degrades the syntactic validity of generated theories. We include a heterogeneous-temperature variant of formalization self-consistency so that diversity alone is controlled for.
Why not just translate once and run a solver? Single-shot translation is our first baseline. BoardgameQA's missing-information cases and MuSR's reliance on unstated commonsense suggest a single translator will omit or fabricate background clauses. The planned breakdown by crux type will show whether our gains come from those background items. If gains concentrate there, the elicitation role of Delphi is doing the work.
Proposed Experiments
The primary test uses BoardgameQA across depths 1–3, with the 500-example validation split used for prompt development and the 1,000-example test split for reporting. Its generated ground-truth rules let us score revision quality clause by clause. We predict the gap over formalization self-consistency grows with depth, since deeper problems contain more places where one misread preference flips the answer.
The second test uses DEFREASING, split by its strengthening, weakening, and no-impact conditions. We ask whether the interpreter plus premise-level feedback removes the monotonicity bias. The weakening condition is the telling one, and the nonsense-type split checks whether gains survive without real-world priors.
The third test uses MuSR as a stress test. Its narratives resist clean formalization, so it may expose the limits of the approach, and a loss there to answer-level voting would be informative, not embarrassing. We also measure premise-level and answer-level collapse rates, and tokens per question for every method. Tokens let reviewers judge whether any gain is bought with compute.
The decisive checks are two. The first is BoardgameQA depth 3 accuracy against formalization self-consistency at matched tokens. The second is the answer-visible ablation's effect on collapse. If both go our way, we will have shown that resolving disagreement at the level of premises, with a program deciding what gets discussed, is a better way for model panels to reach agreement. If only the first goes our way, the gain comes from localization and not from anonymity. If neither does, the Delphi rounds are unnecessary once a solver is in the loop.
References
- Voting or Consensus? Decision-Making in Multi-Agent Debate
- Peacemaker or Troublemaker: How Sycophancy Shapes Multi-Agent Debate
- Emergence of Biased Consensus in Multi-Agent LLM Debates
- An LLM-based Delphi Study to Predict GenAI Evolution
- BoardgameQA: A Dataset for Natural Language Reasoning with Contradictory Information
- Evaluating Defeasible Reasoning in LLMs with DEFREASING
- A Flexible Framework for Defeasible Logics
- Computing preferred answer sets by meta-interpretation in answer set programming
- Logic Programing in Artificial Intelligence
- Reflection as a Tool for Integration: An Exercise in Procedural Introspection
- MuSR: Testing the Limits of Chain-of-thought with Multistep Soft Reasoning