Corex: Pushing the Boundaries of Complex Reasoning through Multi-Model Collaboration

Venue: colmweb_org_COLM_2024_Conference
Published: 2024-03-21 15:14:58

Abstract: Large Language Models (LLMs) are evolving at an unprecedented pace and have exhibited considerable capability in the realm of natural language processing (NLP) with world knowledge. Benefiting from ultra-large-scale training corpora, a single LLM can manage typical NLP tasks competently. However, its performance in executing complex tasks is still confined by the limitations of its internal representation. To push this boundary further, we introduce Corex, a suite of novel general-purpose strategies that transform LLMs into autonomous agents, pioneering multi-model collaborations for task-solving. Inspired by human behaviors, Corex is constituted by diverse collaboration paradigms including Discuss, Review, and Retrieve modes, which collectively work towards enhancing the reasoning process. These paradigms foster task-agnostic approaches that enable LLMs to “think outside the box,” thereby overcoming common errors and providing better solutions. Through extensive experiments across four different types of reasoning tasks, we demonstrate that orchestrating multiple LLM-based agents to work in concert yields better results compared to well-established existing baselines. Further analysis reveals the advantages of Corex over other multi-model methods, synergies produced among different LLMs, and the effectiveness across various aspects.

Main paper: 
 introduction: 
 Large Language Models (LLMs) have succeeded in advancing the state-of-the-arts for a series of Natural Language Processing (NLP) tasks (Brown et al., 2020; Chowdhery et al., 2022; OpenAI, 2023; Touvron et al., 2023; Zhao et al., 2023a, inter alia) . Recent research (Wei et al., 2022a) indicates that scaling up models (Kaplan et al., 2020) can yield improvements in both performance and sample efficiency across a broad spectrum of downstream tasks. Notwithstanding their remarkable proficiency in language understanding and instruction following (Ouyang et al., 2022) , the reasoning abilities of LLMs, often seen as a hallmark for assessing their potential, still present challenges (Suzgun et al., 2023; Huang & Chang, 2023) . Concurrently, there is a prevailing view that merely increasing the size might not adequately address their inherent limitations in solving reasoning tasks (Rae et al., 2022) .In response to this challenge, Wei et al. (2022b) put forth chain-of-thought (CoT) prompting that an LLM generates a series of intermediate steps toward a final answer, contrasting the use of "answeronly" prompts. Subsequently, various approaches have been put forward, such as self-consistency decoding (Wang et al., 2023d) which utilizes a majority voting mechanism to determine the final answer, and program-aided language models (PAL; Gao et al., 2022; Chen et al., 2022a ) that leverage code generation to reduce errors in computations. Besides, curated prompts necessitate task-specific designs (Zheng et al., 2023a) have also been utilized to elicit more accurate predictions. Nevertheless, these approaches are confined within a static black box (Yao et al., 2023b) , wherein the LLM relies exclusively on its internal representation for generating responses and is prone to generating unreliable answers (Ji et al., 2023; Yin et al., 2023) . These shortcomings underscore that relying solely on crafting decoding strategies and specialized prompts may not serve as a silver bullet for addressing Figure 2 : An intuitive illustration of Corex, employs LLMs as agents to collaboratively solve a problem. The strategies encompass the Debate, Review, and Retrieve modes, leveraging both the reasoning process and code synthesis. This framework facilitates interactions between models that foster a collaborative environment for the derivation of a well-reasoned answer. complex reasoning tasks (Qiao et al., 2023) . Alternatively, enabling models to "think outside the box" emerges as a promising yet underexplored pathway.Within the realm of well-established sociological concepts, multiple cognitive processes interact and cooperate will produce a combined effect that is greater than the sum of their individual contributions (Luppi et al., 2022) . This principle is echoed within artificial intelligence (Li et al., 2023a) . Although the study of intelligent agents has been explored for decades (Minsky, 1988; 2007) , the advent of LLMs has rejuvenated interest and introduced novel challenges in this domain. An emerging perspective is that encouraging collaboration and communication between models could potentially pave the way for a new stage for enhancing complex reasoning capabilities.In this study, we propose Corex, a suite of human-inspired strategies that leveraging multi-model collaboration to elicit reasoning for complex task-solving. To facilitate synergies between models, we first assign distinct personas to different models, followed by the design of various collaborative paradigms. This collective intelligence-based method aims to conquer prevalent obstacles in the current landscape of reasoning, as exemplified in Figure 1 . It also endeavors to alleviate common issues observed in majority voting-based methods like self-consistency, where accurate responses might be overwhelmed by incorrect ones and exorbitant costs. To be specific, Corex configures LLMs as a group of autonomous agents, adopting the paradigms shown in Figure 2 for multi-model collaboration: (1) Debate, utilizing group-based debates among models to effectively enhance the factuality (Du et al., 2023) of generated content and minimize fallacies and hallucinations; (2) Review, enabling models to scrutinize reasoning chains or generated codes from their counterparts to ensure the correctness of generated contents, coupled with potential refinements; (3) Retrieve, aiming to enable the model to identify the most faithful option from a pool of candidate chains, facilitates a higher degree of alignment with the final response. The comparison between Corex and recent works is listed in Table 1 , where our approach is task-agnostic, requiring no prior knowledge or iterative processes during the reasoning phase, which makes it broadly applicable to a wide array of scenarios.We conduct extensive experiments across four types of tasks: mathematical reasoning, symbolic reasoning, commonsense reasoning, and semi-structured reasoning. The results illustrate that our method achieves substantial performance gains over previous strong baselines. Moreover, each mode distinctly excels in different categories of tasks, showcasing its specific strengths. Further analysis reveals that, compared to existing schemes based on majority voting and curated prompts, Corex significantly reduces the reasoning overhead of the models, achieving cost-effectiveness. (Zheng et al., 2023a) CoK (Wang et al., 2023b) ToT (Yao et al., 2023a) Task Agnostic?✓ ✗ ✗ ✓ ✓ Multiple Chains? ✓ ✗ ✗ ✗ ✓ Multiple LLMs? ✓ ✓ ✗ ✗ ✗ Task Delegation? ✓ ✗ ✗ ✗ ✗ Reference Free? ✓ ✓ ✓ ✗ ✓ 
