Voting, Self-Consistency, and Debate Topology

Debate can improve accuracy (Du et al., arXiv:2305.14325). It can also degrade it. Whether it helps depends on four structural choices:

1. Who talks to whom (topology).
2. How many rounds (Du 2023: both rounds and agents matter independently).
3. Whether agents are heterogeneous (different base models break monoculture).
4. Whether an adversarial voice is present (steel-manning vs. straw-manning).

Teams that bolt "run 5 agents and vote" onto a task often regress against a single agent. The failures are not random. They track topology and heterogeneity, and this lesson is the topology map.

Self-consistency, the single-model baseline

Wang et al. 2022 ("Self-Consistency Improves Chain of Thought Reasoning") sampled the same model N times at temperature > 0 and majority-voted on reasoning-path answers. The result on GSM8K: substantial gains with N=40 samples over a single greedy decode. Self-consistency is the single-agent precursor to multi-agent voting.

The limit is that it uses one base model, so errors are correlated by construction. If the model has a systematic bias, all N samples share it.

Multi-agent vote, the heterogeneous extension

Replace N samples with N different agents: different base models (Claude, GPT, Llama), different prompts, different tool access. You get uncorrelated errors. You pay for it, because different agents cost different amounts and coordinating them adds overhead.

The canonical 2026 name for heterogeneous debate is A-HMAD, Adversarial Heterogeneous Multi-Agent Debate. It isn't universally adopted, but papers use it for "different models debate, which reduces correlated errors from monoculture collapse."

The four topologies

star                chain               tree                graph

    ┌─A─┐           A─B─C─D         ┌──A──┐              A───B
    │   │                           │     │              │ × │
    B   C                           B     C              D───C
    │   │                          / \   / \
    D   E                         D   E F   G           (fully connected)

Star: one hub, and the other agents talk only to the hub. Equivalent to supervisor-worker without a back-channel. Chain: linear, each agent sees the prior one's output. Pipeline-like. Tree: hierarchical, as in hierarchical agent systems (Lesson 06). Graph: any-to-any. Includes the fully-connected clique and arbitrary DAGs.

The coordination tax (MultiAgentBench)

MultiAgentBench (MARBLE, ACL 2025, arXiv:2503.01935) benchmarked star, chain, tree, and graph on a task suite including research, coding, and planning. The measured results:

• Graph topology wins on research tasks. Information flows any-to-any, so agents can critique each other.
• Star wins on fast-answer factual tasks. The hub filters and consolidates.
• Chain wins on stepwise pipelines (staged refinement).
• Coordination tax appears past ~4 agents in graph topology. Wall-clock and token cost grow faster than quality.

The 4-agent ceiling is empirical, not fundamental. It reflects 2026 LLM context capacity: each agent's context fills with peers' outputs, and the marginal value of agent N+1 drops once everyone can see everyone.

Multi-Agent Debate Strategies ("Should we be going MAD?")

arXiv:2311.17371 is the 2023 survey of MAD strategies. Its key finding, replicated by others, is that MAD variants that are structurally similar to self-consistency (independent sampling plus aggregation) often underperform self-consistency at the same budget. MAD helps most when agents are genuinely heterogeneous and the debate has adversarial structure, meaning one agent argues against.

AgentVerse emergent patterns

