How to Run an Adversarial Debate

audience

this note is read by agents.

role

it is an operating procedure.

rule

how to write a literature note (./how_to_write_a_literature_note.org) is read first.

• why: this protocol is an escalated mode of it, applicable to any literature note — law is only a frequent case.
• scope: the general guide’s whole sourcing discipline applies to every role.

rule

the debate complements the neutral audit rather than replacing it.

• why: it guards against the confirmation bias a lone author slides into — the structured-dissent remedy for what Janis called groupthink¹.
• why: for AI the wager is the alignment one — set agents against each other before a blind judge, betting a good answer is easier to verify than to generate².
• scope: it fires only on a question that warrants it.

rule

the roles are coordinated buddies.

• authority: the auditor is a different party from the author.
• how: the coordination and spawn tools are self-describing MCP tools, discovered via the catalogue.

rule

the debate’s whole state lives on disk.

• why: state on disk rather than in ephemeral messages is what lets the debate survive a buddy dying mid-phase.
• how: the buddies do not chat — they coordinate through the cartographer’s neutral seed in the note’s map block plus one argdown fragment file per defender, each owned by exactly one buddy and merged into a single rendered map by title (:argdown-include).
• how: the orchestrator passes only a phase token.

rule

the defenders work in parallel.

rule

they work in phase-synchronised rounds.

• why: under the round-robin that was the first design, the second defender reads the first’s nodes before forming its own case, so the first author frames the battlefield — the exact anchoring bias the debate exists to kill.
• why: this blind-then-feedback design is the Delphi method’s core — experts kept anonymous so they « cannot be influenced by political and social pressures », a facilitator relaying only controlled feedback between rounds³.
• why: for LLM debaters specifically, stripping identity cues reduces bias⁴.

rule

the seed a defender reads is the cartographer’s neutral framing alone, never the surrounding prose that argues for or against positions.

• why: that editorial voice would contaminate the blind read.

rule

the file boundary enforces the defenders’ independence, exactly as it does the auditor’s.

• why: a defender never edits a file it does not own, so merge-by-title never collides.

rule

a debate still churning after a handful of rounds is surfacing a real disagreement, not asking for more rounds.

• why: Delphi sets the same expectation — consensus is not agreement but « the variability of the responses has decreased to a satisfactory level », and « Usually two or three rounds are sufficient. »³
• why: seeking consensus is classic Delphi, and documenting the dissent instead is Policy Delphi — Turoff’s variant built « to generate the strongest possible opposing views on the potential resolutions of a major policy issue  »⁵.

rule

the orchestrator owns the barrier.

• why: the barrier is what kills cross-influence, and is also what once killed the debate.
• how: within a phase no buddy sees another’s current work, and everyone reacts, next phase, to the same frozen snapshot.
  • why: the quickest defender then cannot nudge the slowest.
• how: phase N+1 is released only once every live defender has reported phase N, event-driven on the coordination wait.
• how: the orchestrator passes a phase token and nothing else — « steelman », « attack », « react » — relaying no argument content, exactly the Delphi facilitator’s controlled feedback.
  • why: the content is in the files.

rule

the orchestrator detects the fixed point mechanically, by diffing the fragment files between rounds, without reading their content.

• how: the debate_round_check MCP tool does it — one call per round, the fragment paths plus a stable label, its first line FIXED_POINT: yes|no.

rule

every per-round orchestrator step is a pre-approved tool.

• why: a shell call that trips a permission prompt mid-round blocks the orchestrator, and the idle defenders are pruned before it clears — the exact stall that once killed a run.

rule

the parallel round is safe where it once collapsed.

• why: the earlier failure — a parallel fan-out that left the defenders blocked, idle past the prune window, until the ephemeral registry collapsed — was a liveness bug, a barrier nobody owned, compounded by clobbering, many writers on one file.
• why: file-per-defender removes the clobbering, and an orchestrator-held barrier removes the stall.
• why: between phases each defender sits in the coordination wait, which exempts it from pruning.

rule

the orchestrator manages each role’s lifecycle, spawn and kill.

• how: a defender that does not answer a phase is skipped and the gap is noted, and the orchestrator does not conclude in its place.
• rule: a pruned or dead buddy is respawned and pointed at its own file.
  • why: it loses nothing, since its state is that file.

rule

the orchestrator hands a worker it spawns or respawns the exact file paths it needs, as clear links — this protocol note, the general guide (./how_to_write_a_literature_note.org), the argdown note (./argdown_in_org_mode.org), and the worker’s own fragment file.

• why: an org id: link does not resolve without the roam database, so a buddy given only an id wastes a turn grepping the note tree for it.

rule

one fresh buddy per role.

rule

the model is chosen per role.

• why: the roles are not equally demanding.
• authority: each audit runs on the model the work needs.
• why: spawning every role on the cheap tier to save tokens is a false economy — a defender that strawmans, an auditor that rubber-stamps, or a cartographer that hands the debate a hand-picked framing each defeats the point of the debate.
• rule: the defenders and the auditor run on the strongest model.
  • why: they do the load-bearing reasoning — steelmanning a thesis, mounting sourced attacks on the strongest rival reading, judging whether an epistemic tag is inflated or a balance is false — which is nuanced work.
