Rethinking the Bounds of LLM Reasoning: Are Multi-Agent Discussions the Key? (2024)

Abstract: Recent progress in LLMs discussion suggests that multi-agent discussion improves the reasoning abilities of LLMs. In this work, we reevaluate this claim through systematic experiments, where we propose a novel group discussion framework to enrich the set of discussion mechanisms. Interestingly, our results show that a single-agent LLM with strong prompts can achieve almost the same performance as the best existing discussion approach on a wide range of reasoning tasks and backbone LLMs. We observe that the multi-agent discussion performs better than a single agent only when there is no demonstration in the prompt. Further study reveals the common interaction mechanisms of LLMs during the discussion.1

heading: 1 Introduction
text: Large Language Models (LLMs) demonstrate strong abilities in language understanding and generation (OpenAI, 2022, 2023; Touvron et al., 2023a; Zhang et al., 2022a; Chowdhery et al., 2022; Team et al., 2023). However, LLMs still fall short for reasoning tasks due to model deficiencies like hallucination and reasoning perspective mistakes (Xu et al., 2023a). To overcome these issues, numerous works have been proposed by simulating human reasoning. Inspired by Society of Mind (Minsky, 1988), multi-agent discussion frameworks such as Debate (Du et al., 2023), MAD (Liang et al., 2023), and ReConcile (Chen et al., 2023a) present a novel approach by involving multiple AI agents. Powered by LLMs, these agents autonomously engage in discussions on given topics, improving the reasoning abilities of LLMs by emulating the human discussion process. To further improve the performance, most of multi-agent discussion frameworks leverage task-specific examples, which are often
*These authors contributed equally to this work. 1Our code can be found in https://github.com/
HKUST-KnowComp/LLM-discussion.
termed as demonstrations (Min et al., 2022). This is based on the insights that LLMs can learn from the context demonstrations (Brown et al., 2020). We note that all these discussion frameworks claim that they outperform the conventional methods with a single agent, such as Chain-of-Thought (Wei et al., 2022).
Figure 1 presents a comparison between singleagent settings and multi-agent discussion frameworks on FOLIO-wiki dataset (Zhang et al., 2023b; Han et al., 2022). In this figure, ‘Demo’ means that the tested single agent is provided with a demonstration case, ‘Q-Desc.’ indicates that the single agent is provided with detailed question description, while ‘Direct’ refers to the single agent without demonstrations. We observe that the single agent ‘Demo’ tends to reach a performance upper bound similar to that of all discussion frameworks, which will be further elaborated on later. This result suggests that the previous claim is NOT fully established.
Based on the observation from Figure 1, in this paper, we conduct systematic experiments to provide in-depth analysis. As a newly emergent topic, the number of available discussion frameworks still remains limited. To provide a more com-
1 6106

heading: You are a debator in this discussion.

heading: You are the judge in this discussion.
text: prehensive and detailed comparison between the single-agent settings and discussion frameworks, as demonstrated in Figure 3, we propose a new discussion framework named CMD, which is inspired by human group discussion process. Our discussion pipeline considers multiple design aspects shown in Figure 2 (see Section 2.1 for more details). We further carry out a range of experiments over standard reasoning benchmarks (ECQA (Aggarwal et al., 2021), GSM8k (Cobbe et al., 2021), and FOLIOwiki (Han et al., 2022; Zhang et al., 2023b)) using various configurations within different parts of this pipeline.
We find that multi-agent discussion does not necessarily enhance reasoning when the prompt provided to an agent is sufficiently robust, which aligns with the observation from Figure 1. Additionally, our experimental results reveal that multi-agent discussion frameworks outperform single-agent setups when no demonstrations are provided. We also find that agents powered by weaker LLMs like Bard (Anil et al., 2023) can improve its performance on reasoning with the assistance of the stronger LLMs like Gemini Pro (Team et al., 2023) during interaction.
In summary, our analysis provides a new way of understanding when to use multi-agent discussion on reasoning. Our contributions are listed as follows: (1) We propose a new multi-agent discussion framework CMD, which simulates human group discussion process; (2) We observe that single agents with a strong prompt match the performance of a multi-agent discussion using equally robust prompts; (3) We identify two common types
of discussion errors: judge mistake and wrong answer propagation; (4) We find that without demonstrations, multi-agent discussions surpass the single agent ; (5) In multi-LLMs multi-agent discussions, agents with stronger LLMs help improve performance of agents with weaker LLMs.

heading: 2 Preliminary

heading: 2.1 What is Multi-Agent Discussion?
text: Multi-agent discussion refers to an interactive setup where multiple agents, each powered by an LLM, engage in an autonomous dialogue. Each agent is given a prompt that outlines the necessary background knowledge and guides its behavior throughout the discussion. Once the topic is given, these agents can carry on the conversation independently.
Figure 2 illustrates a discussion design pipeline, which is structured into four main elements: the Kick-start prompt, agents, algorithm, and result. The Kick-start prompt supplies essential details such as background knowledge and the topic for discussion. This information is then fed to an agent, which operates based on various LLMs. Next, the algorithm lays out the specific rules of discussion, including the number of rounds, decision-making processes (whether by a judge or through voting), and the structure of the discussion (such as hierarchical). Lastly, ‘Result’ describes how the final decisions are rendered and presented. We further provide a view from symmetry for prompt-related mechanism (including discussion) in Appendix B.
2