related works: 
 Chain-of-Thought Prompting Elicits LLM Reasoning. Chain-of-Thought (CoT; Wei et al., 2022b) prompting, as one of the celebrated capabilities of recent LLMs, is a pivotal breakthrough for performing complex multi-step reasoning when provided with limited examples. Further variants show that CoT can be improved by adding certain "magic phrases" (Kojima et al., 2022) , automated demonstrations construction (Zhang et al., 2023a) , reasoning in different modalities (Zhang et al., 2023b; Yang et al., 2023; Yao et al., 2023c) , and applying modular approaches (Khot et al., 2023) . For robustness, researchers transform problems into interleaved reasoning chains (Zhou et al., 2023; Lyu et al., 2023) or adopt ensembling (Wang et al., 2022) . Notably, self-consistency methods (Wang et al., 2023d) select answers from multiple reasoning paths by majority voting, have greatly elevated the performance of LLMs in complex reasoning. This approach has been further optimized by utilizing prompts with higher complexity (Fu et al., 2023c) . Lately, Yao et al. (2023a) employ heuristic-guided search on "trees" constructed from thoughts to assist LLMs in navigating the problem space.External Knowledge & Tool Utilization for LLM Reasoning. While LLMs exhibit significant capabilities, they are limited by a lack of real-world grounded experience (Petroni et al., 2020 ) and an inability to grasp complex arithmetic reasoning, given that their training is exclusively based on written text. Thus, researchers start utilizing external knowledge to assist models in accomplishing reasoning tasks (Nakano et al., 2022; Schick et al., 2023) . For enhanced factuality and faithfulness, He et al. (2022) and Wang et al. (2023b) make use of external knowledge bases. Lately, Gao et al. (2023) ensure the factual correctness and verifiability of generated text by providing cited passage.Another line is to delegate reasoning tasks to external tools (Qin et al., 2023) , which are commonly used for addressing numerical problems. One of the representatives is program-aided Language model (Gao et al., 2022) , known as PAL1 . Such an approach utilizes LLMs to interpret NL problems, generating programs as intermediate reasoning steps (Chen et al., 2022a) that will be offloaded to a Python interpreter for execution to get final solutions (Ni et al., 2023) . This method transforms reasoning into an NL2Code (Zan et al., 2023) task and has been demonstrated to excel when dealing with larger, non-integer numbers and enabling error corrections (Olausson et al., 2023) . Beyond synthesizing programs, Liu et al. (2023a) integrate a computational physics engine into the language modeling process for simulation. Moreover, Chameleon (Lu et al., 2023a) augments LLMs by incorporating both tools and knowledge resources like web engines and image captioners.Multi-Model Synergy for Task Solving. Utilizing multiple LLMs collectively to solve problems is still in its preliminary stages, with a wealth of opportunities awaiting exploration. The cornerstone of collaboration is constructing a human-like reasoning architecture (Zhu et al., 2023) for LLMs under different environments (Liu et al., 2023b) . Fu et al. (2023b) investigate whether multiple LLMs can autonomously enhance their performance through mutual interactions. Du et al. (2023) and Liang et al. (2023) explore enhancing the factuality of specific tasks, e.g., translation and arithmetic reasoning, by facilitating "debates" among multiple models. LLMs' collaboration has also been applied to software development (Qian et al., 2023 ) and text evaluation (Chan et al., 2023) by assigning identities to models to simulate the development process. Furthermore, from the perspective of social intelligence, inducing cognitive synergy and having them take on different characters (Wang et al., 2023e) during task execution has been proven to have significant potential (Sclar et al., 2023) . Recently, the nascent exploration into artificial societies (Park et al., 2023 ) also seeks to harness collective intelligence to emulate the efficiency of human social structures (Li et al., 2023a; Webb et al., 2023) . 
corex: 
 We introduce the three main components of Corex in this section, namely the Debate, Review, and Retrieve modes. Let us assume a set of LLM-based agents {A 1 , A 2 , . . . , A n } participating in multi-model collaboration. Each agent A i generates the corresponding reasoning chain c i and its prediction p i when facing a query q.In Debate mode, our agents are divided randomly into two groups, the Red Team and the Blue Team, with one reserved as a judge denoted as A j . The debate process within one team involves several rounds, limited to a maximum of T rounds of communications. In each round t (t = 1, 2, . . . , T ), the agents engage in iterative discussions2 to refine their reasoning chains and predictions. This dynamic interaction g, allows for the continual modification of viewpoints, as expressed byc t i = g(q, c t i-1 , . . . , c t i-k ) and predictions p t i .Each team then presents their refined predictions p t red and p t blue at the end of each round. If both teams consistently agree throughout the debate process, i.e., p t red = p t blue , the debate concludes smoothly. However, in the instance of a discrepancy between the teams' predictions, every output from each round is presented to the judge A j . The judge employs a decision-making process h, evaluating the quality and reliability of the reasoning chains and predictions from each round of the debate. The final conclusion is determined by h(c Diverging from previous works (Liang et al., 2023; Du et al., 2023; Xiong et al., 2023) , the debate mode of Corex adopts the concept of group discussions to enhance the factuality of reasoning chains.We opt not to facilitate models in jointly debating their reasoning processes to converge on a single common answer for several reasons: (1) The context length limitations inhibit the ability to fully hold the entire debate process, (2) Despite the tendency of debates to converge to single final answers, these outcomes are not always correct due to incorrect consensus or prevalent biases (Wang et al., 2023c) , (3) Given the performance gaps among various LLMs, there is a risk of strong models "monopolizing" the debate, thereby overshadowing the insights from others. Therefore, we aim to preserve both the factuality and the diversity of thoughts among agents and ensure stability throughout the debate process.Within the scope of reasoning, both CoT and PAL are effective methods with distinct strengths. Grounded in natural language, CoT-based methods stand out for the generality and the clarity of explanations. In contrast, facilitated by programs, PAL guarantees computational accuracy (Zhao et al., 2023b) . However, they both exhibit drawbacks due to the reliance on LLMs' internal representations. For CoT and its variants, issues are twofold: (1) Cumulative errors, where mistakes tend to amplify and propagate throughout the reasoning chain; and (2) A plateau in text quality that cannot be substantially improved through prompting (Xu et al., 2022; Li et al., 2023b) . Alternatively, PAL faces its own challenges: (1) LLMs might misinterpret questions, which inadvertently results in technically correct yet misguided programs; and (2) Generated codes are not always error-free: LLMs may potentially write buggy codes, such as referencing undefined variables or engaging in "Division by Zero" operations. Inspired by recent efforts of LLMs peerrating (Zheng et al., 2023b) and collaborative coding practices prevalent in software engineering, we introduce the Review mode to address the aforementioned issues through collaboration. To be specific, a single agent A p is randomly selected to act as the primary agent. Initially, A p takes the responsibility of formulating corresponding reasoning chains for q along with the prediction, and crafting codes if required. This initial collection of solutions is represented as S (0) p = {a p , c p , m p }, where a p , c p , and m p signify the answer, reasoning chain, and codes respectively. S (0) p is then subjected to iterative reviews by the other agents that function as reviewers in a sequential manner, rigorously scrutinizing both the reasoning chain and the code formulated by A p or modified by preceding reviewers. It is crucial to highlight that each reviewer receives input from its predecessors, signifying that each subsequent review is grounded on the outcomes and feedback of the preceding ones, fostering a progressively refined solution.The reviewing process is formalized asS (i+1) p = R i (S (i) p , F i ),where R i encapsulates the review outcome at the i th iteration and F i represents the feedback received. In essence, the solution set S (i+1) p results from an enhancement of its preceding version S (i) p , informed by the feedback F i . Following the completion of all review iterations, the outcome is determined by the final iteration of the solution set S (n-1) p . Specifically, the final prediction a (n-1) p is chosen as the answer for q, and in instances where code is involved, the last revised version m (n-1) p is executed by a Python interpreter to produce the outcome.In the final thread of work, we delve into the Retrieve mode to identify the most faithful answer through collaborations. While previous strategies based on majority voting mechanism (Wang et al., 2023d; Fu et al., 2023c) can mitigate the low-diversity issue of techniques such as beam-search (Li & Jurafsky, 2016) , they still present the following two significant challenges: The confidence scores are: [0.9, 0.2, 0.9, 0.1]. Agents 2, 4 made errors in their descriptions. Specifically, Agent 2 confused amino acids with saccharides, while Agent 4 incorrectly stated that saccharides bond to form polypeptides. In reality, saccharides bond to form polysaccharides. Thus, they are not faithful in their responses. Agents 1 and 3 are correct. (1) Correct answers risk being swayed by incorrect ones. (2) Despite facilitating a notable enhancement in performance, it exponentially escalates the computational burden and tends to reach a performance "saturation point" as the sampled chains increase. We attribute these drawbacks to the limited scope of majority voting techniques that singularly prioritize the prediction while overlooking the faithfulness of reasoning chains (Li et al., 2023c) .In response, we propose the Retrieve mode, a paradigm specifically engineered to evaluate whether the answer can be expressed by the content (explanation) generated during reasoning (Jacovi & Goldberg, 2020; Lanham et al., 2023) .Concretely, given a query q, we randomly select an agent A r from the pool of n agents to act as the retriever. The remaining agents {A 1 , A 2 , . . . , A n-1 } independently perform CoT reasoning about q. Each of these agents derives its own reasoning chains c i and corresponding predictions p i . Together, they form a candidate pool, denoted by P = {(c i , p i )}The retriever A r then scrutinizes the candidates in P. For (c i , p i ), A r evaluates the faithfulness between c i and p i . Based on this assessment, the retriever assigns a confidence score s i in the range [0, 1], which is denoted as: s i = f r (c i , p i ) where f r indicates the retriever's evaluation process. After that, the most faithful response to the question q is then determined by the highest confidence:(c * , p * ) = argmax (c i ,p i )∈P s iHere, (c * , p * ) denotes the chain-prediction pair that the retriever considers most faithful, which will serve as the final answer for the query q.Retrieve mode enables the selection of the most aligned combination of reasoning chains and answers from a diversified candidate pool. Distinct from previous text quality assessment methods, which rely on the log probability of sequences (Adiwardana et al., 2020) that is computationally inefficient and often unavailable for commercial LLMs, our approach is entirely predicated on model-to-model interactions (Chen et al., 2023) and is reference-free. 