AgentVerse (ICLR 2024, https://proceedings.iclr.cc/paper_files/paper/2024/file/578e65cdee35d00c708d4c64bce32971-Paper-Conference.pdf) documents two behaviors that emerge from multi-agent debate even without explicit design:

• Volunteer. An agent offers help ("I can take the next step") unprompted. This is useful because it allocates work to the most capable agent for a subtask.
• Conformity. An agent adjusts its stance to match a critic, even when the critic is wrong. This is the debate-equivalent of sycophancy (Lesson 14).

Conformity is why debate-until-agreement rewards bullies. Bounded rounds with a separate judge soften the problem.

Heterogeneity: the knob that moves accuracy

A pattern in the 2024-2026 practical literature: swapping one of your N agents for a different base model gives a bigger accuracy bump than increasing N by 1. The intuition is monoculture. Each new independent source of error is worth more than one more correlated sample.

Heterogeneity beats numerosity. Three different models beat five copies of one model on most tasks that have clean ground truth.

Jury methods

The Sibyl framework (cited in Minsky-LLM literature) formalizes a "jury": a small set of specialized agents that refine answers by voting at each stage. Unlike plain majority vote, a jury has roles. One agent cross-examines, one supplies context, and one scores plausibility. Jury methods sit between plain vote (cheap, monoculture-prone) and full MAD (expensive, conformity-prone).

When vote-with-debate dominates

• The question has ground truth (fact, math, code behavior), so vote convergence means something.
• Agents can access different sources or tools, so heterogeneity is available.
• Rounds are bounded (2-3 typical) and there is a separate judge or verifier.
• Budget allows 3-5 agents. Beyond 5-7 on graph topology, coordination tax dominates.

When vote-with-debate hurts

• The question is opinion-shaped. Agents converge on whichever answer looks most confident, not most correct.
• The agents share a base model. Monoculture makes consensus meaningless.
• Rounds are unbounded. Conformity wins every time.
• The task is simple. A single agent with self-consistency at N=5 is cheaper and about as accurate.

code/main.py is a stdlib-only simulation. The agents are scripted, not LLM calls. It implements:

• run_star(agents, correct, rng): the first agent is the hub, the rest answer, and the final answer is the majority of the workers' answers.
• run_chain(agents, correct, rng): sequential refinement. Each agent proposes, and may replace the current answer with its proposal.
• run_tree(agents, correct, rng): a root plus two groups of leaves. Each group takes a majority, then the two group answers are combined.
• run_graph(agents, correct, rng, rounds=2): all-to-all debate with bounded rounds. Every agent proposes, then agents off the majority may switch to it.
• A scripted heterogeneity dial: each SimAgent has a base_accuracy and an error_bias, the wrong answer it drifts to on a miss. The homogeneous run gives every agent the same bias. The heterogeneous run spreads three different biases across the agents.
• A measurement harness that runs each topology at N=3, 5, 7 over 200 trials and reports accuracy, average tokens, and steps.

Run:

python3 code/main.py

Expected output: two tables, one homogeneous and one heterogeneous, each listing topology x N with accuracy, tokens, and steps. Steps stand in for latency, since the harness doesn't simulate wall-clock time. In the heterogeneous table, star goes from 0.75 at N=3 to 0.98 at N=7, graph is ahead of star at N=3 (0.89 vs. 0.75), and chain gets worse as N grows. Graph costs about twice the tokens of star at the same N.

outputs/skill-topology-picker.md is a skill that reads a task description and recommends a topology (star / chain / tree / graph), an N (number of agents), a heterogeneity profile (base models to use), and a round bound.

For any ensemble:

• Start with self-consistency at N=5 using one strong base model. It is the cheap baseline.
• Upgrade to heterogeneous voting at N=3 if accuracy matters, and measure the delta.
• Move to debate topology only if the task has structure (research, multi-step) and bounded rounds are feasible.
• Log the minority cluster. When a minority is persistently right, you have a diversity signal.
• Benchmark wall-clock and tokens alongside accuracy. "Better accuracy at 10x cost" is a business decision.

1. Run code/main.py. Plot the coordination-tax curve for graph topology: accuracy vs N, tokens vs N. At what N does the curve inflect?
2. Implement A-HMAD: three agents with deliberately different biases. How does the all-same-bias baseline compare to A-HMAD on the monoculture attack from Lesson 14?
3. Add a "judge" role to the graph topology that does not vote, only scores the final consensus. Does this change the emergent conformity behavior?
4. Read the AgentVerse paper (ICLR 2024). Identify which emergent behavior your implementation exhibits most strongly. Can you elicit the opposite behavior by a prompt change?
5. Read MultiAgentBench (arXiv:2503.01935) Section 4 (topology experiments). Reproduce the "graph-wins-research" result on one task from the paper using your harness.

• Wang et al.: Self-Consistency Improves Chain of Thought Reasoning: single-model baseline
• Du et al.: Improving Factuality and Reasoning via Multiagent Debate: both agents AND rounds matter independently
• MultiAgentBench / MARBLE: topology benchmark showing graph best for research, chain for pipelines
• Should we be going MAD?: MAD-strategy survey; finds MAD often loses to self-consistency at equal budget
• AgentVerse (ICLR 2024): volunteer and conformity emergent patterns
• MARBLE repo: reference benchmark implementation