Multi-Agent Discussion Framework

• Multi-agent discussion frameworks are systems where agents exchange structured messages and coordinate tasks using explicit protocols, stateful interactions, and decision rules.
• They employ varied architectures—from finite-state machines to graph-based methods—to manage message visibility, memory, and information aggregation.
• Recent evaluations show that, while structured debates can enhance performance in specific configurations, strong single-agent baselines often yield competitive results.

Searching arXiv for 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 (Lillis et al., 2015). 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 (Becker et al., 15 Sep 2025). 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 (Lillis et al., 2015).

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 (Becker et al., 15 Sep 2025). A broader evaluation-oriented formalization models a multi-agent debate framework as

$$\mathcal{M} = \langle Q, \mathcal{A}, \mathcal{S}, \delta, \Pi \rangle,$$

with $P = (\phi,\,S,\,T,\,i,\,F),$0 as the query space, $P = (\phi,\,S,\,T,\,i,\,F),$1 the agents, $P = (\phi,\,S,\,T,\,i,\,F),$2 the global state, $P = (\phi,\,S,\,T,\,i,\,F),$3 the state-transition function, and $P = (\phi,\,S,\,T,\,i,\,F),$4 the aggregation policy (Zhang et al., 12 Feb 2025). In a different direction, NormAN represents discussion domains by Bayesian Networks and treats each piece of evidence as an atomic argument with likelihood ratio

$P = (\phi,\,S,\,T,\,i,\,F),$5

so that argument exchange becomes Bayesian belief revision over a networked population (Assaad et al., 2023).

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 (Lillis et al., 2015). 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 (Becker et al., 15 Sep 2025). SimuPanel uses a host agent

$P = (\phi,\,S,\,T,\,i,\,F),$6

where $P = (\phi,\,S,\,T,\,i,\,F),$7 is the finite stage set $P = (\phi,\,S,\,T,\,i,\,F),$8 and $P = (\phi,\,S,\,T,\,i,\,F),$9 is the moderation policy; expert agents are defined by persona, memory, reasoning pipeline, and utterance generator (He et al., 19 Jun 2025). 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 (Zhang et al., 22 May 2025). 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 (Yun et al., 18 Apr 2026).

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 $C = (\phi,\,A,\,s_c,\,c,\,B,\,\psi),$0 defines which messages are visible to which agents and in what order. The “Memory” paradigm gives full visibility,

$C = (\phi,\,A,\,s_c,\,c,\,B,\,\psi),$1

whereas the “Relay” paradigm restricts each agent to the previous agent’s last message,

$C = (\phi,\,A,\,s_c,\,c,\,B,\,\psi),$2

The same framework provides three decision-protocol families: Consensus, Voting, and Judge (Becker et al., 15 Sep 2025).

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 (Kaesberg, 6 Jul 2026). 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 (Wang et al., 2024). 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 (Li et al., 24 May 2026). 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 (Yun et al., 18 Apr 2026).

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 $C = (\phi,\,A,\,s_c,\,c,\,B,\,\psi),$3 at round $C = (\phi,\,A,\,s_c,\,c,\,B,\,\psi),$4,

$C = (\phi,\,A,\,s_c,\,c,\,B,\,\psi),$5

and the agent response is generated from the context $C = (\phi,\,A,\,s_c,\,c,\,B,\,\psi),$6 (Hua et al., 2 Feb 2026). The framework introduces activation-based notions of context coherence and output discrepancy, and a self-adaptive loss

$C = (\phi,\,A,\,s_c,\,c,\,B,\,\psi),$7

with a dual update for $C = (\phi,\,A,\,s_c,\,c,\,B,\,\psi),$8. 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 (Zhang et al., 22 May 2025).

DarkForest addresses robustness by minimizing exposure to raw reasoning traces. It builds an unnormalized evidence score

$C = (\phi,\,A,\,s_c,\,c,\,B,\,\psi),$9

normalizes it into a posterior-like distribution $D = ( A , P , G , \phi , C ),$0, and then applies a narrow deterministic guardrail that overrides the coordinator only when the top cluster is strongly supported (Li et al., 24 May 2026). 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 (Zhang et al., 17 May 2026).

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 (Chen et al., 18 Mar 2025). 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 $D = ( A , P , G , \phi , C ),$1. On MedQA and PubMedQA, the framework reports accuracies of $D = ( A , P , G , \phi , C ),$2 and $D = ( A , P , G , \phi , C ),$3, respectively (Chen et al., 18 Mar 2025).

HiMATE applies hierarchical discussion to machine translation evaluation. Its pipeline is Subtype Evaluation, Self-Reflection, Collaborative Discussion, followed by weighted MQM scoring,

$D = ( A , P , G , \phi , C ),$4

The paper reports an average F1-score improvement of $D = ( A , P , G , \phi , C ),$5 over the best-performing baseline in error span detection and severity assessment (Zhang et al., 22 May 2025). 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

$D = ( A , P , G , \phi , C ),$6

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 $D = ( A , P , G , \phi , C ),$7 minutes to approximately $D = ( A , P , G , \phi , C ),$8 seconds (Li et al., 2024).

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 (Ma, 8 Aug 2025). On TAT-QA, it reports $D = ( A , P , G , \phi , C ),$9 EM and $A$0 F1, compared with $A$1 EM and $A$2 F1 for deepseek-v3; on SEM-TAB-FACTS, it reports Dev $A$3 and Test $A$4 (Ma, 8 Aug 2025). 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 (He et al., 19 Jun 2025, Yang et al., 12 Sep 2025).

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 (Zhang et al., 12 Feb 2025). On aggregated average accuracy across nine benchmarks, the reported values are $A$5 for CoT, $A$6 for SC, and between $A$7 and $A$8 for the evaluated MAD methods, with all MAD methods using more tokens than CoT on average (Zhang et al., 12 Feb 2025).

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 $A$9 in Direct mode to $P$0 in Demo mode, while CMD rises from $P$1 to $P$2 (Wang et al., 2024). 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 $P$3 versus $P$4 for SoM-Average, and EoT-Heter reaches $P$5 versus $P$6 for EoT-Average (Zhang et al., 12 Feb 2025). 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 (Kaesberg, 6 Jul 2026). DarkForest argues for “less talk” by reporting up to $P$7 improvement on benchmark metrics over the strongest baseline and up to $P$8 lower token consumption than communication-heavy baselines (Li et al., 24 May 2026). GoA reports that three selected agents can outperform recent baselines that use all six agents simultaneously, and on MMLU-Pro it reports $P$9 calls, $G$0k tokens, and $G$1s latency for GoA_max versus $G$2 calls, $G$3k tokens, and $G$4s for MoA (Yun et al., 18 Apr 2026).

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.