experimental setup: 
 Tasks and Datasets. We evaluate the effectiveness of Corex across four types of reasoning tasks:(1) Arithmetic reasoning over eight mathematical problems, which includes GSM8K (Cobbe et al., 2021) , MultiArith (Roy & Roth, 2015) , SingleOP/SingleEQ (Koncel-Kedziorski et al., 2016) , AddSub (Hosseini et al., 2014) , AQuA (Ling et al., 2017) , SVAMP (Patel et al., 2021) and GSM-Hard (Gao et al., 2022) . ( 2) Commonsense reasoning covering four datasets, including Strate-gyQA (Geva et al., 2021) , CommonsenseQA (CSQA; Talmor et al., 2019) , BoolQ (Clark et al., 2019) and AI2 Reasoning Challenge (ARC-c) (Clark et al., 2018) 4) Semi-structured understanding, with a focus on FinQA (Chen et al., 2021b) , ConvFinQA (Chen et al., 2022b) and TAT-QA (Zhu et al., 2021) . The detailed description and statistics of tasks are listed in Appendix D.Baselines. We compare our method with several widely used strong baselines. (1) Chain-of-Thought prompting (CoT; Wei et al., 2022b) . (2) Self-Consistency (CoT-SC; Wang et al., 2023d) , which employs a majority voting mechanism to select the most consistent answer from several reasoning chains as the final answer. (3) Complexity-based consistency (ComplexCoT; Fu et al., 2023c ) that selects the majority answer from the candidates with higher reasoning complexity. (4) Program-aided language model (PAL; Gao et al., 2022; Chen et al., 2022a ) that uses LLMs to generate programs as intermediate reasoning steps, while offloading the computation to a Python interpreter.For simplicity and ease of understanding, we denote CoT-SC(x) and ComplexCoT(x) in our experiments and analysis to represent cases utilizing different reasoning paths, where "x" indicates the number of output chains. For all baseline methods, we adhere to the few-shot exemplars to ensure fair comparisons. Details can be found in Appendix B.Implementation Details. We access OpenAI and Anthropic models through their respective APIs. Specifically, we employ GPT-3.5-Turbo-0613 for evaluating both Corex and baseline methods in the main experiments. Moreover, in further experiments and analysis involving different LLMs for collaboration, we also incorporate the use of GPT-4-0613 and Claude-Instant-1.2. The details of prompts and hyperparameter settings for both baselines and Corex are in Appendix F.We report the results of Corex over four categories of tasks. For each kind of task, the best results are highlighted in bold and the second best results are marked with underline. For Review mode, we use Corex-Review NL and Corex-Review Code to describe the scenarios that use CoT or PAL respectively. All modes within Corex are configured to operate with 5 LLM-based agents, ensuring favorable cost-effectiveness. For Corex-Debate, the upper bound of debate rounds is set to 5. Mathematical Reasoning. Table 2 shows the results across arithmetic tasks with varying difficulties. Our method achieves notable performance improvements on most benchmarks.Broadly, we surpass the performance of CoT-SC(10) when only 5 agents are involved. Moreover, given the task-agnostic nature of Corex, it can tackle highly complex computational challenges like GSM-Hard through code synthesis. For problems of relatively lower complexity, the Retrieve mode can identify answers superior to those from majority voting. Commonsense Reasoning. Table 3 showcases the performance of Corex in commonsense and factual reasoning tasks3 . We can observe that various modes contribute to performance enhancements. Semi-structured Reasoning. We demonstrate the results on FinQA and ConvFinQA in Table 5. It can be observed that for these two challenging tasks which require understanding heterogeneous information and performing calculations simultaneously (Lu et al., 2023b) , methods such as CoT-SC offer limited gains. However, through various cooperative paradigms, significant performance improvements can be achieved. Due to the context length restriction of GPT-3.5-Turbo, our experiments on TAT-QA utilized GPT-3.5-Turbo-16k, with the respective results being detailed in Appendix C.1, alongside the evaluations on the other tasks. Following our extensive experiments across 18 tasks, it emerges that the Debate mode is competent for tasks utilizing factual knowledge. For mathematical and counting tasks, the Review mode serves to effectively mitigate errors within the reasoning chains and repair flawed code. Across various tasks, the Retrieve mode consistently facilitates performance improvements to varying degrees. 