heading: 2.2 Existing Discussion Frameworks
text: Previous works on multi-agent discussion frameworks have already covered several common discussion paradigms. In this paper, we consider the following discussion frameworks for our experiments: Debate (Du et al., 2023), MAD (Liang et al., 2023) and ReConcile (Chen et al., 2023a). Debate replicates a simple turn-based discussion among agents. Initially, all agents are prompted to address the assigned task, and their respective responses are then incorporated into each agent’s input for the subsequent round. Typically, this process consists of three rounds of discussion. MAD introduces divergent thinking by involving two participants to discuss a task from opposing perspectives. A judge then steps in to evaluate which viewpoint seems more plausible or if further discussion is needed. The discussion is repeated until a consensus is reached or the judge favors a particular solution. ReConcile implements a round-table discussion with the agents powered by multiple LLMs. It reaches a decision through a weighted voting system. In this process, agents provide a confidence level for their answers, and agents in ReConcile utilize these confidence levels as weights to cast votes and arrive at a final decision.
Despite these advancements, the number of multi-agent frameworks is still limited, and none has yet to consider one of the most prevalent forms of discussion: group discussion.
3 CMD: Conquer-and-Merge Discussion
To provide a thorough comparison in following experiments, we identify and rectify the gap in pre-
vious research, which has not suggested a groupdiscussion-based framework. To address this, we introduce a novel framework for multi-agent group discussion, referred to as CMD. In CMD, suppose there are n agents A = {Ai}ni=1 discussing a question Q, and agent Ai is powered by an LLM Li. We use an array H to store the history responses. The agents will discuss for R rounds. During each turn r, every agent Ai generates a response (vi, ei) = CMD(H|Q, r), where vi is the viewpoint and ei denotes the explanation. Detailed description can be seen in Appendix C.

heading: 3.1 Message-Passing Algorithm
text: For the synchronization of agent communications, we propose a message-passing algorithm. Previous works on multi-agent discussion frameworks focus exclusively on specific scenarios without designing a universal algorithm to synchronize agent messages across various discussions. Moreover, discussion forms vary in architecture and agents can be powered by different LLMs, where each LLM usually possesses different calling protocols. Therefore, we design a message-passing algorithm using a multi-threaded way to overcome these issues. The algorithm establishes a receiving map M for every agent to store the messages they should get in the next turn. For each message mj from Agent Ai, the algorithm first confirms the receivers Ar, then add mj into the receiving map M by every agent Ak ∈ Ar. When the next turn begins, the algorithm will automatically push stored messages from M to corresponding agents. Please refer to Appendix C.4 for more detailed pseudo code.
3
3.2 Three Stages of CMD As illustrated in Figure 3, CMD consists of three stages: group discussion, voting and the final decision stage. Typically, the final decision stage is reserved for instances of a tie and is otherwise unnecessary. Below is a breakdown of each stage involved in the CMD framework, and detailed introduction can be seen in Appendix C.3. Stage 1: Group Discussion. During this stage, agents A are divided into groups G = {Gk}tk=1 with an equal size. All agents are asked to solve task Q through discussion. For each agent Ai ∈ Gk, all answers and explanations from Ai ∈ Gk in the last round are accessible where Aj ∈ Gk and j ̸= i. In contrast, they can only see the answers without explanations from agents in other groups. After R rounds of discussions, CMD moves to the voting stage. Stage 2: Voting. When discussion reaches the maximum number of rounds, all agents A start voting. Each vote of agent in this discussion is treated equally, therefore, the result is determined by the majority decision. In the event of a tie, CMD transitions to stage 3. Otherwise, the discussion process concludes formally. Stage 3: Final Decision. If a tie occurs, we introduce an extra agent S in the role of the secretary to make the final decision. Each proposed answer is accompanied by an explanation selected from agents with the same opinion and provided to the secretary for the final determination. To sum up, the final decision is made by either Vote(A) or S(V,O|Q) where V = {vi}n and O = {oi}n, representing a set of viewpoints and a set of explanations respectively.

heading: 4 Experimental Setups
text: In the experiments, we contrast single-agent setup with four established multi-agent discussion frameworks: Debate, MAD, ReConcile, and CMD under various prompt conditions. These methods are introduced in previous Sections 2.2 and 3.

heading: 4.1 Implementation Details and Metrics
text: Our experiments are primarily implemented with three advanced LLMs, including ChatGPT-3.5 (OpenAI, 2022), Gemini Pro (Team et al., 2023) and Bard (Anil et al., 2023). In particular, we employ the gpt-35-turbo (0613) instance hosted on Azure OpenAI2 for ChatGPT-3.5, while the chat-
2https://oai.azure.com/
bison-001 model represents Bard via PaLM2 architecture. Gemini Pro and Bard interfaces operate through Google MakerSuite API3. A uniform dialogue temperature of 0.25 is configured across LLMs on CMD to ensure consistency. For all multiagent discussion frameworks, we set the maximum discussion round number to 3. Our evaluations use accuracy to measure performance across all tasks.

heading: 4.2 Downstream Tasks
text: The frameworks are implemented on a suite of reasoning tasks, including a commonsense reasoning task and two deductive reasoning tasks: (1) ECQA (Aggarwal et al., 2021): A QA dataset centered on commonsense knowledge, (2) GSM8K (Cobbe et al., 2021): A benchmark consists of math word problems, (3) FOLIO-wiki (Zhang et al., 2023b): A dataset adapted from FOLIO (Han et al., 2022) for both symbolic and natural language deductive reasoning. In alignment with constraints imposed by computational resources and following precedents set by earlier research (Du et al., 2023; Chen et al., 2023a; Liang et al., 2023), a subset of 100 instances from the test sets of both ECQA and GSM8K are selectively sampled. For an in-depth analysis, we choose to conduct a comprehensive experiments of all 460 cases within the curated version of the FOLIO-wiki dataset, which removes the flawed cases to ensure the result authenticity.

heading: 5 Experiments on Single LLM
text: In this section, we conduct our experiments using a single LLM, ChatGPT-3.5. To gain the initial insights, we provide an in-depth analysis of the FOLIO-wiki dataset, examining both single-agent settings and multi-agent discussions as detailed in Section 5.1. Afterward, we extend our experiments to two other datasets GSM8K and ECQA in Section 5.2. We also investigate common mistakes made by discussions through a case study in Section 5.3. Finally, we summarize our findings in Section 5.4.

