Paper deep dive

From Debate to Deliberation: Structured Collective Reasoning with Typed Epistemic Acts

Sunil Prakash

Year: 2026Venue: arXiv preprintArea: cs.AIType: PreprintEmbeddings: 75

Intelligence

Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 97%

Last extracted: 3/22/2026, 6:27:47 AM

Summary

The paper introduces Deliberative Collective Intelligence (DCI), a multi-agent LLM framework that models reasoning as a phased, structured deliberation process rather than simple debate or voting. DCI utilizes a delegate model with four archetypes, an interaction grammar of 14 typed epistemic acts, and a convergent flow algorithm (DCI-CF) to ensure structured, accountable decision-making with preserved dissent.

Entities (5)

DCI-CF · algorithm · 100%Deliberative Collective Intelligence · framework · 100%Delegate Archetypes · role-model · 95%Epistemic Acts · interaction-grammar · 95%Gemini 2.5 Flash · llm · 95%

Relation Signals (4)

DCI → defines → Epistemic Acts

confidence 100% · DCI specifies... 14 typed epistemic acts

DCI → includes → Delegate Archetypes

confidence 100% · DCI specifies (1) a delegate model with four reasoning archetypes

DCI → utilizes → DCI-CF

confidence 100% · DCI specifies... DCI-CF, a convergent flow algorithm

DCI → implementedon → Gemini 2.5 Flash

confidence 95% · We implement DCI on the jamjet agent runtime using Gemini 2.5 Flash

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:Multi-agent LLM systems increasingly tackle complex reasoning, yet their interaction patterns remain limited to voting, unstructured debate, or pipeline orchestration. None model deliberation: a phased process where differentiated participants exchange typed reasoning moves, preserve disagreements, and converge on accountable outcomes. We introduce Deliberative Collective Intelligence (DCI), specifying four reasoning archetypes, 14 typed epistemic acts, a shared workspace, and DCI-CF, a convergent flow algorithm that guarantees termination with a structured decision packet containing the selected option, residual objections, minority report, and reopen conditions. We evaluate on 45 tasks across seven domains using Gemini 2.5 Flash. On non-routine tasks (n=40), DCI significantly improves over unstructured debate (+0.95, 95% CI [+0.41, +1.54]). DCI excels on hidden-profile tasks requiring perspective integration (9.56, highest of any system on any domain) while failing on routine decisions (5.39), confirming task-dependence. DCI produces 100% structured decision packets and 98% minority reports, artifacts absent from all baselines. However, DCI consumes ~62x single-agent tokens, and single-agent generation outperforms DCI on overall quality. DCI's contribution is not that more agents are better, but that consequential decisions benefit from deliberative structure when process accountability justifies the cost.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

74,989 characters extracted from source content.

Expand or collapse full text