analysis: 
 In this section, we first aim to make the collaboration process transparent by delving into models' internal behaviors. Then, the influence of different backbones is examined to observe how model capability affects performance. Further, we assess the efficiency of Corex.Analysis of Interaction Rounds in Debate Mode. We study the number of rounds of communication in the Debate mode of Corex on five tasks, as depicted in Figure 6 . Consensus can be reached swiftly for the majority of problems by each team. However, Corex enables LLMs to engage in more exhaustive discussions for problems that are challenging to reach a consensus on (e.g., over 10% of ConvFinQA problems requiring more than 3 rounds), a small proportion of problems require more interactions. Through observation, we also notice that the Debate mode exhibits favorable convergence properties, wherein the interactive process serves as a basis for the judge's decision-making. Performance Enhancement per Review. We explore the incremental performance gains achieved in specific tasks with each review cycle in the Review mode. As is demonstrated in Figure 7 , we conduct analyses for Repeat Copy and GSM8K with Review Code , as long as BoolQ and Penguin with Review NL . The findings indicate that each review contributes to performance enhancement in general, yet occasional deviations leading to performance oscillations are also observed.Performance Variability with Diverse LLMs as Judges. The backbone LLMs of our agents can be diverse. In this part, we discuss the performance variations when employing different LLMs during the debate process. As shown in Figure 8 , we deploy GPT-3.5-Turbo as debaters and examine the dynamics when different LLMs take the role of judges. The observations indicate that the capability of the judge positively correlates with task performance, with this relationship being evident as the complexity of tasks escalates. Empirically, This can be attributed to the judge's role in the debate process, which requires understanding both the question and the reasoning process of both parties.Utilizing Different LLMs as Retrievers. In Retrieve Mode, the role of the retriever can be played by various LLMs. Based on the candidate answers from GPT-3.5-Turbo agents, we here explore the impact of model selection on the performance, as depicted in Figure 9 . Unlike the debate mode, our analysis reveals that the model capabilities exert a modest effect on the performance. Given that the performance upper bound is determined by the candidates' capabilities, the outcomes using different LLMs as retrievers show minimal variance on tasks like ARC-c. Notably, our findings indicate that without the need for especially potent models as retrievers, we can still achieve favorable results.By encouraging collaboration between LLMs, we manage to reduce the costs associated with reasoning tasks while achieving comparable or even superior performance. Figure 10: Cost-effectiveness analysis. the x-axis represents the computational costs, calculated in terms of input/output tokens, while the size of each dot is proportional to the avg. number of inferences by each method.Based on our analysis conducted on AddSub illustrated in Figure 10 , it reveals that all three modes of Corex consistently match or surpass the prowess of other strong baselines. Significantly, the computational cost of our approach are substantially diminished in comparison to methods using majority voting. In achieving equivalent performance, the resource consumption of Corex is confined to a mere 5-10% of that expended by other strategies. To substantiate the generality, we've provided additional experiments in Appendix C.2, which further demonstrate a similar trend.Beyond the efficiency of computational costs, another advantage of Corex is its annotation efficiency, which reduces the reliance on curated demonstrations. Further experiments with varying numbers of demonstrations on this aspect can be found in Appendix C.3. 