• rule: the cartographer runs on a cheaper model only when the enumeration is mechanical — the positions already laid out in the sources, as in a typical factual or legal question.
• rule: the cartographer runs on the strong model when the enumeration itself takes judgement.
  • why: on an open-ended, methodological or contested-framing question the positions are not pre-listed anywhere and the real risk is missing the one no one anticipated, so the completeness pass is the load-bearing step.

rule

genuinely different readings, and where you can different models, are assigned to different defenders rather than near-duplicates.

• why: « intrinsic reasoning strength and group diversity are the dominant drivers of debate success, while structural parameters such as order or confidence visibility offer limited gains »⁴.
• why: the orchestration earns its keep by removing failure modes — clobbering, stalls, anchoring — rather than by manufacturing insight, so diversity is what makes the debate pay.

When to escalate: the contested question

rule

a settled or purely factual question goes the normal way — a neutral author, a fresh audit.

• why: there is no debating « how to compute π », and forcing a debate onto such a question manufactures a controversy where there is none.

rule

debate fires when the question genuinely admits several defensible but incompatible answers, as typical law questions do.

rule

once it qualifies, the positions are enumerated from the sources, neutrally, before any role is assigned.

• why: otherwise the debate inherits a hand-picked framing and misses the position no one anticipated — « the invoked text does not even apply ».

rule

where the question debates its own method or host document, the positions are stated from outside that document’s voice.

• why: its prose already argues a side, so the debate would silently inherit the host’s thesis and a position the host disfavours would start handicapped.

The roles

rule

the debate has three roles, and no scribe.

• why: the map records itself.

rule

the cartographer runs the completeness pass — it confirms the question is suitable for debate and lists the positions, each stated neutrally with its anchoring source or sources.

• how: it seeds the map with the root claim and one node per position, then leaves.
• scope: it inventories, it does not argue.

rule

a defender takes one position and owns one fragment file, which it extends in phase-synchronised rounds.

• rule: an attack rests on sourced arguments, never on a weak point a position would not stand behind.
• rule: it tags by epistemic strength the sourced nodes it adds, and not a derived conclusion.
  • why: a derived conclusion takes its colour by weakest-link propagation, so an asserted tag would override and inflate it (see Weight settles it).

rule

the auditor is fresh, blind to any stake — never « the client hopes that … » — and checks the map against the discipline.

• why: otherwise the debate corrects nothing.
• how: every node carries a source link, the epistemic tags are justified rather than inflated, attacks target the strongest reading, and weight is not falsely symmetric.
• rule: it also checks that no defender has quietly abandoned a well-sourced minority reading just because the map leaned the other way.
  • why: even phased, the attack and react rounds expose each defender to the majority of the nodes on the map, and « majority pressure suppresses independent correction »⁴.

The shared map: the medium

rule

the files are both the medium and the output.

• why: there is no broadcast channel to miss, no membership to race, no transcript to reconstruct — whoever opens the merged map reads the current state.
• how: the cartographer’s neutral seed sits in the note’s map block and =:argdown-include=s one argdown fragment file per defender, all merged into a single rendered map by title.

rule

the cartographer seeds the framing — the root claim and one node per enumerated position, the shared neutral starting point.

• how: it wires the per-defender :argdown-include, leaves each defender an empty fragment file to own, and leaves.

rule

one owner per file, so parallel writes never clobber.

• how: the many-to-many exchange happens through the merged map each defender reads at the start of a phase.
• scope: a defender that misses a phase loses nothing — its file stays as it was on disk.

rule

the auditor reads the merged map, and only the map.

• why: it then sees the neutral artifact rather than the per-defender advocacy files that produced it, so the file boundary enforces « fresh and blind » structurally, with nothing ephemeral to prune or lose.

rule

at the end the orchestrator collects the map and the auditor’s verdict, then kills the workers.

• scope: the map persists in the note either way.

rule

a debate names its fragment files and block names uniquely to its own note.

• why: :argdown-include merges by title, so two debates sharing fragment names silently bleed into each other’s maps — the demo below and a live run of the same question would otherwise populate one shared set of files.

rule

once the fixed point is reached and the audit passes, the merged map is inlined into the note’s own block and the fragment files are deleted.

• why: the per-defender fragment files are scaffolding rather than the deliverable — they exist so parallel defenders write without clobbering, and that job is then done.
• why: the state then persists inline and self-contained.

rule

a debate note is not ready to publish until its final block has been run.

• why: the published note then carries the rendered map rather than raw argdown source.

Steelman without cheating

rule

defending a thesis means assembling its strongest version, not spinning it.

• how: Rapoport’s rules give the order of operations — re-express the rival’s position so well it would say « thanks », and bank what you agree with and learned from it, before a word of rebuttal⁶.

rule

an attack targets the strongest reading of the opposing thesis.

• why: scoring a point against a caricature settles nothing.

authority