heading: 5.1 Analysis of FOLIO-wiki Dataset
text: We begin by examining if multi-agent discussions are more effective than an agent using the strongest prompt on FOLIO-wiki dataset. Drawing from previous research (Wei et al., 2022; Ling et al., 2023) on crafting prompts for reasoning tasks, we divide the prompt into three parts: a detailed question description, which provides an in-depth background
3https://ai.google.dev/
4
Prompt Components Multi-Agent Discussion (%) Single Agent (%)Q-Desc. A-Desc. Demo. MAD (3) Debate (3) Debate (6) CMD (6)
64.13 70.00 69.13 73.26 70.22 74.13 75.65 76.30 74.13 73.26 68.91 71.96 71.74 73.89 71.30 71.96 70.22 70.00 71.09 73.91 74.13 75.65 74.78 77.39 76.09

heading: 5.2 Evaluation on All Tasks
text: advantage makes multi-agent discussions a more effective option in scenarios lacking specific expert knowledge or detailed examples. Why Does Discussion Frameworks Perform Differently on Tested Tasks? Table 2 indicates that MAD is the least effective among the frameworks tested. We suspect that this is because MAD incorporates a divergent thinking way, which asks agents to disagree with each other. This can sometimes hinder reasoning by introducing irrelevant information that complicates decision-making. We explore this further with an error analysis in Section 5.3. Additionally, we observed unexpected behaviors from other discussion frameworks under specific conditions or tasks. For example, Debate and CMD perform worse on ECQA dataset when demonstrations are introduced. We hypothesize that because ECQA demands more commonsense knowledge than purely analytical reasoning, the single-source interaction stemming from a single LLM might cause agents to overthink. Instead of clarifying misunderstandings, the increased dialogue may introduce complexity without addressing the underlying knowledge gaps. In contrast to ECQA, datasets like GSM8K and FOLIO-wiki place a greater emphasis on deductive reasoning abilities. In these cases, the discussion process between agents can be beneficial as it allows them to identify and address flaws in each other’s reasoning through interaction.

heading: 5.3 Two Discussion Error Types: A Case Study
text: Our experiments show that multi-agent discussions can sometimes reach incorrect conclusions on questions that a single agent answers correctly. Figure 4 presents an example from the FOLIO-wiki dataset illustrating this point: a single agent provides the correct answer, but multi-agent discussions lead to an erroneous result. We identify two
unique types of errors in multi-agent discussions: (1) Judge Mistake: This occurs in situations where an agent serves as a judge to decide on the final answer. If there are varying responses among agents, the judge might select the incorrect option as the final verdict. Frameworks like MAD and CMD are susceptible to this error, particularly when decisions are made during a tie. (2) Wrong Answer Propagation: This type of error happens when an agent, influenced by the input from others, deviates from its initial correct answer and adopts an incorrect consensus, spreading the mistake further in the discussion. This is the most common mistake the multi-agent discussion can make, even when most of their initial answers are correct.
6

heading: 5.4 Summary
text: In this section, we evaluate various prompt component combinations for both single-agent settings and multi-agent discussions. Our findings suggest that multi-agent discussions are on par with a single agent when both have access to demonstrations. However, in the absence of demonstrations, multiagent discussions generally outperform a single agent, making them a better option in scenarios where expert knowledge or detailed examples are insufficient. We also highlight unusual outcomes and present a case study to identify two frequent errors in multi-agent discussions: Judge Mistake and Wrong Answer Propagation.

heading: 6 Experiments on Multiple LLMs
text: In this section, we expand our experimental scope from a single LLM to multiple LLMs for both single-agent settings and multi-agent discussion frameworks, which allows us to test the validity of our previous findings in multi-LLM scenarios. Specifically, we assess the performance of agents powered by three advanced LLMs: ChatGPT-3.5, Gemini Pro, and Bard. In Section 6.1, we compare the performance of three single-agent configurations, each using a different LLM, against multiagent discussions leveraging all three LLMs. Our round-level analysis in Section 6.2 yields another insight: an agent powered by stronger LLM can enhance the performance of an agent powered by a less capable LLM.
More experimental results can be found in Appendix A, where we study the open-source LLMs and how they interact with other LLMs in CMD.

heading: 6.1 Validate Findings on Multiple LLMs Scenarios
text: In this section, we evaluate the performance of three single-agent settings, each supported by a different LLM, and two multi-agent discussion frameworks, ReConcile and CMD, across all tasks. We utilize two types of prompt settings for each task: one with demonstrations and one without. For the CMD framework, we organize six agents into two groups of three, with each agent in a group powered by one of the LLMs: ChatGPT-3.5, Gemini Pro, or Bard. The results presented in Table 3 support our previous findings from Section 5 with some slight modifications. A Strong Single Agent is Comparable to Discussion Frameworks. Based on experimental re-
(a) ReConcile (Discussion) (b) CMD (Group Discussion)

heading: 6.2 Enhancing Agents in Weaker LLMs with Support from Stronger LLMs

heading: Method Category LLM ECQA GSM8K FOLIO-wiki AverageDirect Demo Direct Demo Direct Demo Direct Demo
text: and recovers swiftly, largely maintaining its superior performance. Again, this finding is applicable to different multi-LLM discussions, specifically for both ReConcile and CMD.

heading: 7 Related Work