conclusion: 
 We introduce Corex in this paper, a suite of strategies that transform LLMs into autonomous agents, thereby leveraging multi-model collaboration for complex reasoning. This offers a preliminary exploration into the LLM-based multi-model ecosystems. Through unlocking the synergies among LLMs, Corex empowers reasoning with enhanced factuality, faithfulness, and reliability through various collaboration paradigms. We conduct extensive evaluations across 18 tasks within 4 categories, and the results demonstrate superior performance compared to previous solutions. Moreover, our methods also exhibit multiple notable advantages including being task-agnostic, cost-effective, and annotation-efficient. We hope that this work may serve as a foundation for further research, offering novel perspectives in complex reasoning, collective intelligence, and autonomous agents. 
 
 Appendix: Considering performance constraints, open-source models were not incorporated in this study. However, we hold the view that the collaboration of several relatively weaker open-source models (Zhang et al., 2022; Touvron et al., 2023) might enable them to conquer tasks that only stronger commercial models (Bai et al., 2022; OpenAI, 2023) could previously accomplish. Since we have empirically demonstrated that model collaboration can help reduce redundant computations and resource usage, it is foreseeable that the efficiency can be further accentuated when integrating open-source models into the collaboration framework, making the development of general artificial intelligence more sustainable (Hessenthaler et al., 2022) . Also, this may enhance the diversity to address the issues of biases and misconceptions inherent to a single model (Sun et al., 2022; Shaikh et al., 2023) can be mitigated, promoting the fairness of future AI systems (Hendrycks et al., 2021) .At the same time, we also observe the emergence of instability when integrating the functions of multiple LLMs. This highlights the need for better strategies to orchestrate the interaction among models with unique attributes and capabilities (Parsons & McBurney, 2003; Dorri et al., 2018) , which we identified as a pivotal direction for future research.LLMs Settings and Prompts. We access OpenAI and Anthropic models through their respective paid APIs. Specifically, we utilize two versions of the OpenAI models: GPT-3.5-Turbo-0613 and GPT-4-0613, as well as Claude-Instant-1.2 from Anthropic. Following the settings of previous works, the temperature is set as 0 during the generation process.As for the prompts, we maintain the same number of exemplars per task as established by previous studies. The details and examples of prompts are listed in Appendix F. Regarding the complexitybased prompting baseline, we directly utilize the prompts provided by Fu et al. (2023a) .Evaluation. We use accuracy to evaluate the tasks of arithmetic reasoning, commonsense reasoning, and Symbolic reasoning. For semi-structured understanding, we employ the official evaluation scripts released along with the literature for FinQA (Chen et al., 2021b) and ConvFinQA (Chen et al., 2022b) , as well as employing the same test split as in Chen et al. (2022a) . For TAT-QA (Zhu et al., 2021) , we utilize the arithmetic part to enable the simultaneous use of both CoT-based methods and PAL. Among all the evaluations involve Corex-Debate, the upper bound of rounds is set as 5.In the analysis part, due to the rate limits imposed and a restricted budget, we set an upper limit for our sample size. Consequently, each analysis is based on a maximum of 500 samples per run.We draw upon the design of the self-consistency baseline as delineated by Wu et al. (2023) , and partially refer to the benchmarking provided by Wang et al. (2023a) .PAL Details. We use Python 3.9.12 to execute the generated program by PAL in Review mode, following the similar settings from Gao et al. (2022) and Chen et al. (2022a) . Unlike Code-davinci-002 (Chen et al., 2021a) employed in these works, GPT-3.5-Turbo is not optimized for generating programs, so we might anticipate a compromise in performance when using GPT-3.5-Turbo as the backbone model.As is mentioned in section 4.2, due to the constraint of context length, we conduct experiments on the TAT-QA dataset with GPT-3.5-Turbo-16k along with other two tasks. For all computations related to cost-effectiveness, we define cost as the sum of: tokens of few-shot exemplars, query tokens, and output tokens. Here we conduct additional cost-effectiveness analysis on the ARC-c dataset and Penguins dataset, as shown in Figure 11 and Figure 12 . The x-axis represents the computational costs, calculated in terms of input/output tokens, while the size of each dot is proportional to the avg. number of inferences by each method.Due to the scarcity and instability of curated prompts (Ye & Durrett, 2022) , we aim to mitigate reliance on them through multi-model collaboration. We conduct experiments in scenarios with varying numbers of demonstrations to assess the effectiveness of our approach. As depicted in Figure 13 and Figure 14 , we demonstrate the performance of the Review mode and Retrieve mode under different shots. The results reveal a marginal impact of the number of few-shot examples on performance, underscoring the annotation efficiency of our approach.The detailed information of each dataset is shown in the follow:• Grade School Math (GSM8K; Cobbe et al., 2021) : Linguistically diverse grade school math word problems created by human problem writers. The problems take between 2 and 8 steps to solve and involve elementary calculations using basic arithmetic operations. • AddSub (Hosseini et al., 2014) : A set of simple arithmetic word problems.• SVAMP (Patel et al., 2021) : A challenge set for elementary-level Math Word Problems.• SingleOP, SingleEQ and MultiArith (Koncel-Kedziorski et al., 2016) : Grade-school math dataset that aims at solving multi-sentence algebraic word problems. • GSM-Hard (Gao et al., 2022) : A harder version of the GSM8K dataset, constructed by replacing the numbers in the questions of GSM8K with larger numbers.• CommonsenseQA (CSQA; Talmor et al., 2019) : CSQA is a multiple-choice question answering task. It requires complex semantic reasoning based on prior commonsense knowledge to answer the questions. • StrategyQA (Geva et al., 2021) : It is a commonsense QA task with Yes or No answer format that requires models to perform multi-hop reasoning to answer the questions. We use the open-domain setting (question-only set) from bench authors (2023).Table 7 : Examples from mathematical reasoning datasets used in this work.GSM8K (Cobbe et al., 2021) 1,319 A robe takes 2 bolts of blue fiber and half that much white fiber. How many bolts in total does it take? GSM-Hard (Gao et al., 2022) 1,319 A robe takes 2287720 bolts of blue fiber and half that much white fiber. How many bolts in total does it take? SVAMP (Patel et al., 2021) 1,000 Each pack of dvds costs 76 dollars. If there is a discount of 25 dollars on each pack. How much do you have to pay to buy each pack? SINGLEOP (Koncel-Kedziorski et al., 2016) 562 If there are 7 bottle caps in a box and Linda puts 7 more bottle caps inside, how many bottle caps are in the box? SINGLEEQ (Koncel-Kedziorski et al., 2016) 508 Benny bought a soft drink for 2 dollars and 5 candy bars. He spent a total of 27 dollars. How much did each candy bar cost? AddSub (Hosseini et al., 2014) 395 There were 6 roses in the vase. Mary cut some roses from her flower garden. There are now 16 roses in the vase. How many roses did she cut? MultiArith (Roy & Roth, 2015) 600 The school cafeteria ordered 42 red apples and 7 green apples for students lunches. But, if only 9 students wanted fruit, how many extra did the cafeteria end up with?• OpenBookQA (Mihaylov et al., 2018) : It is a multi-choice QA task to evaluate commonsense knowledge and promote reasoning over a fixed collection of knowledge.• ARC-c (Clark et al., 2018) : A subset of the AI2 Reasoning Challenge, consisting of challenging science questions that require reasoning and a wide breadth of knowledge to answer the multiple-choice problems correctly. The original dataset is from https: //allenai.org/data/arc.• BoolQ (Clark et al., 2019) : It is a knowledge-intensive task and the format is "Yes" or "No". Problems are extracted from real-world internet queries, aiming to foster models capable of contextual understanding to provide binary answers. that much white fiber. How many bolts in total does it take? OpenBookQA (Mihaylov et al., 2018) 500 In which location would a groundhog hide from a wolf? ARC-c (Clark et al., 2018) 1,172 An astronomer observes that a planet rotates faster after a meteorite impact. Which is the most likely effect of this increase in rotation? BoolQ (Clark et al., 2019) 3,270 A robe takes 2 bolts of blue fiber and half that much white fiber. How many bolts in total does it take?Symbolic Reasoning We select the following tasks from BIG-Bench (bench authors, 2023) and BIG-Bench Hard (BBH) (Suzgun et al., 2023) , with Apache License v.2: https://github.com/ google/BIG-bench/blob/main/LICENSE.• Date Understanding: A temporal reasoning task. Given a set of sentences about a particular date, answer the provided question in MM/DD/YYYY format. • Object Counting: Given a collection of possessions that a person has along with their quantities (e.g., three pianos, two strawberries, one table, and two watermelons), determine the number of a certain object/item class (e.g., fruits). • Penguins in a Table: Given a unique table of penguins (and sometimes some new information), answer a question about the attributes of the penguins. • Reasoning about Colored Objects: Given a context, answer a simple question about the color of an object on a surface. • Repeat Copy: Evaluate LLMs' capability to follow basic natural-language instructions nested within each example's input. Semi-structured Understanding• FinQA (Chen et al., 2021b) : Question-Answering pairs over financial reports written by experts, which includes financial QA pairs. • ConvFinQA (Chen et al., 2022b) : A financial-related dataset designed to study the chain of numerical reasoning in conversational QA. • TAT-QA (Zhu et al., 2021) : A QA dataset aiming to stimulate the progress of research over more complex and realistic tabular and textual data.We have prepared case studies to provide a more intuitive understanding of the three collaboration paradigms. The cases are presented in Table 11 , Table 12 , and Table 13 , each corresponding to a specific collaboration paradigm. Owing to space constraints and in an effort to maintain a reasonable length for this paper, we present one exemplar of the prompts for each task in this section, as well as the system messages for collaboration. Our full prompts and formulations can be accessed in our attached code repository. Angelo and Melanie think they should dedicate 3 hours to each of the 2 chapters, 3 hours x 2 chapters = 6 hours total.For the worksheets they plan to dedicate 1.5 hours for each worksheet, 1.5 hours x 4 worksheets = 6 hours total. Angelo and Melanie need to start with planning 12 hours to study, at 4 hours a day, 12 / 4 = 3 days. However, they need to include time for breaks and lunch. Every hour they want to include a 10-minute break, so 12 total hours x 10 minutes = 120 extra minutes for breaks. They also want to include 3 10-minute snack breaks, 3 x 10 minutes = 30 minutes. And they want to include 30 minutes for lunch each day, so 120 minutes for breaks + 30 minutes for snack breaks + 30 minutes for lunch = 180 minutes, or 180 / 60 minutes per hour = 3 extra hours. So Angelo and Melanie want to plan 12 hours to study + 3 hours of breaks = 15 hours total.They want to study no more than 4 hours each day, 15 hours / 4 hours each day = 3.75 They will need to plan to study 4 days to allow for all the time they need. So the answer is 4. COLORED OBJECTS: NL PROMPTS Q: On the nightstand, there is a red pencil, a purple mug, a burgundy keychain, a fuchsia teddy bear, a black plate, and a blue stress ball. What color is the stress ball? Options: (A) red (B) orange (C) yellow (D) green (E) blue (F) brown (G) magenta (H) fuchsia (I) mauve (J) teal (K) turquoise (L) burgundy (M) silver (N) gold (O) black (P) grey (Q) purple (R) pink A: Let's think step by step.According to this question, the color of the stress ball is blue. So the answer is (E).COLORED OBJECTS: PAL PROMPTS Q: On the nightstand, there is a red pencil, a purple mug, a burgundy keychain, a fuchsia teddy bear, a black plate, and a blue stress ball. What color is the stress ball?# Generate Python3 Code to solve problems # Q: On the nightstand, there is a red pencil, a purple mug, a burgundy keychain, a fuchsia teddy bear, a black plate, and a blue stress ball. What color is the stress ball? CoT-SC and PAL, 3-shots are adopted for both tasks.OBJECT COUNTING: NL PROMPTS Q: I have a blackberry, a clarinet, a nectarine, a plum, a strawberry, a banana, a flute, an orange, and a violin. How many fruits do I have? A: Let's think step by step.We first identify the fruits on the list and include their quantity in parentheses:-blackberry (1) -nectarine (1) -plum (1) -strawberry (1) -banana (1) -orange (1) Now, let's add the numbers in parentheses: 1 + 1 + 1 + 1 + 1 + 1 = 6. So the answer is 6.OBJECT COUNTING: PAL PROMPTS Q: I have a peach, an onion, two garlics, a nectarine, a yam, a carrot, a potato, a head of broccoli, a cabbage, a banana, and a stalk of celery. How many vegetables do I have?# solution using Python: def solution(): """Q: I have a raspberry, a cat, a rabbit, a mouse, a pig, two snails, a fish, two cows, a snake, a goat, and a duck. How many animals do I have? ↪ ↪ """ # note: I'm not counting the raspberry as an animal animals_to_count = { 'cat': 1, 'rabbit': 1, 'mouse': 1, 'pig': 1, 'snail': 2, 'fish': 1, 'cow': 2, 'snake': 1, 'goat': 1, 'duck': 1 } num_animals = sum(animals_to_count.values()) return num_animals REPEAT COPY: NL PROMPTS Q: Q: say java twice and data once, and then repeat all of this three times. A: Let's think step by step. java java data java java data java java data REPEAT COPY: PAL PROMPTS Q: say java twice and data once, and then repeat all of this three times.# solution using Python: def solution():"""Q: say java twice and data once, and then repeat all of this three times.""" ↪ result = [] tmp = ["java", "java", "data"] for i in range(3): result.extend(tmp) return " ".join(result) The idea of integrating LLMs with external PL interface was proposed byGao et al. (2022) andChen et al. (2022a) within the same timeframe. We refer to this approach as "PAL" in this paper.Due to the context length limit of GPT-3.5-Turbo, only information from the previous round is stored during the debate process.Due to the nature of commonsense reasoning tasks, the Review mode only utilizes NL reasoning chains. 


