---
title: Multi-Agent Discussion Framework
url: https://www.emergentmind.com/topics/multi-agent-discussion-framework
type: topic
---

# Multi-Agent Discussion Framework

Searching arXiv for recent papers on multi-agent discussion frameworks and closely related systems.
A multi-agent discussion framework is a system in which multiple agents exchange messages, drafts, critiques, or structured arguments in order to solve tasks, evaluate outputs, or coordinate action. In early multi-agent systems, this problem was formulated as conversation reasoning over Agent Communication Languages (ACLs), where interaction protocols are treated as first-class objects and conversations are tracked as finite-state processes [1508.02685]. In recent large-language-model settings, the same general problem is expressed as multi-agent debate or discussion, often formalized as a tuple over agents, personas, response generators, discussion paradigms, and decision protocols, with explicit mechanisms for visibility, turn structure, and final aggregation [2509.11656]. Across both lines of work, the central concern is not merely message passing, but the representation, control, and evaluation of multi-step interaction.

## 1. Formalization and conceptual scope

A recurring formal view treats multi-agent discussion as a stateful interaction process. In ACRE, a message is modeled as
$$m = (s,\,r,\,c,\,\phi,\,p,\,x),$$
where sender, receiver, conversation identifier, protocol identifier, performative, and content are all explicit. A protocol is represented as
$$P = (\phi,\,S,\,T,\,i,\,F),$$
and a conversation as
$$C = (\phi,\,A,\,s_c,\,c,\,B,\,\psi),$$
so that protocol membership, current state, variable bindings, and status are machine-readable properties of the discussion [1508.02685].

Modern LLM-oriented frameworks use analogous abstractions with different emphases. MALLM defines a debate as
$$D = ( A , P , G , \phi , C ),$$
where $A$ is the set of agents, $P$ the persona prompts, $G$ the response-generator strategy, $\phi$ the discussion paradigm, and $C$ the decision protocol [2509.11656]. A broader evaluation-oriented formalization models a multi-agent debate framework as
$$\mathcal{M} = \langle Q, \mathcal{A}, \mathcal{S}, \delta, \Pi \rangle,$$
with $Q$ as the query space, $\mathcal{A}$ the agents, $\mathcal{S}$ the global state, $\delta$ the state-transition function, and $\Pi$ the aggregation policy [2502.08788]. In a different direction, NormAN represents discussion domains by Bayesian Networks and treats each piece of evidence as an atomic argument with likelihood ratio
$$\lambda(e) = \frac{P(e \mid \theta=true)}{P(e \mid \theta=false)},$$
so that argument exchange becomes Bayesian belief revision over a networked population [2311.09254].

These formalisms differ in substrate, but they converge on a common structural idea: a discussion is an evolving state coupled to explicit rules for admissible messages, visibility, update, and termination. This suggests that “discussion” in the technical literature is not simply free-form dialogue; it is an executable protocol for coordination, inference, or evaluation.

## 2. Core architectural patterns

The architecture of a multi-agent discussion framework is usually determined by where control resides, how memory is exposed, and how inter-agent dependencies are represented.

| Framework | Core structure | Distinctive mechanism |
|---|---|---|
| ACRE | PM, CM, AAI | FSM-tracked ACL conversations |
| MALLM | Modular debate stack | Personas, generators, paradigms, decision protocols |
| SimuPanel | Host–expert architecture | Stage machine with moderator policy |
| HiMATE | Hierarchical multi-agent system | MQM taxonomy as a tree |
| GoA | Graph-based framework | Node sampling and directed message passing |

In ACRE, the Protocol Manager is a shared, platform-independent service that loads, validates, caches and provides access to interaction-protocol definitions, the Conversation Manager is a per-agent module that watches every incoming and outgoing ACL message and maintains the state, bindings and status of each conversation, and the Agent/ACRE Interface exposes knowledge sensors, event sensors, and optional convenience actions to the host language [1508.02685]. The result is that agents see their usual beliefs, goals, and plans, augmented by conversation-level beliefs and events.

MALLM adopts a modular debate architecture consisting of a Persona Generator, Response Generator, Discussion Paradigm, Decision Protocol, and a Dataset Loader & Evaluation Pipeline [2509.11656]. SimuPanel uses a host agent
$$H = (\mathcal{S}, \mathcal{T}, \mathcal{A}, \mathcal{P}, \pi_H),$$
where $\mathcal{S}$ is the finite stage set $\{\text{Opening, Discussion, Convergence, Closing}\}$ and $\pi_H$ is the moderation policy; expert agents are defined by persona, memory, reasoning pipeline, and utterance generator [2506.16010]. HiMATE organizes agents according to the MQM hierarchy: tier-2 subtype agents detect spans and severities for specific error categories, while tier-1 agents supervise broader judgments without directly inspecting spans [2505.16281]. GoA instead treats agents as graph nodes, samples the most relevant agents using model cards, constructs directed weighted edges by peer relevance scoring, and aggregates refined responses through graph-based pooling [2604.17148].