every claim links to a footnote holding the verbatim that justifies it.

• why: the adversarial part is about which sources and arguments are surfaced, and it licenses no unsourced claim.
• rule: a thesis with only unsourced claims to defend itself is not a position in the debate but an opinion, and it falls at the audit.

Weight settles it, not the number of defenders

rule

the debate ensures each position is steelmanned, and says nothing about its weight.

• why: the format’s trap is false balance — giving equal weight to two theses because each was assigned a defender.

rule

weight is established by evidence, by the domain’s own authority indicators — level and convergence of sources, recognition, dominant or marginal character, recent trend, in law for instance publication au bulletin, doctrinal dominance, level of the decisions.

• how: in the map that weight is the node’s epistemic tag (#(bare assertion) … #(established consensus), weak→strong, rendered as a red→green border).
  • why: the map then renders a weakly-backed claim red however many defenders pile nodes onto it, so false balance is visible rather than merely discouraged.
• how: the defender tags each source node it adds, and the auditor contests inflated tags.
• scope: a thesis defended hard but carried by a single isolated source is tagged accordingly — the defence made it strong, the weight puts it back in its place.

rule

the auditor flags a one-sided source supply as an asymmetry rather than reading the thin side as settled.

• why: a position the available corpus mostly argues against is starved of citable nodes, so its thin, weakly-tagged defence may reflect the corpus’s slant rather than the thesis’s true weight — under-sourced is not refuted.
• why: this extends source quality is part of the claim — the weight of what backs a claim is part of it too.

rule

a position’s standing is how well it survives the attack edges, not how many defenders or citations it piled up.

• why: robustness reads the analysis-of-competing-hypotheses way — « The most probable hypothesis is usually the one with the least evidence against it, not the one with the most evidence for it. »⁷

The output: the state of the debate

rule

the map is the « state of the debate », accumulated in place rather than synthesized after the fact.

• how: the positions and their best sourced arguments are its nodes.
• how: the points of friction are its unresolved attack edges (- / ><, which source and which exact reading is disputed).
• how: each position’s weight is its epistemic tags.
• how: what would settle it is the residue the phased rounds could not close — the missing fact to request, the reference source to consult, the awaited evolution or decision.

rule

the output is a documented disagreement rather than a forced conclusion.

• authority: a note that ends in cited, unresolved disagreement is finished, not failed.
• how: it feeds the outward « bridge » — the surgical questions only a reference source, often closed or paid, or a human can settle.
  • scope: only open content enters the note.
• why: that handoff is adversarial collaboration’s move — rather than declare a winner, the opposed sides commit to the joint research that would settle it⁸.

Demo debate: how should agents debate to reach a good conclusion?

The question, and why it qualifies

rule

this heading dogfoods the protocol on a meta question — how should a fleet of agents orchestrate — or forgo — their debate so that they reach a neutral, concrete, complete and good conclusion?, the protocol turned on itself.

rule

the question qualifies for debate.

• why: the orchestration discipline genuinely admits several defensible but incompatible answers — round-robin, phase-synchronised parallel, independent-then-aggregate, a free-for-all, a judge-led tournament, and forgoing the debate altogether.
• why: the conclusion feeds straight back into Orchestration discipline above.

rule

this is deliberately a harder dogfood than a factual question.

• why: the domain is methodological, so many claims are reasoned rather than citable, which stresses the discipline where it is most load-bearing — never assert it bare — and the #(bare assertion) tag that marks a claim with no source as worth zero.

rule

a run that ends thin, with weak tags and a documented disagreement, is a finding about the protocol rather than a failure of it.

What the run did

report

this heading has been run live by the protocol above — a cartographer seed, then six file-per-defender buddies extending one fragment file each through phase-synchronised rounds, the orchestrator holding the barrier and diffing the fragments with debate_round_check.

report

the files each buddy was handed, as clear paths, are this note (./how_to_run_an_adversarial_debate.org), the general guide how to write a literature note, and argdown in org-mode for the syntax and the epistemic tags.

report

the block below is the merged map, inlined, the fragment files deleted and the block run, so the note publishes the rendered map rather than raw source.

report

the judge-tournament defender stalled and never wrote — the liveness failure Orchestration discipline warns of — and stalled again after a respawn.

• report: its position was then orchestrator-seeded from verified quotes and marked represented-but-undefended, rather than strawmanned by omission.
• report: phase-parallel conceded in the map that the barrier’s coordination cost is real, citing that stall as the proof.

What it settled, and what it did not

report

the payoff is a documented disagreement, node [debate-residue], and no position was refuted.

report

the live trades are anchoring magnitude under round-robin against barrier staleness, and — the sharpest — whether phase-parallel’s blind barrier actually fixes the « majority pressure suppresses independent correction » it invokes.

• why: the study documents the problem but does not test the barrier-fix, while the barrier’s cost is measured.

residue

what would settle it is a controlled run of the blind-barrier design against an independent-aggregate baseline on the same question — the outward « bridge » — and that result feeds straight back into Orchestration discipline above.

Notes linking here

• how to write and audit a note

Permalink