Decision: Summary:
The paper presents Corex, which targets the improvement of Large Language Models' (LLMs) reasoning abilities by turning them into collaborative autonomous agents using human-inspired strategies like Discuss, Review, and Retrieve modes.
Overall the authors are willing to make adjustments to presentations about multi-agent instead of multi-model, add more open-source model experiments, and parallels between this approach to self-consistency, self-refine, CoT etc.,.

Pros:
1. The paper introduces Corex, a novel method that utilizes multimodal collaboration to tackle complex reasoning tasks through three distinct, human-inspired modes, each designed to overcome the limitations of individual LLMs and achieve competitive results across various benchmarks.
2. Thorough experimentation on 18 different reasoning tasks demonstrating that one of the modes from the proposed Corex model performs better than competitive baselines at least. The authors made the data and the benchmark available.
3. I believe that the cost-effectiveness aspect appears promising. 

Cons:
1. The intuition behind why the different modes are effective and the justification for their specific setups seem somewhat unclear. It appears that no single mode consistently outperforms all benchmarks within the broader reasoning category, thereby making it unintuitive as to which Corex mode to choose for a new task. This is not adequately answered in the rebuttal directly but the authors promise to add relevant information in the paper.
2. There seems to be minimal exploration with open-source models. Incorporating outcomes from open-source LLMs such as Llama3 and Mistral could yield richer insights for the wider community. (as also pointed out by the reviewer LnBc). The authors promise to add these results in the paper.

Originality:
1. The authors offer a novel technique to boost the complex reasoning skills of LLMs. They outline three separate methods: Discuss, Review, and Retrieve, each driven by different motivations and designed to tackle the weaknesses of existing methods.
2. Feedback about a discussion/empirical comparison with SC, SR, CoT would differentiate this work from prior work for originality

Significance:
1. The proposed Corex method demonstrates improved or competitive performance by using fewer tokens, leading to reduced costs.
2. This work has a strong potential impact on the active area of research involving LLM agents collaborating in multi-model settings.

[comments from PCs] Please follow up on the AC recommendations, especially as far as exploring open-weight/open-source models.