From Debate to Deliberation: Structured Collective Reasoning with Typed Epistemic Acts Sunil Prakash Indian School of Business, India sunil_prakash_pgpmax2026@isb.edu Abstract Multi-agent LLM systems increasingly tackle complex reasoning tasks, yet their interaction patterns remain limited to parallel generation with voting, unstructured debate, or rigid pipeline orchestration. None of these paradigms model deliberation—a phased process in which differentiated participants exchange typed reasoning moves, preserve disagreements as productive tensions, admit new evidence under controlled rules, and converge on an explicit, accountable outcome. We introduce Deliberative Collective Intelligence (DCI), a framework that treats collective reasoning as a first-class computational object. DCI specifies (1) a delegate model with four reasoning archetypes, (2) a phased session model, (3) an interaction grammar of 14 typed epistemic acts organized in a three-layer model, (4) a shared workspace for structured collective thought, and (5) DCI-CF, a convergent flow algorithm with formal termination guarantees that always produces a structured decision packet—including the selected option, residual objections, minority report, and reopen conditions—even under persistent disagreement. We implement DCI on the jamjet agent runtime using Gemini 2.5 Flash and evaluate on 45 tasks across seven domains—including software architecture, policy analysis, hidden-profile integration, late-evidence revision, risk analysis, disagreement resolution, and routine decisions as a negative control—organized around four hypotheses. We find that on non-routine tasks (n=40n=40), DCI significantly improves over unstructured debate (+0.95+0.95, 95% CI [+0.41,+1.54][+0.41,+1.54]), indicating that deliberative structure matters when multiple agents interact (H1). DCI excels on hidden-profile tasks requiring integration of partial perspectives (9.56, the highest score of any system on any domain) and significantly outperforms all baselines on such tasks, while failing on routine decisions (5.39), confirming strong task-dependence (H2). DCI produces 100% structured decision packets and 98% minority reports—process artifacts absent from all baselines. However, DCI is expensive: it consumes ∼62× 62× the tokens of a single agent, and single-agent generation significantly outperforms DCI on overall quality (−0.60-0.60, CI [−1.06,−0.15][-1.06,-0.15]), indicating that structured deliberation is not justified for routine tasks (H3). Component contributions are not clearly separable at our sample size (H4). DCI’s contribution is not that more agents are better, but that consequential decisions—especially those requiring integration of partial information, multi-stakeholder reasoning, and explicit risk surfacing—benefit from deliberative structure when process quality and accountability matter enough to justify the cost. 1 Introduction Large language models (LLMs) have demonstrated remarkable reasoning capabilities when applied individually, yet many consequential decisions—architectural design, policy analysis, strategic planning—benefit from multiple perspectives, structured argumentation, and explicit consideration of tradeoffs. The multi-agent paradigm promises to deliver these benefits by assembling multiple LLM instances into collaborative systems. In practice, however, current multi-agent approaches operate through surprisingly limited interaction patterns. Prior multi-agent LLM systems mainly aggregate, debate, or orchestrate. DCI instead models collective reasoning as deliberation: a phased process in which differentiated delegates exchange typed epistemic acts, preserve tensions, admit new evidence, and still close with an explicit result through bounded convergence. Deliberation, in this sense, is a distinct computational primitive—not a refinement of debate, not an optimization of voting, but a qualitatively different way of organizing multi-agent interaction. To make this distinction precise, consider the four dominant paradigms: • Ensembling (self-consistency, best-of-N) generates independent reasoning paths and selects among them (Wang et al., 2023). There is no interaction between paths, no mutual refinement, and no record of why paths disagreed. • Debate allows agents to argue freely over answers across rounds (Du et al., 2023; Liang et al., 2023). Interaction exists, but it is untyped: a challenge is indistinguishable from a proposal at the protocol level. There is no phased progression, no structured workspace, and no guarantee that disagreement is preserved rather than flattened. • Orchestration (AutoGen, MetaGPT, CrewAI) chains agents in workflows with role assignments (Wu et al., 2023; Hong et al., 2023; CrewAI, 2024). The focus is task decomposition and handoff, not reasoning interaction. A MetaGPT pipeline does not distinguish between a proposal and a challenge, and it does not preserve dissent. • Voting collects independent judgments and selects by majority or judge (Irving et al., 2018). It aggregates preferences but does not transform them through engagement. None of these paradigms produce what we term deliberated intelligence: decisions that emerge from structured examination where assumptions are surfaced, dissent is preserved, reasoning is typed and traceable, and the process guarantees a bounded, explicit outcome. DCI fills this gap by treating deliberation as a first-class computational object—a session with typed acts, phased progression, a shared workspace, tension tracking, and a convergent algorithm that always terminates with a structured decision packet. Contributions. This paper makes the following contributions: 1. We define deliberative collective intelligence as a distinct interaction paradigm for multi-agent LLM systems, distinguishing it from ensembling, debate, orchestration, and voting. 2. We introduce DCI, a session-based framework with differentiated delegate archetypes, a phased session model, an interaction grammar of 14 typed epistemic acts, explicit tension tracking through a shared workspace, and structured decision packets. 3. We propose DCI-CF, a convergent deliberation algorithm that preserves epistemic openness while guaranteeing bounded procedural closure—every session terminates with a decision packet containing the selected option, residual objections, minority report, and reopen conditions. 4. We present an empirical evaluation on 45 tasks across seven domains organized around four specific hypotheses, showing that structured deliberation significantly improves over unstructured debate on non-routine tasks and excels on hidden-profile perspective-integration tasks, while exposing substantial efficiency tradeoffs against simpler alternatives and confirming task-dependence through a routine negative control. Figure 2 provides a compact end-to-end walkthrough of a DCI session, illustrating how typed acts, tension preservation, and the decision packet work in practice. 1.1 What is New in DCI? DCI’s contribution is not any single component but their combination into a coherent deliberation protocol. Five elements, taken together, distinguish DCI from all prior multi-agent LLM systems: 1. Typed epistemic interaction. Agents exchange structured reasoning moves—propose, challenge, bridge, synthesize—not undifferentiated text. The protocol distinguishes a challenge from a proposal at the structural level, enabling enforceable discourse rules and analyzable interaction patterns. 2. Session-based deliberation. Collective thinking is organized into phases (arrival, independent thought, mutual engagement, collective shaping, closure), not just rounds. Phases create a deliberate arc from divergence through engagement to convergence, preventing premature consensus. 3. Tensions as first-class objects. Disagreements are preserved in the shared workspace, not flattened by majority rule or lost in transcript accumulation. Tensions carry structure: which positions conflict, what evidence supports each side, and what would resolve the disagreement. 4. Bounded openness. New evidence and hypotheses can enter the deliberation, but under controlled admission rules (materiality, distinctness, evidence linkage, and a cutoff round). This prevents both premature closure and endless expansion. 5. Guaranteed procedural convergence. Every DCI session terminates with a structured decision packet—the selected option, residual objections, a minority report preserving dissent, and explicit reopen conditions—even under persistent disagreement. The convergence guarantee is procedural, not epistemic: DCI guarantees a fair and bounded process, not truth or optimality. DCI’s novelty lies in combining typed epistemic interaction, session-based deliberation, explicit tension preservation, bounded openness to new hypotheses, and guaranteed procedural closure into a single protocol for collective reasoning. No prior multi-agent LLM system integrates all five. 2 Background and Related Work DCI draws on multi-agent LLM systems, ensemble reasoning, and deliberative governance theory. We review each strand, positioning DCI as a synthesis that addresses gaps left by each individually. 2.1 Multi-Agent Debate Du et al. (Du et al., 2023) demonstrated that multi-agent debate—where LLM instances argue over answers across multiple rounds—improves factual accuracy and mathematical reasoning over single-agent baselines. Liang et al. (Liang et al., 2023) further showed that encouraging divergent thinking in multi-agent debate reduces sycophantic convergence. Irving et al. (Irving et al., 2018) proposed AI safety via debate for scalable oversight. These approaches demonstrate the value of multi-agent interaction but lack formal structure: agents communicate through free-form text, there is no typed grammar constraining interaction patterns, no phased progression from exploration to convergence, and no guarantee of termination with a structured outcome. 2.2 Multi-Agent Frameworks AutoGen (Wu et al., 2023) provides a group-chat abstraction with a manager agent mediating turns. CAMEL (Li et al., 2023) uses role-playing for cooperative interaction. MetaGPT (Hong et al., 2023) assigns software engineering roles and coordinates through structured outputs. CrewAI (CrewAI, 2024) defines tasks and roles for multi-agent workflows. These frameworks advance multi-agent coordination infrastructure, but they focus on task decomposition and orchestration rather than deliberation. An AutoGen group chat does not distinguish between a proposal and a challenge. A MetaGPT pipeline does not preserve dissent or surface hidden assumptions. DCI addresses a complementary need: principled structure for the reasoning interaction itself. 2.3 Ensemble Methods and Self-Consistency Wang et al. (Wang et al., 2023) introduced self-consistency, which samples multiple reasoning paths and selects the most common answer. Chen et al. (Chen et al., 2023) and Ong et al. (Ong et al., 2024) explored model routing and cascading. These ensemble approaches improve accuracy through diversity but operate independently—there is no interaction between paths, no mutual refinement, and no examination of why paths disagree. DCI generates diversity through differentiated delegates and then uses disagreement productively through structured challenge and synthesis. 2.4 Deliberative Democracy and Speech Act Theory Habermas’s theory of communicative action (Habermas, 1984) argues that legitimate collective decisions emerge from discourse governed by procedural norms. Fishkin’s deliberative polling (Fishkin, 2018) demonstrates empirically that structured deliberation produces more informed collective judgments than unstructured discussion or voting. Speech act theory (Austin, 1962; Searle, 1969) provides the linguistic foundation for typed interaction moves: utterances are acts, not merely information transfer, and the discourse structure should reflect the type of act being performed. DCI adapts these principles for LLM agents, accounting for their specific characteristics: high fluency but bounded reasoning, tendency toward sycophantic agreement, and differentiability through system prompts. 2.5 Social Choice and Arrow’s Impossibility Arrow’s impossibility theorem (Arrow, 1951) establishes that no rank-order voting system can satisfy a small set of fairness criteria simultaneously. DCI-CF’s convergence mechanism acknowledges this: rather than claiming optimal aggregation, it guarantees termination with transparency. When a decision is forced rather than emergent, the minority report and reopen conditions make the procedural nature of the outcome explicit. 2.6 Positioning The preceding review reveals that current multi-agent LLM systems lack: (1) a typed interaction grammar that distinguishes reasoning moves at the protocol level; (2) a termination guarantee with transparent forced-decision procedures; (3) first-class dissent preservation; (4) a structured workspace rather than flat transcripts; and (5) a principled session model that applies phased deliberation to LLM collectives. DCI addresses all five gaps within a single framework. 3 The DCI Framework DCI models multi-agent reasoning as governed discourse among a small council of differentiated delegates. The framework comprises four components: a delegate model, a session model, an interaction grammar, and a shared workspace. 3.1 Delegate Model Without differentiated delegates, collective intelligence collapses into duplicated intelligence. Each delegate carries an identity, a reasoning style, a known limitation, a current perspective (which evolves during deliberation), and a willingness to revise. DCI defines four core archetypes that provide complementary cognitive functions: • Framer (δF _F): Defines the real problem. Clarifies ambiguity, identifies hidden dimensions, decomposes mixed issues, and determines what questions actually need answering. • Explorer (δE _E): Generates novel possibilities. Proposes unconventional paths, fresh structures, analogies, and generative expansions. Opens the solution space before the group narrows it. • Challenger (δC _C): Pressure-tests everything. Searches for hidden assumptions, weak logic, risks, blind spots, and overconfidence. • Integrator (δI _I): Combines the group’s thinking into coherent direction. Identifies common patterns, synthesizes positions, manages session coherence, and builds the emerging center of gravity. Formally, a delegate δi _i maintains local state σi=⟨vi,ci,Qi,Ri,Hi⟩ _i= v_i,c_i,Q_i,R_i,H_i where viv_i is the current view, ci∈[0,1]c_i∈[0,1] is confidence, QiQ_i is the set of open questions, RiR_i is the set of active concerns, and HiH_i is the history of position shifts. This state evolves through interaction: a delegate that receives a strong challenge and updates its position records the shift in HiH_i and adjusts cic_i accordingly. Archetypes constrain tendency, not capability: a Challenger can still propose, and an Explorer can still challenge. The archetype biases the distribution of interaction acts, implemented through differentiated system prompts. 3.2 Session Model A DCI session S is a bounded collaborative thinking event in which a small council of delegates works on one problem. The session unfolds through five phases: 1. Arrival (ϕ1 _1): The session grounds itself. The group identifies the central question, notes scope and boundaries, names uncertainties, and establishes an exploratory tone. Output: shared problem statement. 2. Independent First Thought (ϕ2 _2): Each delegate contributes its initial view before being shaped by others: how it sees the problem, what it thinks matters most, what it suspects is hidden, one possible direction. This preserves diversity before social influence. 3. Mutual Engagement (ϕ3 _3): The heart of the session. Delegates respond to one another through typed interaction acts: extend, question, challenge, bridge, clarify, reframe, deepen. The goal is movement—improved ideas, clearer tensions, and genuine synthesis opportunities. 4. Collective Shaping (ϕ4 _4): The group turns discourse into shared structure: recurring themes, strongest ideas, most important tensions, what seems central, what can be discarded. Output: common ground, live tensions, 2–4 candidate paths, and a preferred direction. 5. Closure (ϕ5 _5): The session closes with intellectual honesty and practical usefulness: current synthesis, remaining uncertainty, key tensions, action suggestions, and carry-forward memory. The phase structure creates a deliberate arc from divergence (phases 1–2) through engagement (phase 3) to convergence (phases 4–5), preventing premature consensus. 3.3 Interaction Grammar In DCI, a delegate does not merely “send a message.” It performs one or more typed epistemic acts—meaningful moves in collective reasoning. The grammar operates at three layers: • Layer 1—Speech Mode μ: The stance of the move: exploratory, analytical, critical, integrative, reflective, or decisional. • Layer 2—Interaction Act α: The core move from a vocabulary of 14 typed acts (Table 1). • Layer 3—Intent ι : The specific purpose: test assumption, open option, resolve ambiguity, connect ideas, support convergence. Table 1: The 14 core epistemic acts in DCI’s interaction grammar, organized by family. # Act Family Description 1 frame Orienting Define how to view the problem 2 propose Generative Put forward a candidate idea or path 3 clarify Orienting Remove ambiguity or distinguish concepts 4 ask Critical Open a useful question 5 challenge Critical Test weakness, assumption, or consequence 6 extend Generative Build on another idea 7 reframe Orienting Shift the level or angle of understanding 8 bridge Integrative Connect two ideas or positions 9 synthesize Integrative Summarize where the group seems to be 10 ground Epistemic Anchor a point in evidence or constraint 11 update Epistemic Revise one’s own position 12 recommend Decisional Suggest a next direction or action 13 spawn Generative Propose a sub-session for a sub-problem 14 recall Integrative Incorporate a sub-session’s result A complete interaction move is a triple m=(μ,α,ι)m=(μ,α, ) targeting either the problem, another delegate’s contribution, or the shared workspace. For example, m=(critical,challenge,test hidden assumption)m=(critical, challenge, hidden assumption) targeting m31m_31 represents a Challenger pressure-testing a specific proposal. The grammar distinguishes soft moves (exploratory, tentative—appropriate early in deliberation) from hard moves (decisive, committal—appropriate later), creating natural progression from open exploration to convergent decision-making. Certain acts naturally invite specific responses, forming a response grammar: a challenge invites defend, refine, update, or concede; a synthesize invites affirm, sharpen, surface omission, or recommend. 3.3.1 Design Rationale for the 14 Acts The 14 acts are organized into six families, each serving a distinct cognitive function in collective reasoning. The design principle is coverage: removing any family creates a specific failure mode in the deliberation process. • Orienting acts (frame, clarify, reframe) establish and refine the problem definition. Without them, the group risks shallow or misdirected problem definitions—solving the wrong problem with high confidence. • Generative acts (propose, extend, spawn) increase the search breadth of the collective. Without them, the option space is limited to whatever the first speaker suggests, producing premature lock-in. • Critical acts (ask, challenge) surface hidden assumptions, weak logic, and overlooked risks. Without them, proposals pass unexamined, leading to false agreement where the group converges on an option whose weaknesses were never tested. • Integrative acts (bridge, synthesize, recall) prevent fragmentation by connecting ideas and building shared understanding. Without them, the deliberation accumulates positions without combining them, producing a list of views rather than a collective judgment. • Epistemic acts (ground, update) expose confidence levels and enable genuine revision. Without them, delegates assert positions without anchoring them in evidence or acknowledging when a challenge has changed their view, producing fake certainty. • Decisional acts (recommend) enable closure by proposing concrete next steps. Without them, deliberation can cycle indefinitely through analysis without arriving at actionable outcomes. Table 2 summarizes this structure. Table 2: Act families, their cognitive functions, and the deliberation failure that occurs when the family is absent. Act Family Cognitive Function Failure if Absent Orienting Problem framing Shallow or misdirected problem definition Generative Search breadth Limited option space, premature lock-in Critical Assumption testing False agreement, unexamined proposals Integrative Synthesis Fragmentation, list of views without judgment Epistemic Confidence & revision Fake certainty, no genuine belief update Decisional Closure Endless discussion, no actionable outcome 3.4 Shared Workspace A DCI session maintains a shared workspace W—not merely a transcript, but a structured evolving thought-space with six sections: 1. Problem View: The group’s current understanding of what the problem is. 2. Key Frames: Different valid perspectives on the problem. 3. Emerging Ideas: Candidate concepts, approaches, or hypotheses. 4. Tensions: Disagreements, ambiguities, trade-offs, and unresolved questions, captured as first-class objects. 5. Synthesis in Progress: What appears to be converging. 6. Next Actions: Possible follow-up tasks or decisions. The workspace prevents repetition, makes progress visible, and gives the session a visible center of gravity. Critically, tensions are preserved rather than resolved prematurely—the workspace explicitly tracks open disagreements, preventing the group from faking consensus. 4 DCI-CF: Convergent Flow Algorithm DCI-CF (Deliberative Collective Intelligence—Convergent Flow) is the algorithm that guarantees every DCI session terminates with a result. Its design principle is: do not force minds to agree; force the process to close fairly. 4.1 Algorithm Overview DCI-CF proceeds through eight stages (Figure 1): Figure 1: DCI-CF algorithm flow. Stages 3–6 form a loop bounded by max_rounds. If convergence fails after round exhaustion, Stage 7 provides a deterministic fallback. Every path terminates at Stage 8 with a structured decision packet. Stage 0—Session Initialization. Set the session envelope: problem statement P, delegates Δ=δ1,…,δn =\ _1,…, _n\, round budget RmaxR_ , evaluation criteria C=c1,…,cpC=\c_1,…,c_p\, maximum options KmaxK_ , finalist count M, convergence margin ϵε, and fallback rule ℱF. Stage 1—Independent Proposal Generation. Each delegate privately submits its framing, hypotheses, concerns, confidence level, and suggested evaluation criteria. Independent first input reduces dominance, conformity, and rhetorical capture. Output: raw hypothesis pool ℋH. Stage 2—Canonicalization and Clustering. The algorithm deduplicates semantically equivalent ideas, splits overloaded proposals, and groups similar hypotheses into “option families.” Output: a finite candidate set O=o1,o2,…,okO=\o_1,o_2,…,o_k\ with k≤Kmaxk≤ K_ . Stage 3—Structured Challenge and Evidence. For each option, delegates contribute support, challenge, evidence, counterexample, revision suggestion, or uncertainty note through typed epistemic acts. New hypotheses may enter only if materially distinct, plausibly superior, evidence-linked, and submitted before a cutoff round. Output: for each option, a structured record of pros, cons, assumptions, evidence, and risks. Stage 4—Revision and Option Compression. Options are revised in light of criticism: refine, merge, narrow scope, split into variants, or discard if dominated. The set is compressed by removing strictly dominated options and merging compatible variants. Output: finalist set F=f1,…,fmF=\f_1,…,f_m\ where m≤Mm≤ M. Stage 5—Multi-Criteria Scoring. Delegates evaluate finalists against the explicit criteria. Each delegate δd _d provides per-criterion scores with confidence cdc_d, evidence strength ede_d, and rationale. The aggregate score for option o is: Total(o)=∑c∈Cwc∑d∈Δ[sd,o,c⋅cd⋅ed⋅ϕd]Total(o)= _c∈ Cw_c _d∈ [s_d,o,c· c_d· e_d· _d ] (1) where wcw_c is the criterion weight, sd,o,cs_d,o,c is the raw score, and ϕd _d is a domain-fit factor reflecting the delegate’s relevance to criterion c. Stage 6—Convergence Test. The algorithm tests whether sufficient convergence has been achieved via any of: (a) score dominance—the top option exceeds the second by margin ϵε; (b) majority backing—the top option has support above a threshold; or (c) no blocking objection—all remaining objections are non-fatal. If none hold and rounds remain, return to Stage 3. If rounds are exhausted, proceed to Stage 7. Stage 7—Forced-Decision Fallback. This guarantees termination. The algorithm applies, in sequence: (1) outranking (option winning the most pairwise comparisons), (2) minimax regret, (3) robust satisficing, (4) Integrator selection from the top-2. The output includes the chosen option, why it won procedurally, what objections remain, and what would change the decision. Stage 8—Actionization and Carry-Forward. The session closes with a structured decision packet (Definition 1). 4.2 Decision Packet Definition 1 (Decision Packet). Every DCI-CF session terminates with a decision packet D, a structured record containing: 1. Selected option with rationale and supporting evidence 2. Residual objections—challenges that were raised but not resolved 3. Minority report—positions held by dissenting delegates, including their reasoning and confidence levels 4. Next actions—concrete follow-up steps derived from the selected option 5. Reopen triggers—conditions under which the decision should be reconsidered (e.g., new evidence, changed assumptions, threshold events) The decision packet is the primary output of DCI. It captures not only the decision but the epistemic state of the collective at closure: what was agreed, what was contested, what was left unresolved, and what would change the outcome. 4.3 Guarantees and Non-Guarantees The distinction between what DCI guarantees and what it does not is central to understanding its contribution. DCI guarantees: • Session termination. Every session ends in bounded time (Theorem 1). • Bounded deliberation. The number of rounds, options, and recursive sessions are all finitely bounded. • Explicit result packet. Every session produces a structured decision packet (Definition 1), even when natural convergence fails. • Preserved minority report. Dissenting positions are recorded with rationale and confidence, never silently discarded. • Reopen conditions. The decision packet specifies conditions under which the decision should be revisited. DCI does not guarantee: • Truth. Structured deliberation cannot overcome factual deficiencies in the delegate model. • Unanimity. Persistent disagreement is a valid outcome, preserved in the minority report. • Optimality. The selected option is the procedural winner, not provably the best possible answer. • Superior performance on all tasks. As our experiments confirm (Section 7), DCI’s coordination overhead can exceed its benefits for tasks where a single coherent generation suffices. DCI does not guarantee truth or consensus. It guarantees a fair and bounded process that transforms divergent perspectives into an explicit, actionable outcome with transparent provenance. 4.4 Convergence Theorem Theorem 1 (Termination). For any DCI session with finite delegate set |Δ|=n| |=n, maximum rounds RmaxR_ , maximum options KmaxK_ , and maximum recursion depth DmaxD_ , DCI-CF terminates in at most Tmax=Rmax⋅(∑d=0DmaxBd)T_ =R_ · ( _d=0^D_ B_d ) rounds, where BdB_d is the maximum number of sessions at depth d. Proof sketch. The proof relies on six hard constraints: (1) Finite rounds. Each session executes at most RmaxR_ iterations of the Stage 3–6 loop. (2) Finite option space. Stage 2 caps options at KmaxK_ ; Stage 4 compresses to at most M finalists. The option set is non-increasing across rounds. (3) Hypothesis cutoff. New hypotheses cannot enter after round Rmax−1R_ -1, ensuring the option set stabilizes. (4) Structured scoring. Stage 5 maps all positions to comparable numeric scores, making disagreement resolvable by comparison. (5) Deterministic fallback. Stage 7 provides a total ordering over finalists through a cascade of resolution methods, guaranteeing exactly one winner. (6) Bounded recursion. Recursive sessions are depth-limited (DmaxD_ , default 2) and budget-carved, with a tree-wide ceiling on total rounds (default: 50). Since every execution path either converges at Stage 6 (within RmaxR_ rounds) or terminates at Stage 7, and recursive spawns are bounded, the algorithm terminates. ∎ Remark 1. Theorem 1 guarantees termination—every DCI-CF session produces a decision in bounded time—but makes no claim about decision quality. Quality depends on delegate capabilities, domain knowledge, and archetype adherence. The convergence algorithm ensures the process closes fairly; whether the outcome is good depends on the substance of the deliberation. 4.5 Complexity Analysis Round complexity. Each round involves O(n⋅k)O(n· k) delegate-option interactions in Stage 3, O(k2)O(k^2) pairwise comparisons in Stage 4, and O(n⋅m⋅p)O(n· m· p) scoring evaluations in Stage 5. Total per-session: O(Rmax⋅n⋅k⋅p)O(R_ · n· k· p). Token complexity. Each delegate produces O(L)O(L) tokens per interaction, where L is the response length bound. Total tokens per session: O(Rmax⋅n⋅k⋅L)O(R_ · n· k· L). With default parameters (Rmax=2R_ =2, n=4n=4, k=5k=5, L≈2000L≈ 2000), this yields approximately 80K tokens per session—though observed mean usage (238K tokens) exceeds this estimate due to multi-stage prompts, workspace state, and context accumulation across rounds. Recursion overhead. With maximum depth DmaxD_ and at most B child sessions per level, worst-case total rounds are Rmax⋅(1+B)DmaxR_ ·(1+B)^D_ , bounded by the tree-wide ceiling of 50 rounds. 5 Implementation We implement DCI as a workflow on the jamjet agent runtime (JamJet, 2024), an open-source system for composing autonomous agents with built-in support for agent-to-agent communication via A2A (Google, 2024a) and tool integration via MCP (Anthropic, 2024). 5.1 Architecture The implementation maps directly onto jamjet’s workflow model: • Delegates as agents. Each archetype is a jamjet agent with a differentiated system prompt encoding its reasoning orientation and behavioral guidelines. • DCI-CF as workflow graph. The eight stages are expressed as a jamjet workflow graph with conditional edges (Stage 6 loops back to Stage 3 or advances to Stage 7/8). Session state is maintained as workflow state. • Workspace as structured state. The shared workspace is a structured JSON document within the workflow state, updated through typed epistemic acts. Each act modifies a specific workspace section rather than appending to a flat transcript. • Grammar enforcement. Delegate outputs are parsed against the interaction move schema. Invalid moves are rejected and the delegate is re-prompted. 5.2 Model Configuration All delegate agents use Gemini 2.5 Flash (Google, 2024b) accessed through the Google Generative Language API via its OpenAI-compatible endpoint, with reasoning_effort=“none” to disable thinking tokens, max_tokens=16384, and temperature 0.7. A minimum 4-second delay between API requests enforces rate limiting. For LLM-as-judge evaluation, we use Gemini 3 Flash Preview (Google, 2024b) (temperature 0.2) with structured rubrics to enable cost-effective automated assessment with a more capable model than the delegates themselves. Delegate system prompts encode both the archetype orientation and grammar constraints. Each prompt specifies the delegate’s cognitive focus, preferred act types, known limitations, and instructions for producing well-formed interaction moves with the three-layer structure (mode, act, intent). All conditions achieved 100% task completion rate. 5.3 Worked Example To illustrate how DCI produces structured deliberation rather than unstructured chat, Figure 2 traces a condensed session on an architectural design task. Problem. Design a high-throughput event processing pipeline handling 100K events/sec with exactly-once delivery semantics and a complete audit trail. The team has 4 engineers and a 3-month deadline. Phase 1—Independent First Thought (4 delegates, 8 moves). Selected moves: Actor Act Summary Framer clarify Does “exactly-once” mean delivery to ingestion, or end-to-end including all downstream side effects? This distinction drives the entire architecture. Explorer propose Treat the event stream as an append-only immutable database (blockchain analogy): each batch cryptographically linked, providing inherent audit trail and unique event IDs for exactly-once. Challenger challenge Challenges the implicit assumption that exactly-once delivery and complete audit trail are achievable at 100K evt/s within 3 months with 4 engineers. “Exactly-once is notoriously difficult.” [hard move] Integrator frame Frames the core tension: ambitious correctness requirements vs. severe resource/time constraints. Should we determine if “at-least-once with idempotent processing” is a more realistic goal? [hard move] Phase 2—Mutual Engagement (4 moves). Selected moves: Framer reframe Distinguishes “exactly-once delivery” (unachievable in distributed systems) from “exactly-once processing” (idempotent consumers). Reframing to the latter simplifies the problem. [hard move] Challenger challenge Challenges the immutable-database option: building a blockchain-like ledger for 100K evt/s is a massive undertaking—risks overruns and brittleness with a 4-person team. Tensions surfaced (tracked as first-class workspace objects): • Correctness vs. feasibility: exactly-once at 100K evt/s vs. 3-month deadline / 4 engineers. • Elegance vs. risk: immutable-ledger approach is conceptually clean but may be impractical. Convergence. Score dominance after round 1. Winning option: redefine delivery guarantees to “exactly-once processing” via Kafka + idempotent consumers (at-least-once delivery, application-level deduplication). Immutable-database option retained in minority report. Decision packet (abbreviated): • Decision: Shift to exactly-once processing with idempotent consumers on a managed Kafka backbone. • Minority report: Immutable-database option remains conceptually superior for auditability but impractical within constraints. • Reopen conditions: (1) requirement explicitly demands true exactly-once delivery; (2) throughput requirement increases 10×; (3) timeline or team size reduced further. Session: 12 moves, 2 rounds, 26.5K tokens, convergence via score dominance (no forced fallback). Figure 2: Condensed DCI session on an architectural design task. Four archetypes exchange typed epistemic acts across two phases, surfacing tensions that are preserved as first-class objects. The session converges on a pragmatic reframing while retaining the minority position and specifying reopen conditions—artifacts absent from single-agent or debate outputs. 6 Experimental Setup We evaluate DCI against four baselines across seven domains (45 tasks), with ablation conditions to probe component contributions. Rather than framing the evaluation as a broad comparison, we organize it around four specific hypotheses that the data can support or refute. 6.1 Hypotheses • H1: Structured deliberation improves over unstructured multi-agent debate. If the structure of multi-agent interaction matters, DCI should outperform free-form debate among the same number of agents on the same tasks. • H2: DCI especially helps on tasks requiring perspective integration and multi-stakeholder analysis. If deliberative structure adds value specifically through its challenge mechanisms, tension preservation, and multi-perspective reasoning, DCI’s advantage should be largest on hidden-profile, risk-heavy, and policy tasks—and smallest (or negative) on routine tasks. • H3: DCI incurs substantial coordination overhead and is not efficient for routine tasks. Structured deliberation requires multi-stage, multi-agent interaction. If this overhead is real, DCI should consume substantially more tokens than simpler approaches, and single-agent generation should achieve competitive quality at a fraction of the cost. • H4: Different DCI components matter differently across task classes. If the framework’s components (archetypes, typed grammar, convergence algorithm) serve distinct functions, removing each should produce different effects, potentially varying by task type. 6.2 Evaluation Domains We evaluate on 45 tasks across seven domains, including a negative control, to test task-dependence: Domain 1: Software Architecture (10 tasks). Complex design tasks with multiple valid approaches, hidden tradeoffs, and no single correct answer. Tasks span distributed systems, data modeling, API design, and infrastructure choices. Domain 2: Policy Analysis (10 tasks). Inherently multi-perspective problems requiring structured reasoning about value tradeoffs. Tasks span technology policy, organizational governance, and societal impact assessment. Domain 3: Hidden-Profile (5 tasks). Tasks where the correct answer requires combining partial information distributed across perspectives—no single viewpoint has the full picture. These test whether deliberative structure helps integrate fragmented knowledge. Domain 4: Late-Evidence (5 tasks). Tasks requiring revision of an initial assessment after new information arrives. These test DCI’s bounded-openness mechanism for admitting new evidence under controlled rules. Domain 5: Risk Analysis (5 tasks). Tasks centered on comprehensive risk identification, where the primary evaluation dimension is surfacing hidden assumptions, second-order effects, and failure modes. Domain 6: Disagreement-Heavy (5 tasks). Tasks with genuinely competing valid positions where reasonable experts would disagree. These test whether DCI’s tension preservation and minority report mechanisms add value. Domain 7: Routine (5 tasks, negative control). Straightforward tasks with clear correct approaches that should not benefit from multi-agent deliberation. This domain tests H3’s prediction that DCI’s overhead is not justified for simple decisions. 6.3 Baselines • B1: Single Agent. One LLM (same model as DCI delegates) given the full problem with careful-reasoning instructions and structured output format. • B2: Unstructured Debate. Four LLMs communicating via free-form messages with no grammar, no phases, no workspace, and no DCI-CF. • B3: Simple Voting. Four LLMs independently produce answers; an LLM judge selects the best. • B4: Self-Consistency (Wang et al., 2023). Single LLM generates multiple reasoning paths; best answer selected. 6.4 Ablation Conditions • A1: No Archetypes. All four delegates are generic reasoning agents with no archetype specialization. Same DCI-CF flow. • A2: No Typed Grammar. Delegates communicate in free-form text but still follow DCI-CF’s staged process. • A3: No DCI-CF. Delegates have archetypes and grammar but deliberate freely for a fixed number of rounds with no structured convergence. Final answer extracted by an LLM summarizer. • A4: No Workspace. Delegates have archetypes, grammar, and DCI-CF but no shared workspace. They see the full transcript instead. 6.5 Metrics Primary metrics. Decision quality: LLM-as-judge scoring on a 1–10 rubric covering completeness, reasoning quality, risk identification, tradeoff articulation, and actionability. Reasoning depth: count of identified tradeoffs, risks, and assumptions. Perspective coverage: count of distinct viewpoints surfaced. Secondary metrics. Total tokens consumed, wall-clock time, rounds to convergence, convergence method (natural vs. forced fallback), and quality-per-token ratio. 6.6 Evaluation Protocol All system outputs are evaluated blind: the LLM judge does not know which system produced which output. For each task, all systems’ outputs are collected and evaluated with the same rubric. We use Gemini 3 Flash Preview (Google, 2024b) as the LLM judge with structured evaluation prompts that score each dimension independently before producing an aggregate score. 6.7 Statistical Methodology We use paired comparisons (each task evaluated by all systems), bootstrap 95% confidence intervals (10,000 resamples) for all reported metrics, Wilcoxon signed-rank tests for significance, and Holm-Šidák correction for multiple comparisons. 7 Results We present results organized by hypothesis, using the same data and tables but framing each finding as evidence for or against a specific claim. 7.1 H1: Structured Deliberation Improves Over Unstructured Debate Table 3 presents the main comparison across all seven evaluation domains. The core test of H1 is the comparison between DCI and unstructured debate (B2), which isolates the effect of deliberative structure while holding the number of agents constant. Table 3: Main results across all seven evaluation domains (N=N= number of task evaluations per condition). Overall quality, risk identification, reasoning depth, and actionability scored 1–10 by LLM-as-judge (Gemini 3 Flash Preview). Bold indicates best in column. System N Overall Risk ID Depth Actionability DCI (Ours) 45 8.24 8.84 8.62 8.96 B1: Single Agent 45 8.84 9.42 9.00 9.00 B3: Simple Voting 45 8.78 8.66 8.67 9.44 B4: Self-Consistency 45 8.65 8.37 8.53 9.32 B2: Unstructured Debate 45 7.75 8.39 7.72 8.76 Evidence for H1. On the full task set (n=45n=45), DCI scores 0.49 points higher than unstructured debate on overall quality (8.24 vs. 7.75). However, bootstrap 95% confidence intervals (10,000 resamples) show this overall difference is not statistically significant: Δ=+0.49 =+0.49, 95% CI [−0.10,+1.12][-0.10,+1.12]. The reason is informative: routine tasks (Domain 7) drag down DCI’s average substantially (5.39 on routine vs. 8.58 for debate), diluting the signal from domains where deliberative structure genuinely helps. On non-routine tasks (n=40n=40), the picture changes: DCI scores +0.95+0.95 over debate, 95% CI [+0.41,+1.54][+0.41,+1.54]—statistically significant. This is the most direct test of whether deliberative structure matters when the task warrants it: the same number of agents, the same model, the same tasks—the only difference is the presence of typed acts, phased sessions, a shared workspace, and a convergence algorithm. Context. H1 is supported on non-routine tasks but not on the full task set, confirming that deliberative structure helps selectively. Single-agent generation now significantly outperforms DCI overall (Δ=−0.60 =-0.60, 95% CI [−1.06,−0.15][-1.06,-0.15]). Simple voting (8.78) and self-consistency (8.65) also score higher. The data show that DCI’s value is task-dependent: it improves over debate on perspective-heavy and process-sensitive tasks, but its failure on routine tasks confirms that structured deliberation is not a general-purpose improvement. DCI’s value must be assessed domain-by-domain, which we examine next. 7.2 H2: DCI Especially Helps on Perspective-Integration and Process-Sensitive Tasks Table 4 breaks results by domain across all seven evaluation categories. We examine whether DCI’s advantage concentrates on the task types where deliberative structure should matter most. Table 4: Overall quality scores by domain. Bold indicates best in each column. n = tasks per domain. System Hidden-Prof. Late-Evid. Risk Disagree. Policy Arch. Routine n=5 n=5 n=5 n=5 n=10 n=10 n=5 DCI (Ours) 9.56 9.24 8.48 8.15 8.55 8.13 5.39 Single Agent 9.25 9.60 8.85 8.87 8.82 8.73 7.88 Voting 9.30 9.26 8.03 8.68 8.26 9.19 8.86 Self-Consistency 9.08 8.80 8.77 7.83 8.97 8.22 8.96 Unstr. Debate 9.03 8.45 7.83 8.24 8.03 5.78 8.58 Evidence for H2: hidden-profile tasks. DCI’s strongest domain is hidden-profile tasks (9.56)—the highest score of any system on any domain. Hidden-profile tasks require integrating partial information that no single perspective possesses, and this is exactly where differentiated delegates and structured engagement should help. DCI significantly outperforms single-agent generation on hidden-profile tasks (Δ=+0.31 =+0.31, 95% CI [+0.12,+0.49][+0.12,+0.49])—the only domain where DCI beats the single agent. DCI also significantly outperforms self-consistency (Δ=+0.48 =+0.48) and debate (Δ=+0.53 =+0.53) on this domain. Evidence for H2: process-sensitive tasks. On process-sensitive tasks (architecture + policy, n=20n=20), DCI–Debate is +1.44+1.44, 95% CI [+0.57,+2.43][+0.57,+2.43]—statistically significant. On the standard architecture domain, debate degrades severely (5.78) while DCI maintains 8.13, a gap of +2.36+2.36. Evidence for H2: routine negative control. DCI scores 5.39 on routine tasks—significantly lower than every baseline (DCI–Debate: −3.19-3.19, CI [−4.25,−2.11][-4.25,-2.11]). This negative control confirms strong task-dependence: DCI’s deliberative machinery actively harms output quality on straightforward tasks, consistent with H2’s prediction that DCI’s value is domain-specific. Process metrics. Table 5 shows that DCI’s structural differentiation extends beyond quality scores. DCI produces decision artifacts that no baseline provides. Table 5: Process metrics across systems. Decision packet completeness, minority report presence, and reopen conditions presence are percentages. Explicit assumptions and risk/objection counts are means per task. Metric DCI SA Debate Voting SC Decision packet 100% 1% 8% 16% 0% Minority report 98% 0% 0% 0% 0% Reopen conditions 100% 0% 0% 0% 0% Explicit assumptions 3.6 3.3 0.2 0.0 0.0 Risk count 4.3 10.5 3.5 4.9 3.4 Objection count 3.8 7.3 1.1 2.4 2.2 7.3 H3: Substantial Coordination Overhead Table 6 presents efficiency metrics. The token costs test whether DCI’s deliberative structure comes at a substantial cost. Table 6: Efficiency metrics across systems. Mean tokens per task across all agents and rounds. System Mean Tokens Quality Quality/kToken B1: Single Agent 3,809 8.84 2.320 B2: Unstructured Debate 9,458 7.75 0.819 B4: Self-Consistency 21,249 8.65 0.407 B3: Simple Voting 31,987 8.78 0.274 DCI (Ours) 237,565 8.24 0.035 Evidence for H3. DCI consumes approximately 62×62× the tokens of a single agent for an overall quality score that is 0.60 points lower—a gap that is now statistically significant (Δ=−0.60 =-0.60, 95% CI [−1.06,−0.15][-1.06,-0.15]). In quality-per-token terms, single-agent generation dominates all conditions (2.320 quality/kToken vs. 0.035 for DCI). Even compared to unstructured debate, DCI uses ∼25× 25× more tokens for a 0.49-point quality improvement that does not reach significance on the full task set. H3 is strongly supported. DCI’s routine-task performance (5.39) provides the most direct evidence for H3: on straightforward tasks, DCI’s deliberative machinery actively degrades output quality. The multi-stage pipeline introduces coordination overhead, error propagation, and over-structuring on tasks where a single coherent generation suffices. DCI’s convergence process required a mean of 1.5 rounds with a 51% fallback rate, indicating that natural convergence is achieved roughly half the time. This cost is not a side effect—it is a central finding that shapes DCI’s applicability. DCI is not a general replacement for simpler approaches. It is designed for tasks where process quality matters enough to justify the cost: decisions requiring explicit risk surfacing, preserved dissent, stakeholder accountability, and structured closure under disagreement. When the cost is justified. Three properties of DCI’s output are absent from cheaper alternatives: 1. Decision packets. Every session produces a structured artifact: the selected option, residual objections, a minority report, and reopen conditions. DCI achieves 100% decision packet completeness and 98% minority report presence; no simpler baseline exceeds 16% on either metric (Table 5). 2. Hidden-profile integration. On tasks requiring combination of partial perspectives, DCI achieves 9.56—the highest score of any system on any domain—and significantly outperforms the single agent (+0.31+0.31, CI [+0.12,+0.49][+0.12,+0.49]). 3. Policy and architecture performance. On process-sensitive tasks (n=20n=20), DCI significantly outperforms debate (+1.44+1.44, CI [+0.57,+2.43][+0.57,+2.43]) while providing dissent artifacts that single-agent output cannot. The right question is not “is DCI efficient?” (it is not) but “does the task require accountable, auditable deliberation?” When it does, the structured decision packet and preserved minority positions provide value not captured by scalar quality scores. 7.4 H4: Component Contributions Table 7 presents results from three of four planned ablation conditions (A1–A3) run on 25 tasks each; A4 (No Workspace) was not completed within the experimental budget. We note upfront that while the sample size has increased from our initial experiments, the high variance in DCI’s performance continues to limit the strength of conclusions. Table 7: Ablation results (n=25n=25 tasks each). Overall quality scored 1–10. Full DCI reference is the overall mean (n=45n=45). Condition Overall Δ vs. Full Full DCI 8.24 — A1: No Archetypes 8.61 ± 0.68 +0.37 A2: No Typed Grammar 8.32 ± 1.47 +0.08 A3: No DCI-CF 8.33 ± 0.91 +0.09 Evidence regarding H4. As with our initial experiments, all three ablation conditions scored at or above the full framework. Removing archetypes (+0.37+0.37), typed grammar (+0.08+0.08), or the convergence algorithm (+0.09+0.09) each produced equal or higher mean scores. Bootstrap confidence intervals confirm that none of these differences are statistically significant. The No Typed Grammar condition shows the highest variance (±1.47± 1.47), suggesting that the typed grammar acts as a variance reducer even when it does not improve the mean—removing it yields occasional high and low outliers. H4 is not supported—the data do not reliably separate individual component contributions. We identify three non-exclusive explanations: 1. Moderate sample, high variance. Even with n=25n=25, the wide confidence intervals (especially for No Typed Grammar) confirm that reliable component attribution requires larger evaluation sets or lower-variance tasks. 2. Coordination overhead. The full pipeline involves multiple stages of structured interaction, each adding opportunities for error propagation. When the model occasionally produces low-quality structured outputs, the multi-stage pipeline amplifies rather than corrects these failures. 3. Over-constraint. The typed grammar and convergence algorithm impose structure that may over-constrain generation for some tasks. Generic agents communicating freely may produce more coherent outputs when the underlying model is already capable. We note a suggestive pattern: the No Typed Grammar condition’s high variance (±1.47± 1.47 vs. ±0.68± 0.68 for No Archetypes) suggests that the grammar provides consistency even when it does not improve average quality. Similarly, DCI’s hidden-profile dominance (9.56, beating all baselines) is consistent with the archetype differentiation providing genuine epistemic diversity on perspective-integration tasks. However, these observations are not isolated by the ablation design. Confirming any component-level attribution requires targeted experiments with larger samples. 7.5 Reliability All conditions achieved 100% task completion rate after an initial engineering fix (setting reasoning_effort=“none” to disable thinking tokens that caused parsing failures). This is notable for DCI, which involves the most complex multi-stage pipeline: across 45 tasks, every DCI-CF session terminated with a structured decision packet, confirming Theorem 1 in practice. The convergence process required a mean of 1.5 rounds with a 51% fallback rate—indicating that natural convergence is achieved roughly half the time, with the Stage 7 forced-decision mechanism providing reliable closure for the remainder. 7.6 Qualitative Observations Inspection of session logs reveals patterns that complement the quantitative results: • Hidden-profile integration. On hidden-profile tasks, delegates consistently contributed distinct partial perspectives that were integrated during the synthesis phase—exactly the mechanism DCI is designed to support. The Framer’s problem reframing and Integrator’s synthesis were visibly productive on these tasks. • Coordination overhead in output coherence. DCI’s multi-stage pipeline occasionally produced outputs where the final synthesis was less coherent than a single-agent generation. Aggregating multiple delegate perspectives sometimes introduced redundancy or unresolved tension in the final output—a pattern especially pronounced on routine tasks. • Policy domain strength. On policy tasks, delegates naturally surfaced competing stakeholder interests, equity considerations, and implementation barriers that single agents addressed more superficially. • Routine task degradation. On routine tasks, the deliberative machinery introduced unnecessary complexity: delegates generated artificial tensions on straightforward problems, and the convergence process produced over-structured outputs for questions with clear answers. • Outlier sensitivity. Several low-scoring runs involved cascade failures where an early-stage malformed output propagated quality degradation through subsequent stages. 7.7 Cross-Judge Validation To verify that our evaluation is not an artifact of a single judge, we scored 20 representative outputs (4 per condition) using three independent LLM judges: Gemini 3 Flash Preview (our primary judge), GPT-4o (OpenAI), and Claude Sonnet 4 (Anthropic). Table 8 reports the per-condition mean overall quality for each judge. Table 8: Cross-judge validation: mean overall quality (1–10) for 20 representative outputs scored by three independent LLM judges (4 outputs per condition). Condition Gemini GPT-4o Claude Voting 9.24 8.73 8.66 Single Agent 9.12 8.73 8.50 DCI 8.57 8.27 8.12 Self-Consistency 8.50 8.75 7.62 Unstructured Debate 6.97 8.06 7.54 All three judges agree on the essential finding: voting and single-agent baselines score highest, DCI and self-consistency occupy the middle tier, and unstructured debate ranks last. Critically, the DCI >> debate ordering—the central test of H1—is confirmed by all three judges, ruling out single-judge bias as an explanation for our main result. Inter-judge agreement is substantial: Claude Sonnet 4 correlates most strongly with Gemini (Pearson r=0.817r=0.817, MAD =0.63=0.63), while GPT-4o shows moderate correlation (r=0.592r=0.592, MAD =0.55=0.55). Claude is the strictest judge (mean 8.098.09) and Gemini the most generous (8.488.48), consistent with known calibration differences across model families, but relative condition rankings remain stable across all three. 8 Analysis and Discussion 8.1 When Does Structured Deliberation Help? DCI is not a general-purpose reasoning default. At ∼62× 62× the token cost of a single agent for lower overall quality scores, it cannot be justified on efficiency grounds. Its value is narrow, specific, and conditional—tied to tasks where the process artifacts matter as much as the final answer: • When the decision requires accountable process. DCI’s decision packet—selected option, residual objections, minority report, reopen conditions—provides an audit trail absent from all simpler approaches. DCI achieves 100% decision packet completeness and 98% minority report presence, compared to ≤ 16% for all baselines. For decisions requiring stakeholder accountability or regulatory justification, this structured output is the primary differentiator. • When the task requires integrating partial perspectives. On hidden-profile tasks, DCI achieves 9.56—the highest score of any system on any domain—and is the only condition that significantly outperforms single-agent generation (+0.31+0.31, CI [+0.12,+0.49][+0.12,+0.49]). Tasks where the correct answer requires combining fragmented information are DCI’s strongest use case. • When tasks involve competing perspectives. On policy and architecture tasks requiring multi-stakeholder reasoning, DCI significantly outperforms debate (+1.44+1.44, CI [+0.57,+2.43][+0.57,+2.43]). The differentiated delegates and tension preservation mechanisms provide genuine value on process-sensitive tasks. For routine reasoning, single-agent generation or simple voting is the better choice—DCI’s score of 5.39 on routine tasks confirms this empirically. DCI is designed for the subset of decisions where minority reports, residual objections, reopen conditions, and perspective integration provide value that justifies the cost—architectural reviews, policy deliberations, hidden-profile situations, strategic decisions with competing stakeholders, and other settings where auditability and process accountability matter. 8.2 When Structured Deliberation Fails We identify five failure modes: 1. Fundamental knowledge gaps. DCI cannot overcome factual deficiencies in the delegate model. When delegates lack domain knowledge, structured deliberation produces convergent but wrong decisions. This is the most dangerous failure mode, because the procedural structure may create unwarranted confidence in factually incorrect outcomes. 2. Overhead on routine tasks. For problems with clear correct answers, DCI adds multi-round overhead that actively degrades quality. Our routine domain (5.39) confirms this: DCI scores significantly lower than every baseline, including debate (8.58). The deliberative machinery introduces unnecessary complexity, error propagation, and over-structuring on tasks where a single coherent generation suffices. 3. Archetype role drift. In extended sessions (3+ rounds), delegates may abandon their assigned cognitive orientation. A Challenger may begin proposing rather than pressure-testing. System prompts establish initial adherence, but sustained maintenance across many turns is not guaranteed. 4. Sycophantic convergence. Despite the Challenger’s mandate, LLMs exhibit a well-documented tendency toward agreement (Liang et al., 2023). Even designated Challengers may soften objections across rounds, producing apparent consensus that reflects social compliance rather than genuine deliberative agreement. 5. Forced fallback quality. When natural convergence fails and DCI-CF invokes the Stage 7 fallback, the resulting decision reflects procedural resolution rather than genuine agreement. The minority report documents this distinction, but downstream consumers may not attend to it. 8.3 Limitations • LLM-as-judge evaluation. Our primary evaluation relies on an LLM judge (Gemini 3 Flash Preview), which may have systematic biases toward coherent single-agent outputs (Liang et al., 2023). Human evaluation would complement automated scores, particularly for risk identification. • Model homogeneity. The main experiments use a single delegate model (Gemini 2.5 Flash), limiting genuine epistemic diversity. A preliminary diverse-council experiment (2×Gemini + 2×GPT-4o, n=5) improved architectural-domain quality from 8.13 to 8.71, suggesting this limitation is remediable. • Sample size. With 45 tasks across seven domains (5–10 per domain) and ablations on 25 tasks, statistical power has improved from our initial 20-task evaluation but remains limited for per-domain conclusions, especially in domains with only 5 tasks. • Archetype adherence. LLMs may not perfectly maintain archetype behavior across extended sessions. • Task scope. Our evaluation covers seven domains but remains focused on open-ended reasoning tasks. Generalization to mathematical reasoning, creative tasks, or negotiation requires further investigation. • Scale. We evaluate with 4 delegates. Behavior with larger councils (7+) remains an open question. • Cost. DCI consumes approximately 62×62× the tokens of a single agent. The quality-per-token ratio strongly favors simpler approaches. DCI’s cost is justified only when specific quality dimensions are valued above raw efficiency. 8.4 Connection to AI Safety DCI’s emphasis on preserved dissent provides a structural mechanism against sycophantic tendencies. When a Challenger surfaces a valid objection that the majority dismisses, the minority report ensures the objection is recorded and available for review. This mirrors dissenting opinions in legal systems, which often influence future decisions despite not prevailing initially. The formal convergence guarantee also contributes to safety: a DCI session cannot run indefinitely or silently fail to produce output. Every session terminates with explicit decisions, explicit uncertainty, and explicit reopen conditions. 9 Conclusion The main contribution of DCI is not that more agents are better, but that collective reasoning benefits from explicit deliberative structure. Typed acts, visible tensions, and fair closure rules turn multi-agent interaction from parallel monologue into accountable collective judgment. We evaluated DCI across 45 tasks in seven domains—software architecture, policy analysis, hidden-profile integration, late-evidence revision, risk analysis, disagreement resolution, and routine decisions—organized around four hypotheses. Four empirical conclusions emerge: • On non-routine tasks (n=40n=40), DCI significantly improves over unstructured debate (+0.95+0.95, CI [+0.41,+1.54][+0.41,+1.54]), indicating that deliberative structure matters when the task warrants it. • DCI excels on hidden-profile tasks (9.56, the highest score of any system on any domain) and is the only condition that significantly outperforms single-agent generation on any domain—precisely on tasks requiring integration of partial perspectives. • DCI fails on routine tasks (5.39, significantly worse than all baselines), confirming that structured deliberation is task-dependent. This negative control validates that DCI’s value is genuine rather than artifactual. • DCI is expensive (∼62× 62× single-agent token cost) and produces 100% structured decision packets with 98% minority reports—process artifacts absent from all baselines—but single-agent generation significantly outperforms DCI on overall quality. The right use case for DCI is not routine reasoning but consequential decisions—especially those requiring integration of partial information, multi-stakeholder accountability, and explicit risk surfacing—where accountable process matters enough to justify the cost. Contributions. In summary, this paper: 1. Defines deliberative collective intelligence as a distinct interaction paradigm for multi-agent LLM systems, distinguishing it from ensembling, debate, orchestration, and voting. 2. Introduces DCI, a session-based framework with differentiated delegates, explicit tension tracking, a shared workspace, and structured decision packets. 3. Proposes DCI-CF, a convergent deliberation algorithm that preserves epistemic openness while guaranteeing bounded procedural closure. 4. Shows empirically that structured deliberation significantly improves over unstructured debate on non-routine tasks and excels on hidden-profile tasks requiring perspective integration—while honestly exposing that simpler baselines achieve higher overall quality at dramatically lower cost, and that DCI fails on routine tasks. Future work. Several directions could address the limitations our evaluation reveals: 1. Model-diverse councils. A preliminary experiment with heterogeneous delegates (2×Gemini + 2×GPT-4o, n=5) scored 8.71 mean quality on architecture tasks vs. 8.13 for the homogeneous council (+0.58). Genuine model diversity appears to provide real epistemic value beyond prompt-induced differentiation. 2. Iterative refinement. Adding a post-deliberation refinement stage where the synthesized output is critiqued and revised could improve output coherence without requiring full re-deliberation. 3. Adaptive deliberation depth. An adaptive system could assess task complexity and invoke structured deliberation only when expected value exceeds coordination cost, routing routine tasks to single-agent generation. 4. Larger-scale evaluation. Expanding per-domain sample sizes beyond 5–10 tasks and running ablations on all domains would enable reliable per-domain component attribution and proper statistical testing of domain-specific effects. 5. Human evaluation. Expert evaluation, particularly for risk identification and output structure, would complement LLM-as-judge scores and may reveal strengths that automated evaluation underweights. References Wu et al. (2023) Q. Wu, G. Bansal, J. Zhang, Y. Wu, B. Li, E. Zhu, L. Jiang, X. Zhang, S. Zhang, J. Liu, A. H. Awadallah, R. W. White, D. Burger, and C. Wang. AutoGen: Enabling next-gen LLM applications via multi-agent conversation. arXiv preprint arXiv:2308.08155, 2023. Hong et al. (2023) S. Hong, X. Zhuge, J. Chen, X. Zheng, Y. Cheng, C. Zhang, J. Wang, Z. Wang, S. K. S. Yau, Z. Lin, L. Zhou, C. Ran, L. Xiao, C. Wu, and J. Schmidhuber. MetaGPT: Meta programming for a multi-agent collaborative framework. arXiv preprint arXiv:2308.00352, 2023. Li et al. (2023) G. Li, H. A. A. K. Hammoud, H. Itani, D. Khizbullin, and B. Ghanem. CAMEL: Communicative agents for “mind” exploration of large language model society. In Advances in Neural Information Processing Systems, 2023. CrewAI (2024) CrewAI. CrewAI: Framework for orchestrating role-playing autonomous AI agents. https://github.com/crewAIInc/crewAI, 2024. Du et al. (2023) Y. Du, S. Li, A. Torralba, J. B. Tenenbaum, and I. Mordatch. Improving factuality and reasoning in language models through multiagent debate. arXiv preprint arXiv:2305.14325, 2023. Liang et al. (2023) T. Liang, Z. He, W. Jiao, X. Wang, Y. Wang, R. Wang, Y. Yang, Z. Tu, and S. Shi. Encouraging divergent thinking in large language models through multi-agent debate. arXiv preprint arXiv:2305.19118, 2023. Chen et al. (2023) L. Chen, M. Zaharia, and J. Zou. FrugalGPT: How to use large language models while reducing cost and improving performance. arXiv preprint arXiv:2305.05176, 2023. Ong et al. (2024) I. Ong, A. Almahairi, V. Wu, W.-L. Chiang, T. Wu, J. E. Gonzalez, M. W. Kadous, and I. Stoica. RouterLLM: Learning to route LLMs with preference data. arXiv preprint arXiv:2406.12194, 2024. Wang et al. (2023) X. Wang, J. Wei, D. Schuurmans, Q. Le, E. Chi, S. Narang, A. Chowdhery, and D. Zhou. Self-consistency improves chain of thought reasoning in language models. In Proc. ICLR, 2023. Irving et al. (2018) G. Irving, P. Christiano, and D. Amodei. AI safety via debate. arXiv preprint arXiv:1805.00899, 2018. Habermas (1984) J. Habermas. The Theory of Communicative Action, Volume 1: Reason and the Rationalization of Society. Beacon Press, 1984. Fishkin (2018) J. S. Fishkin. Democracy When the People Are Thinking: Revitalizing Our Politics Through Public Deliberation. Oxford University Press, 2018. Austin (1962) J. L. Austin. How to Do Things with Words. Oxford University Press, 1962. Searle (1969) J. R. Searle. Speech Acts: An Essay in the Philosophy of Language. Cambridge University Press, 1969. Google (2024a) Google. Agent2Agent (A2A) protocol. https://github.com/google/A2A, 2024. Anthropic (2024) Anthropic. Model Context Protocol (MCP). https://modelcontextprotocol.io, 2024. JamJet (2024) JamJet. JamJet: Agent runtime for composable autonomous agents. https://github.com/jamjet-labs/jamjet, 2024. Google (2024b) Google. Gemini: A family of highly capable multimodal models. https://deepmind.google/technologies/gemini/, 2024. Arrow (1951) K. J. Arrow. Social Choice and Individual Values. John Wiley & Sons, 1951. Appendix A DCI-CF Pseudocode Listing 1: DCI-CF convergent flow algorithm. ⬇ def dci_convergent_flow(problem, delegates, criteria, max_rounds=2, max_options=5, finalist_count=3, margin=0.15, depth=0, max_depth=2): # Stage 0: Session initialization workspace = init_workspace(problem, delegates, criteria) session = create_session(problem, delegates, depth, max_depth) # Stage 1: Independent proposal generation proposals = collect_independent_proposals(delegates, problem) # Stage 2: Canonicalization and clustering options = canonicalize_and_cluster(proposals, max_options) for round_idx in range(1, max_rounds + 1): # Stage 3: Structured challenge and evidence records = [] for option in options: records.extend( collect_challenge_evidence(delegates, option, round_idx) ) # Admit new hypotheses before cutoff if round_idx < max_rounds: new_options = admit_new_hypotheses(records) options = merge_options(options, new_options) # Stage 4: Revision and option compression options = revise_and_compress(options, records, max_options) # Stage 5: Multi-criteria scoring finalists = select_finalists(options, finalist_count) score_table = score_options(delegates, finalists, criteria) ranking = aggregate_scores(score_table) # Stage 6: Convergence test if has_dominant_winner(ranking, margin): return finalize_decision(ranking[0], finalists, records) if no_blocking_objection(finalists, records): return finalize_decision(ranking[0], finalists, records) # Stage 7: Forced-decision fallback winner = fallback_select(finalists, "outranking_then_minimax") return finalize_decision(winner, finalists, records, forced=True) def finalize_decision(winner, finalists, records, forced=False): # Stage 8: Actionization and carry-forward return "decision": winner, "rationale": build_rationale(winner), "minority_report": build_minority_report(finalists, records), "action_plan": derive_actions(winner), "assumptions": extract_assumptions(winner, records), "risks": extract_risks(winner, records), "reopen_conditions": derive_reopen_conditions(records), "confidence": compute_confidence(winner), "forced_fallback": forced Appendix B Convergence Proof Theorem 2 (Termination of DCI-CF). For any DCI session with parameters (n,Rmax,Kmax,M,Dmax)(n,R_ ,K_ ,M,D_ ), the DCI-CF algorithm terminates in finite time. Proof. We show that every execution path through DCI-CF reaches Stage 8 in bounded steps. Claim 1: The Stage 3–6 loop terminates. The loop counter r increments from 1 to RmaxR_ on each iteration. At r=Rmaxr=R_ , if neither convergence condition (score dominance or no blocking objection) holds, the algorithm exits the loop and proceeds to Stage 7. Therefore the loop executes at most RmaxR_ iterations. Claim 2: The option set is bounded and non-increasing after cutoff. Stage 2 initializes |O|≤Kmax|O|≤ K_ . Stage 4 can only reduce or maintain |O||O| (via merging, discarding dominated options). New hypotheses are admitted only before round Rmax−1R_ -1. After the cutoff, |O||O| is non-increasing. Stage 4 selects at most M finalists, so |F|≤M|F|≤ M. Claim 3: Stage 7 produces exactly one winner. The fallback cascade—outranking, minimax regret, robust satisficing, Integrator selection—is a total ordering over finalists. At each level, if no unique winner emerges, the next level is applied. Integrator selection from the top-2 is guaranteed to produce exactly one winner. Claim 4: Recursive sessions are bounded. Each recursive spawn decrements the remaining depth by 1 and carves budget from the parent’s remaining rounds. At depth=Dmaxdepth=D_ , no further spawns are permitted. The tree-wide round ceiling (default: 50) provides an additional hard bound. Therefore the total number of sessions in the recursion tree is at most (1+Bmax)Dmax(1+B_ )^D_ where BmaxB_ is the maximum children per level. Combining Claims 1–4: the main loop terminates in RmaxR_ rounds, each round involves bounded computation over O(Kmax)O(K_ ) options and n delegates, the fallback is deterministic, and recursion is depth-bounded. Therefore DCI-CF terminates in finite time with a structured decision packet. ∎ Appendix C Interaction Move Schema Each DCI interaction move conforms to the following schema: Listing 2: Interaction move structure. ⬇ "move_id": "mv-042", "session_id": "DCI-S-001", "round": 2, "phase": "mutual_engagement", "actor": "Challenger", "mode": "critical", // Layer 1: speech mode "act": "challenge", // Layer 2: interaction act "intent": "test␣assumption", // Layer 3: specific purpose "target": "contribution:mv-031", "content": "This␣proposal␣assumes␣delegates␣can ␣self-regulate␣without␣coordination ␣pressure.␣What␣prevents␣divergence?", "confidence": 0.78, "move_force": "hard", "meta_level": false Valid act types: frame, propose, clarify, ask, challenge, extend, reframe, bridge, synthesize, ground, update, recommend, spawn, recall. Valid speech modes: exploratory, analytical, critical, integrative, reflective, decisional. Appendix D Full Experimental Configuration Table 9 lists the complete parameter configuration used in all experiments. Table 9: Experimental configuration parameters. Parameter Description Value DCI-CF Parameters max_rounds Maximum deliberation rounds 2 max_options Maximum candidate options 5 finalist_count Finalists for scoring 3 convergence_margin Score dominance threshold ϵε 0.15 fallback_rule Forced-decision method outranking max_depth Recursive session depth limit 2 tree_ceiling Total rounds across session tree 50 Model Configuration Delegate model Delegate LLM Gemini 2.5 Flash API endpoint Google GenAI (OpenAI-compat.) generativelanguage.googleapis.com Judge model LLM-as-judge Gemini 3 Flash Preview reasoning_effort Thinking token control “none” (disabled) max_tokens Response length bound 16384 Rate limiting Minimum inter-request delay 4 seconds Temperature (delegates) Sampling temperature 0.7 Temperature (judge) Sampling temperature 0.2 Evaluation Tasks per domain Evaluation set size 5–10 Quality rubric scale LLM-as-judge scoring 1–10 Significance test Statistical test Wilcoxon Multiple comparison Correction method Holm-Šidák Confidence intervals Bootstrap method 95% CI

Instant research discovery