A plausible implication is that architectural choice encodes a theory of coordination. FSM-based systems assume protocol conformance is primary; host–expert and hierarchical systems assume role asymmetry; graph-based systems assume that relevance-weighted routing is the main source of performance.

## 3. Interaction protocols, visibility, and decision rules

Discussion frameworks differ sharply in what each agent can see and how a collective answer is produced. In MALLM, the discussion paradigm $\phi$ defines which messages are visible to which agents and in what order. The “Memory” paradigm gives full visibility,
$$\mathrm{visible\_msgs}(a_i, t) = \{m_{j t'} \mid \forall j,\, t' < t\},$$
whereas the “Relay” paradigm restricts each agent to the previous agent’s last message,
$$\mathrm{visible\_msgs}(a_i, t) = \{m_{i-1, t-1}\}.$$
The same framework provides three decision-protocol families: Consensus, Voting, and Judge [2509.11656].

The later decision-protocol study based on MALLM makes this dimension explicit. Voting includes simple, ranked, cumulative, and approval variants; consensus stops when a threshold of agreements is reached; judge-based protocols designate a neutral agent that receives the final proposals and reasoning and produces a single answer [2607.05477]. The reported pattern is task-dependent: consensus protocols excel in knowledge-intensive domains, while voting and judge protocols are more effective for logic-based tasks.

Other frameworks alter information flow more aggressively. CMD organizes six agents into groups, lets intra-group agents see both viewpoints and explanations, and lets inter-group agents see only final votes before a tie-breaker or representative promotion stage [2402.18272]. DarkForest replaces discussion-heavy exchange with controlled communication: agents first generate answers independently, those answers are parsed and clustered, a belief distribution over canonical candidates is estimated, and only policy-permitted evidence from that belief state is disclosed to a coordinator [2605.25188]. GoA performs a different form of structured exchange: source-to-target message passing runs from high-relevance agents to lower-relevance agents, followed by reverse message passing from lower-relevance nodes back to the original sources before max- or mean-pooling [2604.17148].

These systems illustrate that “discussion” ranges from full shared transcripts to tightly filtered evidence exchange. This suggests that the principal design variable is not the presence of multiple agents alone, but the granularity and asymmetry of information exposure.

## 4. Coherence, diversity, and robustness mechanisms

A central difficulty in multi-agent discussion is maintaining enough coherence for convergence without collapsing diversity too early. M2CL addresses this directly by learning a context generator for each agent. For agent $i$ at round $t$,
$$I_t^i = G^i\bigl([\,P;\,I_0^i];\,X_{t-1}^{-i}\bigr),$$
and the agent response is generated from the context $[I_t^i; X_{t-1}^{-i}; P]$ [2602.02350]. The framework introduces activation-based notions of context coherence and output discrepancy, and a self-adaptive loss
$$L(\phi) = \|a(I_t;P,X_{t-1})-a(X_{t-1})\|+\alpha\|C_t-C_{t-1}\|,$$
with a dual update for $\alpha$. Early rounds loosen the constraint to encourage rapid convergence; later rounds stabilize it to preserve diversity and avoid premature consensus on “majority noise.”

HiMATE tackles hallucination and over-labeling through two strategies: self-reflection and asymmetric information multi-agent discussion. Each tier-2 subtype agent first produces an initial evaluation record, then rewrites the translation to remove the purported error, and finally verifies whether the original judgment still holds. Only low-confidence cases enter a focused debate between tier-1 and tier-2 agents, where the two tiers see the same transcript but bring different information: tier-1 knows all child definitions, whereas tier-2 knows only its own subtype definition plus the transcript [2505.16281].

DarkForest addresses robustness by minimizing exposure to raw reasoning traces. It builds an unnormalized evidence score
$$s(z)=R_{\pi_z}\sum_{i\in S_z}\alpha_i\,\rho_i\,\delta_i\,\phi(c_i),$$
normalizes it into a posterior-like distribution $P(z\mid O)$, and then applies a narrow deterministic guardrail that overrides the coordinator only when the top cluster is strongly supported [2605.25188]. AgentRevive addresses a related failure mode in graph-evolving systems by replacing hard pruning with Markov state-aware scheduling. Agents transition among “Active,” “Standby,” and “Terminated” states under a stochastic policy, and hallucination risk is estimated by KL divergence against the average message of the active set [2605.17348].

Taken together, these mechanisms show that robustness is commonly framed as a control problem over exposure, memory, and state transition. A plausible implication is that the literature increasingly treats discussion quality as a function of information geometry rather than conversational fluency alone.

## 5. Domain-specific instantiations

Multi-agent discussion frameworks are often specialized to domains in which structured disagreement, expert decomposition, or auditability is operationally valuable.

MDTeamGPT organizes medical consultation into three stages: specialist arrangement, multi-round consultation, and summary, safety review, and knowledge-base update. Its specialist set includes General Internal Medicine Doctor, General Surgeon, Pediatrician, Obstetrician and Gynecologist, Radiologist, Neurologist, Pathologist, and Pharmacist, while auxiliary agents include a Primary Care Doctor, Lead Physician, Chain-of-Thought Reviewer, and Safety & Ethics Reviewer [2503.13856]. The Lead Physician produces a four-part summary—Consistency, Conflict, Independence, and Integration—and specialists see only the last two processed summaries, a residual window of depth $2$. On MedQA and PubMedQA, the framework reports accuracies of $90.1\%$ and $83.9\%$, respectively [2503.13856].

HiMATE applies hierarchical discussion to machine translation evaluation. Its pipeline is Subtype Evaluation, Self-Reflection, Collaborative Discussion, followed by weighted MQM scoring,
$$S = - \sum_{j=1}^m w_j \cdot s_j.$$
The paper reports an average F1-score improvement of $89\%$ over the best-performing baseline in error span detection and severity assessment [2505.16281]. MATEval applies multi-agent discussion to open-ended text evaluation through Evaluator, Feedback, and Summarizer roles, with five error types—REP, LINC, DCONT, ILC, FER—and aggregate score
$$S_{\mathrm{total}}(T) = \sum_{t=1}^5 w_t\,S_t(T).$$
It reports the highest correlation with human evaluation among the compared methods and, in an Alipay story-generation audit pipeline, reduces per-item evaluation time from approximately $5$ minutes to approximately $30$ seconds [2403.19305].

PanelTR uses five “scientist” personas—Albert Einstein, Isaac Newton, Marie Curie, Alan Turing, and Nikola Tesla—for zero-shot table reasoning through Individual Investigation, Self-Review, and Collaborative Peer-Review [2508.06110]. On TAT-QA, it reports $67.2$ EM and $74.8$ F1, compared with $58.0$ EM and $66.5$ F1 for deepseek-v3; on SEM-TAB-FACTS, it reports Dev $87.1$ and Test $90.8$ [2508.06110]. SimuPanel applies host-moderated expert discussion to academic panel simulation in an immersive 3D environment, while XAgents uses a multipolar task processing graph and IF–THEN rules for uncertain knowledge-typed and logic-typed question answering [2506.16010][2509.10054].

These examples indicate that domain adaptation usually requires one or more of the following: specialized personas, structured summaries, domain-specific scoring rules, restricted memory windows, or explicit safety and verification roles.

## 6. Evaluation findings, limitations, and active debate

The empirical status of multi-agent discussion is contested. A systematic evaluation of five representative multi-agent debate methods across nine benchmarks and four foundational models reports that multi-agent debate often fails to outperform simple single-agent baselines such as Chain-of-Thought and Self-Consistency, even when consuming significantly more inference-time computation [2502.08788]. On aggregated average accuracy across nine benchmarks, the reported values are $72.5$ for CoT, $73.9$ for SC, and between $64.9$ and $71.2$ for the evaluated MAD methods, with all MAD methods using more tokens than CoT on average [2502.08788].

A separate reevaluation reaches a related conclusion. With high-quality demonstrations, a single-agent LLM with a strong prompt reaches or matches multi-agent performance on ECQA, GSM8K, and FOLIO-wiki; the reported average accuracy for a single agent rises from $67.41\%$ in Direct mode to $75.63\%$ in Demo mode, while CMD rises from $70.75\%$ to $74.46\%$ [2402.18272]. The same study states that multi-agent discussion performs better than a single agent only when there is no demonstration in the prompt.

At the same time, several papers identify conditions under which multi-agent discussion helps. The heterogeneity study argues that model heterogeneity is a universal antidote: when agents are instantiated by different foundation models, SoM-Heter reaches $76.7\%$ versus $74.3\%$ for SoM-Average, and EoT-Heter reaches $75.7\%$ versus $73.4\%$ for EoT-Average [2502.08788]. The MALLM decision-protocol study reports that increasing response diversity through independent solution generation improves decision quality, and that changes in information access during the decision process have minimal impact [2607.05477]. DarkForest argues for “less talk” by reporting up to $30.7\%$ improvement on benchmark metrics over the strongest baseline and up to $6.5\times$ lower token consumption than communication-heavy baselines [2605.25188]. GoA reports that three selected agents can outperform recent baselines that use all six agents simultaneously, and on MMLU-Pro it reports $11$ calls, $19$k tokens, and $100$s latency for GoA\_max versus $19$ calls, $56$k tokens, and $240$s for MoA [2604.17148].

The literature therefore does not support a single verdict. Concrete findings support at least three positions simultaneously: discussion can improve performance under some configurations; naive discussion can underperform strong single-agent baselines; and heterogeneity, structured routing, or controlled disclosure often matter more than simply increasing the number of interacting agents.

Source: https://www.emergentmind.com/topics/multi-agent-discussion-framework