Reviews: review: paper_summary: paper_summary: This submission introduces Corex which aims to improve the reasoning of LLMs using multi-model collaboration. In order to solve complex reasoning tasks, Corex uses LLM-based agents collaborating with each other in different modes to find the best solution. The different modes are inspired by how humans work together and collaborate to solve problems. 

In terms of quality, clarity, originality and significance of this work:
- The paper is well written and high quality. The experiments are thorough as they have investigated the performance of Corex on 18 different reasoning benchmarks and results seem to show that at least one of the Corex modes performs better than other baselines. 
- In terms of clarity, the paper is overall clear, though there are parts which can be clarified  more (see section about questions below). 
- The technical content is original, where the authors propose a new approach to improve complex reasoning capabilities of LLMs. The authors propose 3 different ways: Discuss, Review and Retrieve. Each of these methods have different motivations and attempts to address limitations of previous approaches. 
- The method shows better/competitive performance in terms of number of tokens used which directly translate to reduced cost, which is an important consideration. There is also another angle of LLM agents engaged in multi-model collaboration which is an interesting and actively area of exploration.
strength_weakness: strength_weakness: 1. From the main results in section 4, it seems that there’s no clear mode that wins all benchmarks within a bigger reasoning bucket (out of the 4 categories experimented). For a new benchmark or a new production usecase, it seems unclear which mode of Corex would a user of this method use and why.  

2. I think there’s somewhat unclear intuition on why the different modes are working well and justification for the exact setup for a given mode. For instance, I wonder why “discuss” mode has only 2 teams, green and blue? Did the authors experiment / think about k groups?  Same for “review” mode, rationale for one agent to be a primary one seems arbitrary. 

3. [Minor] Beyond the results from Appendix section C, it seems to be that there’s missing experimentation around open source models. Adding results from open source LLMs like Llama3, Mistral, etc would be even more informative for the broader community.
questions: questions: See suggestions / questions: 

- [Typo] In section 1, “In this study, we propose Corex, a suite of human-inspired strategies that leveraging” -> leverages
- In section 1, “Additionally, Corex reduces the reasoning overheads, achieving multifaceted cost-effectiveness.”: What is the “multi-faceted” aspect? 
- In several parts of the manuscript, the authors talk about “reasoning chain”. It would be great to provide a definition and/or example of that somewhere. I believe they are referring to the explanation of the answer of a given reasoning prompt?
- In section 3.1 when the authors talk about the “Discuss” mode, they mention: 
```
We opt not to facilitate models in jointly exchanging their reasoning processes to converge on a single common answer for several reasons: (1) The limited context length inhibits the ability to hold the communication process, (2) A single final answer is not always correct, as erroneous consensus or biases among models can occur (Wang et al., 2023c), (3) Given performance gaps among various LLMs, there is a risk of strong ones “monopolizing” the collaborations, thereby overshadowing the insights from others
```
However, even with the green and blue team I'm not sure how the 3rd limitation is addressed. Moreover, since the experimentation has been around GPT-3.5-Turbo where information from only previous rounds is stored (from footnote 1), I believe limitation 1 above is also not handled? 
- In the “Discuss” mode of Corex, have the authors experimented with k teams instead of 2?
- For the “Review” mode of Corex, have the authors considered also adding the execution signal of the code snippet in addition to a_p, c_p and m_p? It seems that they execute the final revised version. Maybe an intermediate signal of code execution would help?
- [Broader / aspirational] Have the authors thought about a generalizable framework where the choice among the 3 strategies of Corex can be task specific (and potentially agnostic to the user)? 
- In section 3.3 which discusses the “Retrieve” mode: “...evaluates the faithfulness between ci and pi . Based on this assessment, the retriever assigns a” -> how? 
- [Table 1] It is surprising to see code version performing worse than retrieve for some of the benchmarks. 
- Do we have any intuition on why this is the case?
- Probably minor, but Figure 2 isn’t very clear. The change between R1 and R2 values isn't clear.
- I like figure 8. I wonder what the results look like for other benchmarks, maybe not for all 18 benchmarks, but at least one of each 4 categories?
paper_summary: paper_summary: This paper proposes a framework for improving LLM reasoning via multi-agent collaboration. 
1. By prompting an existing LLM to take on different agent roles and have them collaborate in different patterns (i.e., Discuss, Review, and Retrieve), the paper shows empirically that it can lead to improved accuracy on 18 reasoning tasks among 4 categories. 
2. The paper shows the effectiveness of their proposed agent collaboration strategy by comparing against existing model collaboration methods, and ablates the impact of using different LLMs for different agents in the collaboration.
strength_weakness: strength_weakness: 1. The novelty of the method contribution is not established. The key method of this paper is the agent collaboration approach, i.e., Discuss, Review, and Retrieve. These individual components are somewhat covered in the prior work (see below), and for most of the evaluation in the paper, these components are used separately (see from table 1 to 5). For example:
    - `Retrieve` seems to be similar to the self-consistency (SC) approach, in essence that both approaches sample multiple generations and coalesce the candidates with some mechanism. SC uses the model scoring while “Retrieve” uses models’ explicit judgment over the generations. It is also similar to DsPY’s demonstrate-and-search method. 
    - `Review` reminds me of the self-refinement approach, whereas both of them iteratively use the LM to generate feedback to the generation and improve the output. 
    - `Discuss` may feel like a combination of “longer” chain-of-thought plus self-refinement. 
    - The authors claim to assign different personas (page 2) to the agents – that might be an interesting distinction from the proposed approach against existing methods – but that seems not to be the focus of the paper. 
    - What are other potential patterns for collaboration and why are the three components chosen in this paper? For example, delegation is a common pattern in human collaboration and one could imagine using different agents to take on different parts of the task.
2. The empirical results are somewhat mixed. From table 1 to 5, 
    - Often there is a baseline method that can achieve somewhat similar performance (within 1 or 2 points of absolute difference) to the proposed method. It would be helpful to provide standard errors in the evaluation so we can better understand if there’s a meaningful difference. 
    - It’s unclear which of the collaboration strategies is optimal from the results. Sometimes there is high variance among the methods (see GSM-hard in table 1, Repeat Copy in table 3). And in such cases, the best proposed collaboration method achieves somewhat similar performance to one of the best performing baselines. 
    - It would be interesting to see results on harder reasoning tasks like MATH, GPQA, as well as MMLU. 