heading: 7.1 Prompting LLM for Reasoning
text: Recent researches have experienced great progresses in building powerful LLMs (Brown et al., 2020; OpenAI, 2022, 2023) or exploring the strategy of adopting LLMs over many downstream tasks via prompt enigineering.
By training with different knowledge textual sources and parameter size, various LLMs equipped with different reasoning capabilities are constructed, such as OPT (Zhang et al., 2022a), LLaMA (Touvron et al., 2023a,b), BLOOM (Scao et al., 2022), and PaLM (Chowdhery et al., 2022; Anil et al., 2023). Recently, Gemini Pro (Team et al., 2023) extends the capabilities of LLMs to the field of multi-modality.
Numerous advancements have been made in the field of improving reasoning abilities of LLMs with prompt engineering. Chain of Thought (CoT) (Wei et al., 2022; Kojima et al., 2022) is a linear problem-solving approach where each step builds upon the previous one. Fu et al. (2022) propose to apply CoT to multi-step reasoning tasks. To automate the CoT, Auto-CoT (Zhang et al., 2022b) constructs demonstrations by sampling diverse questions and generating reasoning chains. ActivePrompt (Diao et al., 2023) aims to select the most uncertain questions for task-specific annotations. Other prompt strategies designed to enhance reasoning in LLMs include the PS Prompt (Wang et al., 2023a), which breaks tasks into subtasks, ToT (Yao et al., 2023a) which expands on the reasoning process by considering multiple paths of reasoning and self-evaluating choices, the effective GoT (Yao et al., 2023b), which frames thoughts as graphs,
Natural Program (Ling et al., 2023) which helps to improve the deductive reasoning tasks, re-reading prompt (Xu et al., 2023b) which revisits the question information embedded within input prompts.

heading: 7.2 Multi-agent Discussion for Reasoning with LLMs
text: Multi-agent discussion utilizes multiple LLMs as agents to collectively discuss and reason given problems in an interactive way. Abundant researches have explored how to improve the reasoning ability of single LLM, while multi-agent discussion among LLMs is still under exploration.
The Multi-Agent Debate framework, introduced by (Du et al., 2023), establishes a mechanism for symmetric discussions among agents. During the same period, the MAD (Multi-Agent Debate) framework (Liang et al., 2023) introduces an asymmetric mechanism design. It assigns different roles (debater and judge) asymmetrically. Other similar works include (Chan et al., 2023). Also, the ReConcile framework (Chen et al., 2023a) exemplifies an asymmetric discussion mechanism by involving different LLMs and using a weighted voting mechanism. To understand discussion more deeply, Zhang et al. (2023a) aim to explain such collaboration mechanism in a social psychology view.
Unlike these works, we aim to explore the potential effects of prompting contents over the discussion process by our defined multi-agent group discussion framework CMD.

heading: 8 Conclusion
text: In this paper, we re-examine the claim that multiagent discussions are superior to a single agent in reasoning tasks by conducting systematic experiments. We introduce a novel framework CMD for a comprehensive and fair assessment. By conducting experiments over standard benchmarks, we find that (1) A single agent with a strong prompt and powered by a strong LLM achieves comparable per-
8
formance with multi-LLM multi-agent discussions; (2) In the absence of demonstrations, multi-agent discussion frameworks outperform single agents on most tasks; (3) When multiple LLMs are involved in multi-agent discussions, agents with stronger LLMs can enhance the performance of agents with weaker LLMs as discussion progresses.

heading: 9 Ethical Considerations
text: Our study employs publicly available datasets and LLMs accesses via official APIs, ensuring responsible and ethical use. Specifically, our ethical considerations can be summarized as follows: Public Datasets. Datasets we use are designed for academic research. No personal data has been processed. Licensed API Usage. Our application of LLMs complies with the API usage policies, maintaining fair use standards and respecting intellectual property. Transparency. We provide detailed experimentation methods to allow for result reproduction and encourage transparent scientific practices.

heading: 10 Limitations
text: Our research offers comprehensive experiments to study the performance of a strong single agent and multi-agent discussions. However, several aspects highlighted below can be further refined and explored in future work. Enhancing Agent Complexity. Currently, all discussion frameworks including CMD considers an LLM session as an AI Agent. This perspective simplifies the the concept of LLM-based AI Agent defined in the literature (Weng, 2023). By integrating more sophisticated techniques such as Tree-ofThought (Yao et al., 2023a) or Cumulative Reasoning (Zhang et al., 2023b), or incorporating with external tools or knowledge bases, we could potentially improve the overall reasoning performance of multi-agent discussions. Expanding Task Diversity. While our study mainly focuses on reasoning tasks for assessing both single-agent settings and multi-agent discussions, the adaptive nature of discussions allows for a broader types of applications. Future research could explore the use of agent discussions in diverse scenarios such as real-world strategic planning or the integration of agents into interactive gaming environments.
Experimenting with Additional LLMs. Due to computational and financial constraints, our investigation is limited to testing three LLMs—Bard, Gemini Pro, and ChatGPT-3.5. Expanding our analysis to include additional LLMs could provide a more extensive understanding of the capabilities and variances across different language models, offering valuable insights into the generalizability and scalability of our findings in multi-agent discussion frameworks.

heading: 11 Acknowledgement
text: The authors of this paper were supported by the NSFC Fund (U20B2053) from the NSFC of China, the RIF (R6020-19 and R6021-20), and the GRF (16211520 and 16205322) from RGC of Hong Kong. We also thank the support from the UGC Research Matching Grants (RMGS20EG01-D, RMGS20CR11, RMGS20CR12, RMGS20EG19, RMGS20EG21, RMGS23CR05, RMGS23EG08).

heading: A Extended Empirical Results

heading: A.1 Open-source language model
text: Table 4 shows the results of CMD on GSM8k with direct prompt (no demonstration). The open-source weak models also affect the results. As expected, the 7B LLM makes the overall performance worse than the 70B case.
Table 5 demonstrates how these three LLMs interact during the discussion. Our main claim that the weaker LLMs can be improved during the discussion also holds. We can see that Llama-7b and Llama-70b have been significantly improved.
Furthermore, by adding weaker LLMs, we can identify more fine-grained interactions.
• When the weakest LLM is sufficiently weak (Llama 7b), the stronger LLMs (Gemini Pro/Bard/ChatGPT3.5) are affected. However, the results are ensembled in the final decision stage, making the overall performance still compatible. (To see this, the baseline LLM performance of Llama is about 20%.
• When the weakest LLM is not sufficiently weak (Llama 70b), the performance of stronger LLMs (Gemini Pro/Bard/ChatGPT3.5) follows Figure 5. And the final results are good.
The experimental results with weak open-source LLMs reveal additional fine-grained information about LLM discussion.
A.2 CMD and other methods to enhance LLMs Self-consistency is a simple and effective way of improving the performance of LLMs. We argue that CMD and such approaches are orthogonal, so we can attach such methods within each agent inside CMD.
Table 6 below compares self-consistency against single-agent prompts and CMD. Self-consistency (6), with six trials, performs on par with the single agent with demonstration and CMD(6). We note that the self-consistency (6) runs with prompts with demonstrations, which matches the single-agent input.
When considering self-consistency (6) as a "discussion" without interactive messages, our claim that a single agent with strong prompts performs similarly to a multi-agent discussion still holds.
It is also interesting to consider self-consistency as a way to improve agents rather than a "discussion". In this way, self-consistency can be plugged into any discussion mechanisms. Given its similar performance with single-agent experiments revealed in the table above, one could expect that the improvement of adding self-consistency into other discussions is very marginal. Meanwhile, the number of tokens consumed by such discussion + self-consistency will be approximate -times of the cost of original discussion methods, where is the number of trials in self-consistency.
Similarly, self-consistency can be understood as one general technique to improve the performance of methods. Therefore, all discussion models can be further improved by running multiple times. However, such engineering hacking is beyond the scope of this paper, where we focus more on language model discussion. Besides, self-consistency can improve stability; it might bring more improvement when the weak but cheap LLMs, such as Llama-7b. However, how to improve weak LLMs is beyond the scope of the discussion itself.

heading: B Discussion Engineering and Agent Symmetry
text: This section introduces a general framework to understand the discussion engineering of large language models. Let L be a Large Language Model (LLM) and x be the input text, the forward inference generates
a response of surprising quality, which is written as
ŷ = L(x). (1)
Given the high price of obtaining one large language model, one essential research question is to unlock the reasoning capability of large language models so that they can perform better on various tasks. One of the key directions is prompt engineering, where the format and content of the input texts are decorated to improve performances for downstream tasks. Specifically, for a task T , the original input x is decorated as a task-specific prompt input p(x; T ,L). The function p(·; T ,L) is denoted as a prompt decorator for T and L. Then, output ŷ is generated by prompt engineering, which is written as
ŷ = L(p(x; T ,L)). (2)
Another way to improve the reasoning capability of L(x) is to leverage multiple times of inference of large language models, leading to a way larger space for mechanism design. The output ŷ derived by mechanismM is considered as
ŷ = M (x; {(Li, pi(·, T ,Li))}ni=1) , (3)
where M is the mechanism pipeline, Li is the i-th inference of LLM, and pi(·, T ,Li) is the corresponding prompt decorator. A mechanismM is designed by jointly consideringM = (M, {(Li, pi)}ni=1), i.e., how to organize prompt decorated LLM inferences into the mechanism pipeline M .
The discussion engineering, characterized by the mechanismM = (M, {(Li, pi)}ni=1), includes careful designs at three levels: (1) the (i-th) inference Li of an LLM, (2) the prompt decorator pi for the inference Li, and (3) the mechanism M(·, {Li, pi}) to organize the inferences of LLMs. We further introduce the symmetry of the multi-agent system of LLMs to demonstrate the complexity ofM. Under our framework, several examples are discussed.
14
B.1 Agent symmetry in discussion engineering Symmetry and its breaking is a fundamental concept and widely investigated in science (Anderson, 1972). Symmetry also plays an important role in the context of mechanism design of multiple agents (Laffont and Martimort, 2000; Daskalakis and Weinberg, 2012). Here we introduce a formal description to justify the agent symmetry of the mechanismM. Definition 1 (Computational graph). Given the mechanism M = (M, {(Li, pi)}ni=1), let G = (V ∪ {x, y}, E) be the directed graph whose node set V ∪ {x, y} includes the inference operation of LLM and the computational input node and output nodes. x is the node to emit the input text, y is the node that takes the inputs from one or multiple inferences and emits the final output, and vi ∈ V is the inference node that describes the i-th LLM inference with (Li, pi). The directed edge in (vi, vk) ∈ E describes the output of inference node vi is then the input of inference node vk.
We note that the graph G contains all the necessary information to determine the mechanismM. Then we introduce how the LLM agents are associated with the computational graph. To make an LLM conversational session, the entire conversational history is always concatenated as part of the input of each inference call, resulting in many additional connections of the computational graph. The presence of agents allows us to conceptually assume the agents “know” the information in the conversation history, and then the complexity of the graph can be largely reduced. In this paper, we consider the computational graph with agents, so the connections that feed conversation history to the inference nodes are ignored for simplicity.
Let A = {A1, ..., Am} be the set of m discussion agents. The inference call of an agent also concatenates its conversation history, denoted as Aj(x). Definition 2 (Agent assignment). Let A = {A1, ..., Am} be the set of m discussion agents. Each inference node vi ∈ V is assigned to an agent Aj ∈ A. Let [n] present integers from 1 to n, α : [n] 7→ [m] is the assignment map that assigns the i-th inference to the α(i)-th agent. Let P ∈ {0, 1}n×m be the agent-inference assignment matrix, such that
Pij = { 1 j = α(i), 0 j ̸= α(i) . (4)
The assignment matrix P is equivalent to the assignment map α.
Then a multi-agent discussion mechanism is defined by the triple D = (M,A, α) = (G,A, α), which is the central object of discussion engineering. Then, we can further introduce the concept of the coloring of the computational graph.
Definition 3 (Agent coloring of the computational graph). Given the the multi-agent discussion D = (G,A, α), then each inference node vi is described by (Li, pi) = (Aα(i), pi). Let cDi = (Aα(i), pi) be the color of vi and CD(vi) = cDi be the color mapping of nodes, and CD = (V,E,CD) be a colored computational graph.
Then the agent symmetry is established by the permutation operation over the agent set A. Then we can discuss the symmetry by the agent permutation. We begin with the concept of mechanism invariance.
Definition 4 (Mechanism invariance under the agent permutation). Given the multi-agent discussion D = (G,A, α) and a permutation mapping π : [m] 7→ [m], the new discussion Dπ = (G,A, π ◦ α) is derived by applying π to the agents. We say a discussion D is invariant under π if and only if there is an isomorphism ϕ between two colored graphs CD = (V,E,CD) and CDπ = (V,E,CDπ), such that
(1) ϕ is a bijection,
(2) ∀(vi, vj) ∈ E, (ϕ(vi), ϕ(vj)) ∈ E,
(3) ∀v ∈ V,CD(v) = CDπ(ϕ(v)).
We can also define the model invariance to justify the symmetry in the multi-model setting (Chen et al., 2023a).
15
Definition 5 (Model invariance under the agent permutation). Given the agent A = {A1, ..., Am}, and their underlying LLM {L1, .., Lm} (i.e., ChatGPT, GPT4, etc.), the permutation π : [m] 7→ [m] is invariant if for i = 1, ...,m Li = Lπ(i).
Following the definition of invariance, the symmetry group of agents is naturally defined following the standard algebra (Tapp, 2021). The largest possible symmetry group for a discussion of m agents is the group Sm. However, the group Sm is not always the symmetry group of a given multi-agent discussion mechanism D, the reasons for not achieving the largest symmetry group can be due to the asymmetry in the mechanism and asymmetry in models, respectively. Furthermore, for asymmetric mechanisms, there are two major ways of symmetry breaking. Referring to the three conditions of establishing the isomorphism, the dissatisfaction of condition (2) implies the asymmetry in the computational graph or asymmetry in the mechanism pipeline M , and that of condition (3) implies the asymmetry in prompt decorators.
C CMD: Conquer and Merge Discussion Framework

heading: C.1 Motivation
text: The Debate framework proposes that an increased number of agents and discussion rounds will result in improved performance in multi-agent discussions (Du et al., 2023). Also, the ReConcile framework asserts that a greater number of discussion rounds leads to a higher level of consensus among agents, and the higher the consensus among agents, the more accurate the discussion outcomes become (Chen et al., 2023a). However, as the number of agents increases in a discussion, it leads to increased overhead in each round of discussion: 1. Each agent has to read more viewpoints from others, resulting in a sharp rise in input tokens. 2. The increase in input tokens puts significant pressure on language models with context token limitations. Inspired by real-life group discussions, we propose a variant framework for Debate called CMD. Fig 3 shows the overview of our method.

heading: C.2 Problem Definition
text: Assume that there are n agents A = {Ai}mi=1 are discussing the given debate task Q, and each agent is a session created from a LLM. Suppose that the maximum number of the discussion rounds is R, the current round is r, the current discussion level is L, and the current active agents set is A′. For each agent Ai ∈ A′, an answer it generates is Ansi = (vi, ei), where vi denotes the viewpoint and ei denotes the explanation. A debate history is H(r) = ⋃t i=1Ansi where t = |A′|. Ans (r) i is generated through the input prompt Ai(Q, Ans(r−1)i , O (r−1) i ), where O (r) i indicates the opinions generated by Aj ̸=i in (r−1)-th round. The formal definition of O(r)i is
O (r) i =
|H(r−1)|⋃
j=1,j ̸=i
( vi, ei · 1{Group(L)(Ai) = Group(L)(Aj)} ) . (5)
This represents that Ai will receive all information from the group members while it can only receive viewpoints from agents that are not in the same group. Our goal is to obtain the final result a through an unweighted vote. In the event of a tie, either a can be made by a secretary S, or representatives from each group will proceed to the next level of discussion until the tie is resolved. Each discussion group has only one representative. Note that Q can be described differently for each Ai. For example, different agents may be asked to hold different views at first.
C.3 CMD Stages
Generally, there are three stages in CMD. In stage 1, the group map and all states will be initialized, then all the participants will generate their initial answers. Then, in stage 2, the participants will continue the discussion during the remaining rounds in groups. When the discussion round reaches the maximum number, it moves to stage 3. In this stage, all participants will vote to get the final answer.
16
Algorithm 1 CMD: A Conquer and Merge Style Multi-Agents Discussion Framework Require: Debate Task Q, Maximum Discussion Rounds R, Agents A = {Ai}ni=1, Secretary S Ensure: Final Result a
1: function CMD(Q, R,A, S) 2: A′ ← A ▷ Initialize current active agents 3: Ng ← n/3 ▷ Initialize group numbers, every 3 agents a group 4: r ← 0, L← 0 ▷ Initialize current round and current discussion level 5: Lmax ← getMaxLevel(A, S) 6: Mg ← genGroupMap(A, Ng, Lmax) ▷ Assign agents as groups based on discussion levels 7: Ansi ← ∅, Oi ← ∅, H ← [] ▷ Initialize answer, others’ opinions and history 8: while L ≤ Lmax do 9: while r ≤ R do 10: if r > 0 then ▷ Stage 2 11: Update Oi from H 12: end if 13: H ← [] 14: for each Ai ∈ A′ do 15: Ansi ← Ai(Q, Ansi, Oi) ▷ Ansi = (vi, ei) 16: H ← H + [Ansi] 17: end for 18: r ← r + 1 19: end while 20: a← AnswerVote(H) 21: if a ̸= Tie then break 22: else if S is not None then ▷ Check if the secretary mode is on 23: a← S(Q, H); break 24: else ▷ Secretary mode is off, representative mode is on 25: L← L+ 1 26: A′ ← currentActiveAgents(L,Mg) 27: end if 28: r ← 0 ▷ The higher-level discussion has commenced 29: end while 30: return a 31: end function
• Stage 1 : Group Discussion Initialization. In this stage, A′ will be initialized as all participants. All participating agents are initially assigned names in uppercase letters, and they are then grouped in sets of three. For getMaxLevel, if secretary mode is on, then it will be set to 1. Otherwise, it will be determined based on the current number of agents. For getGroupMap, the algorithm will automatically generate the groups for all levels. Higher-level groups are generated among the current representatives. All active agents will generate their first response Ansi.
• Stage 2 : Multi Rounds Discussion. In this stage, the active agents will continue to discuss in the remaining rounds. Assume current round number is r, for each agent Ai ∈ A′, 1. The algorithm will start to update the opinions history O(r−1)i from H . For each record hj whose
sender Aj(j ̸= i) stored in H , if Aj and Ai are in the same group, O(r−1)i will record both the viewpoint and explanation from hj ; otherwise, O (r−1) i will only record the viewpoint from hj . After traversing all the records in H , Oi will first gather all opinions of agents from other groups, then O
(r−1) i will gather local group explanations based on group members opinions.
2. To save up tokens, last round history H will be reset. Then, the new prompt p(r)i will be generated
17
based on (Q, Ans(r−1)i , O (r−1) i ). Ai will make a response Ansi = (vi, ei) when given p (r) i . At last, Ansi will be appended to current round history H for the further use.
3. Repeat 1. and 2. until the maximum number of discussion rounds is reached.
• Stage 3 : Vote for the Final Result. In this stage, all agents will vote based on their final viewpoints stored in the history H(r) to obtain the result a. If there is no tie, then a will be the final result, thus the discussion is over. If there is a tie and secretary mode is on, then the final result will be obtained through S based on the viewpoints and explanations from all sides. If there is a tie and representative mode is on, then the discussion will move to the higher level, and deactivate agents that do not represent their groups. The representatives will be assigned to new groups, and return to Stage 2 for further discussion. If there is still a tie, new representatives will be designated for further discussion, until either the tie is resolved or only one agent is activated for the discussion.

heading: C.4 Message-Passing Algorithm
text: Below is the detailed message-passing algorithm that synchronize all agents messages during the discussion process. This algorithm supports various discussion architectures.
Suppose we have a discussion rule R, agents A, agent attribute table T and agent initial prompts M. Here, the agent attribute table T catalogs the various methods by which an agent processes inputs and formulates responses. These methods might range from LLMs such as ChatGPT-3.5 to synergistic approaches like self-consistency. Now, let’s focus on how our algorithm works.
Our system employs two primary global queues that span all agent threads. Queue Qmsg is designated for holding messages originating from agents that await processing by MESSYNC, while queue Qsend contains processed messages to deliver to respective agents. Each message has the basic info, including message content, sender, and receivers. Usually, receivers are determined either by default (predefined receiving scope) or by the discussion ruleR (temporarily changed receiving scope).
MESSYNC broadly operates in three stages: Initialization, Message Passing, and Message Receiving.
Initialization: Here, parameters Qmsg, Qsend, speaker S, and discussion depth d are initialized. d is important to determine correct dispatch and receipt timings. The system then enters an iterative state to check whether the discussion is finished. For instance, in Debate, all agents speak for each round, meaning that messages from each agent are not immediately sent to others until proceeding to the next round.
Message Passing: If the discussion continues without pending messages, it’s presumed a silence situation (like a teacher asks if students have questions and they remain silent to mean “no”). To gauge discussion progress, the heading depth in Qmsg is peeked and assigned to the depth d, and all messages at that depth are gathered. To prevent repeat dispatching, all messages destined for a particular agent Ai are amalgamated into one, mi, which is then placed in Qsend.
Message Receiving: Now receivers enter focus. After receiving a message, they may stay silent at the next depth d+ 1 (like the students above).
To avoid the biases caused by explicitly asking LLM to stay silent, we introduce a signal HOLD to denote buffering m′ at d into H . For simplicity, the pseudo-code showcases how to buffer messages for one depth. In normal cases, the speaker is then set to the message receiver. Raw input will be preprocessed as tin based on rule R. A bot (or method) boti in T is chosen to generate response tout. If R validates this, it seeks out the next message receiver set A′, creates a new message mnew, and pushes it into Qmsg. Stages 2 and 3 iterate until the end of the discussion. Now, agents can safely sync messages, and all we need to do is to design the discussion ruleR like Debate and CMD.
18
Algorithm 2 MesSync: A Message-Passing Algorithm for Multi-Agents Communication Require: Discussion RuleR, Agents A = {Ai}ni=1, Agent Attribute Table T = {boti}ni=1, Agent Initial
Prompt MessagesM = {pj}tj=1 1: function MESSYNC(R,A, T ,M) 2: Qmsg ←M ▷ Initialize messages storage queue 3: Qsend ← [] ▷ Initialize messages to be sent queue 4: S ← R.Sfirst ▷ Initialize the first speaker 5: d← 0 ▷ Initialize the discussion depth to 0 6: while Qmsg ̸= ∅ or notR.isOver do 7: if Qmsg is ∅ then 8: Qmsg ← pushSilenceMessage(d) 9: end if 10: d← peekDepth(Qmsg) ▷ Peek the discussion depth of the first message 11: Md ← popAllMessagesAtDepth(Qmsg, d) 12: for each Ai ∈ A do 13: mi ← R.mergeCommonMessages(Md, Ai) 14: Qsend.push(mi) 15: end for 16: m′ ← Qsend.pop() 17: isHold← m′.hold ▷ Signal to merge messages from this round with the next 18: H ← {} ▷ Initialize the map of messages to hold in the current depth 19: dnext ← d+ 2 if isHold else d+ 1 20: while m′ and m′.d < dnext do 21: if m′.hold then H[m′.name]← m′.content 22: else 23: S ← m′.name 24: Mraw ← m′.content ∪H[S] 25: tin ← R.modifyRawInput(Mraw) 26: tout ← sendText2Bot(tin, S, d, T ) 27: tout ← R.validateOutput(tin, tout, S, d) 28: A′ ← R.getReceivers(S, d) ▷ Get the receivers of the new message 29: if A′ ̸= ∅ then 30: mnew ← genMessage(tout, S,A′, dnext) ▷ (content, sender, receivers, depth) 31: Qmsg.push(mnew) 32: end if 33: end if 34: m′ ← Qsend.pop() 35: end while 36: ifR.isOver then break 37: end if 38: end while 39: end function
D An CMD Example
In the upcoming demonstration, we’ll walk you through the CMD framework from the viewpoint of agent A among six agents using ChatGPT-3.5.
19

heading: D.1 Meta Prompt

heading: System

heading: D.2 Round 1 Answer

heading: Assistant (ChatGPT-3.5) - Agent A
text: 20

heading: D.3 Middle System and User Prompts in Round 1

heading: System

heading: User
text: 21

heading: D.4 Round 2 Answer

heading: Assistant (ChatGPT-3.5) - Agent A

heading: D.5 Middle System Prompt at the End of Round 2

heading: System

heading: User
text: 22

heading: D.6 Round 3 Answer

heading: Assistant (ChatGPT-3.5) - Agent A
text: E CMD Secretary - A Tie Case Solution
In the event of a tie between two groups, we suggest employing a secretary to resolve such cases. The complete chat transcript below in table 13 illustrates a scenario where the secretary provides the ultimate resolution.
23

heading: System

heading: User

heading: Assistant (ChatGPT-3.5) - Secretary
text: 24

heading: F Extended Related Work

heading: F.1 Large language models L
text: With the advent of large language models (LLMs) like GPT-3 (Brown et al., 2020), chatGPT (OpenAI, 2022), GPT-4 (OpenAI, 2023), Llama series (Touvron et al., 2023a,b) and PaLM 2 (Anil et al., 2023), prompt engineering is a burgeoning field that focuses on optimizing the output of language models by crafting effective input prompts.
F.2 Prompt decorator p(·; T ,L) for reasoning Numerous advancements have been made in the field of improving reasoning abilities of LLMs with prompt engineering. Chain of Thought (CoT) (Wei et al., 2022; Kojima et al., 2022) is a linear problemsolving approach where each step builds upon the previous one. Fu et al. (2022) propose to apply CoT to multi-step reasoning tasks. To automate the CoT, Auto-CoT (Zhang et al., 2022b) constructs demonstrations by sampling diverse questions and generating reasoning chains. Active-Prompt (Diao et al., 2023) aims to select the most uncertain questions for task-specific annotations. Other prompt strategies include PS prompt (Wang et al., 2023a) which divides task into subtasks then solve them, effective GoT (Yao et al., 2023b) which models human thought processes as a graph rather than a chain, Natural Program (Ling et al., 2023) which helps to improve the deductive reasoning tasks, re-reading prompt (Xu et al., 2023b) which revisits the question information embedded within input prompts.
F.3 MechanismM for reasoning In addition to focusing on the design of prompts themselves, some works incorporate different mechanisms to assist language models in reasoning.
The design directions of these mechanisms include: 1. Breaking down the reasoning process into multiple stages, with possible verification at each stage. 2. Optimizing the reasoning process via ensemble methods. 3. Iteratively prompting the model for reflection and correction. 4. Utilizing external tools to aid in reasoning. These approaches aim to enhance the overall reasoning capabilities of language models by introducing additional support and guidance throughout the process. Break Down the Reasoning Process into Multiple Stages. Breaking the original tasks into several operations is an important approach to solving reasoning problems (Liu et al., 2022b) and handling longer contexts (Fei et al., 2023). For reasoning with external knowledge base, this approach leads to many problems when each specific step can be explicitly realized by predicates (Xu et al., 2024; Liu et al., 2024) or logical operations (Wang et al., 2021, 2022b, 2023b,c; Yin et al., 2024b,a; Fei et al., 2024). For LLMs approaches, Self-Polish (Xi et al., 2023) make models to progressively refine given problems with multiple stages of prompts. Additionally, some works (Khot et al., 2022; Press et al., 2022; Dua et al., 2022; Zhang et al., 2023b) study over decomposing the tasks into smaller tasks, and use an individual prompt to solve each subtask. Optimize the Reasoning Process via Ensemble Methods. Tree of Thoughts (ToT) (Yao et al., 2023a) expands on the reasoning process by considering multiple paths of reasoning and self-evaluating choices. Graph of Thoughts (GoT) (Besta et al., 2023) further advances this by modeling information as an arbitrary graph, enabling complex networks of thoughts. And some works propose to first sample reasoning paths then vote for the best one, including self-consistency (Wang et al., 2022a) and step-aware verifier (Li et al., 2022). Discussion Engineering is also one category of ensemble methods. We leave it to section 7 for further introduction. Iteratively Prompt the Model for Reflection and Correction. These works (Zelikman et al., 2022; Weng et al., 2022; Shinn et al., 2023; Madaan et al., 2023; Chen et al., 2023b; Xue et al., 2023) are mainly based on iteratively asking model to find the mistakes or inconsistencies among previous reasoning steps or the knowledge, then solve them one by one. Utilize External Tools or Knowledge to Aid in Reasoning. Mind’s Eye (Liu et al., 2022a) proposes to use a physical simulator to help models reason in the physical world. There are also other works (Lu et al., 2023; Imani et al., 2023) that will equip models with tools to solve problems. Furthermore, some works
25
like MemPrompt (Madaan et al., 2022) and LogicSolver (Yang et al., 2022) use external knowledge to assist LLMs with reasoning.
26

heading: Future Work
text: However, several aspects highlighted below can be further refined and explored in future work. Enhancing Agent Complexity