3. In terms of the scoping, I think this paper focuses a bit more on “multi-agent” collaboration than “multi-model” collaboration. If I understand correctly, in the main paper, the primary experiments are done via prompting one LLM for different agents, and the multi-model collaboration only happens at section 5.2 & 5.3, more of an ablation study rather than the main findings. If that’s the case, I suggest changing the “multi-model” in the title to “multi-agent” or change the presentation of the results for this paper.
questions: questions: 1. In terms of figure 8, please clarify the following:
    - I think “X-axis repre- sents the computational costs, calculated in terms of input/output tokens” is somewhat vague: is that the lump sum of the total input and output tokens for all the model calls during the course? If there’s a shared prefix among multiple calls, would that be discounted in the computation? Also token counts can only approximate the total computational cost: the computational cost for input/output tokens are different. It would be great if you can provide further breakdown in terms of the total input/output tokens. 
    - What do you mean by “the size of each dot is proportional to the avg. number of inferences.”? Do you mean total # of calls the LLMs? 
    - Can you provide a legend for the size of the bubbles? 
2. Missing references and comparison, for example:
    - Self-Refine: Iterative Refinement with Self-Feedback
    - DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines
paper_summary: paper_summary: This paper introduces Corex, a suite of strategies that transform large language models into autonomous agents to enhance reasoning. Corex includes modes like Discuss, Review, and Retrieve, fostering collaboration among models. Through experiments across various reasoning tasks, Corex outperforms existing approaches, showcasing its effectiveness and potential for advancing artificial intelligence in natural language processing and complicated task-solving.
strength_weakness: strength_weakness: - Some method lacks novelty or lacks the authors' clarifications of difference compared with the existing methods. For example, what are the differences between Corex-discussion and multi-agent debate? What are the differences between Corex-review with self-reflection or self-debug?
- Similar to the above bullet, the paper also lacks comparison with additional baselines, including multi-agent debate, self-reflexion, self-debug, retrieval-augmented generation. These single model or single agent method might have better performance than multi-agent framework.
- The method relies heavily on the interactions between multiple LLM agents. From my perspective, the conclusions made from the discussion between LLMs are not always reliable, as LLM agents have the tendency to trust the other LLMs' suggestions, making it easy for them to change their own answers. Do the authors have some unique design to guarantee the quality of interactions?
paper_summary: paper_summary: The paper introduces Corex, aimed at enhancing the reasoning capabilities of Large Language Models (LLMs). Corex transforms LLMs into autonomous agents that collaborate through strategies inspired by human behavior, including Discuss, Review, and Retrieve modes. 

Extensive experiments across diverse reasoning tasks demonstrate Corex's superior performance, highlighting its ability to overcome common errors and provide improved solutions. 

The study emphasizes Corex's cost-effectiveness, the synergies between models of varying scales, and its contribution to annotation efficiency.
strength_weakness: strength_weakness: More multi-agent baselines can be added. For example, Du et al. (2023) and Liang et al. (2023) suggest two multi-agent debate frameworks with 3 agents, which bear similarities to your Discuss mode. From the comparison of Corex-discuss and these baselines, we can gain more insight about the impact of agent quantity on the system's performance.

References:

[1] Du et al. Improving Factuality and Reasoning in Language Models through Multiagent Debate. https://arxiv.org/abs/2305.14325

[2] Liang et al. Encouraging Divergent Thinking in Large Language Models through Multi-Agent Debate. https://arxiv.org/abs/2305.19118
questions: questions: - It's unclear how well the Discuss, Review and Retrieve paradigms would scale to slightly larger numbers of agents (e.g., 8 agents).

- Is there potential for combining different modes to further enhance performance? For instance, within the Discuss mode, teams could engage in reviewing each other's solutions (in Review mode), potentially leading to refined iterations of their initial proposals. This integration could leverage the strengths of both modes to achieve superior outcomes.

Comments: title: Response from authors
Thank you for the rebuttal!
Reviewer Response
Further responses from the authors
Reviewer Response
comment: Thank you for your response! As we mentioned in our reply to LnBc, the current version only provides a brief analysis due to page limits. In the revision, we will add more details, such as visualizing the "win rates" of different modes across various task types.

Thank you again for your insightful suggestions.
Thanks for the rebuttal and clarification! I like this paper in general, but I share some similar concerns as LnBc: 

> From the main results in section 4, it seems that there’s no clear mode that wins all benchmarks within a bigger reasoning bucket (out of the 4 categories experimented). For a new benchmark or a new production usecase, it seems unclear which mode of Corex would a user of this method use and why.

Would love to see your revision and detailed analysis!
Thanks for clarifying and taking the time to respond!
Thanks for your effort in clarifying my previous questions. I decide to maintain my original score which is already in favor of clear acceptance.
Thank you very much for your reply! We apologize for any confusion caused by compressing our answers due to the rebuttal's character limit.

> Evaluate the faithfulness

Sorry for not explaining this clearly in the text. "Assign" is a process of LLM-based evaluation. The Retriever is instructed to evaluate candidates' answers by considering the faithfulness between the reasoning process and their answers. Here, we use definition of faithfulness: “if the reasoning process derived from the model can accurately be expressed by an explanation, we call it faithful.”[1,2] 

It is essentially an LLM evaluating the generated content of other LLMs. We will further clarify these details in the revision.

[1] Faithful Chain-of-Thought Reasoning IJCNLP-AACL 2023

[2] Towards Faithfully Interpretable NLP Systems: How Should We Define and Evaluate Faithfulness? ACL 2020


> Similar Cost-effective Experiments on Other Benchmarks 

Yes, the main paper presents AddSub as a mathematical task. In Appendix D.3, we presented results for ARC-c and Penguins, which correspond to commonsense and symbolic tasks, respectively. Due to the high testing costs for TableQA-type tasks, we currently have not conducted those experiments. We will try to include these in the revision.

> "Multiple Attempts" 

We agree that execution signals and error feedback would improve the overall review process. In real-world scenarios, this would enhance the effectiveness of the entire system. In the rebuttal, our reference to "multiple attempts" means that in general reasoning tasks, errors such as (I) code execution failures or (II) code execution correctness but incorrect answers are both counted as errors. Therefore, for evaluating reasoning tasks, if execution feedback is provided in each round, it validates whether type I errors occur in every review. Compared to methods like PAL/PoT, incorporating execution signals provides additional "verification" opportunities.

Once again, thank you for your feedback!
Thanks for your response.

I think i didn't get the answer to my question earlier:
> In section 3.3 which discusses the “Retrieve” mode: “...evaluates the faithfulness between ci and pi . Based on this assessment, the retriever assigns a” -> how?

Re: Similar exps. on other benchs are provided in D.3. 
Those seem to be not for all the 4 categories right? 

Re: We think this is a great idea, but it will allow multiple attempts that might indirectly compromise the fairness of exps. 
I don't think there are any "multiple attempts" in here. I'm basically saying that the execution signal / error would help the overall review process.
Thanks for your effort in responding to my previous questions. I have increased my score accordingly. Cheers and good luck!