CoReaAgents: A Collaboration and Reasoning Framework Based on LLM-Powered Agents for Complex Reasoning Tasks

Abstract

As LLMs demonstrate remarkable reasoning capabilities, LLM-powered agents are seen as key to achieving AGI (Artificial General Intelligence) and are widely applied in various complex real-world scenarios. Nevertheless, existing studies still suffer from missing steps, deviated task execution and incorrect tool selection. This paper proposes CoReaAgents, a collaboration and reasoning framework based on LLM-powered agents, comprising the Plan Agent (as a precise task planner), the Tool Agent (as a proficient tool user) and the Reflect Agent (as an objective task evaluator). These agents simulate the social division of labor and synergistic cooperation to enable each agent to perform different specialized capabilities in order to solve complex tasks together. Through the above mechanism, the CoReaAgents framework has the skills of prospective thinking and flexible execution. To verify the capability of the CoReaAgents framework, this paper conducts extensive experiments on different complex tasks such as tool learning, math reasoning and multi-hop QA. The results show that the CoReaAgents framework outperforms various comparative methods in both quantity and quality.

1. Introduction

AGI (Artificial General Intelligence) refers to a form of AI that possesses the ability to understand, learn and apply knowledge across a broad range of tasks with human-like flexibility and adaptability [1]. In recent years, AGI has made notable progress across various fields, including improving human–computer interactions and optimizing multimodal automation [2,3]. The prevailing consensus is that AI agents are at the forefront of AGI research, given their capacity for a broad spectrum of intelligent operations [4,5]. These agents can sense their surroundings and utilize those perceptions to make decisions aimed at accomplishing defined objectives. Previously, researchers relied on symbolic logic and reinforcement learning to build agents, such as AlphaGo and the DQN algorithm [6,7]. With the advancement of LLMs (Large Language Models), LLMs equipped with a rich knowledge base and strong reasoning capabilities have become a cornerstone in the development of AI agents, offering numerous advantages that expand their functionalities [8,9]. Nevertheless, traditional methods may struggle with complex reasoning tasks, but as illustrated in Figure 1, collaboration among multiple agents significantly enhances the capacity of LLMs to tackle these challenges more effectively. Likewise, MetaGPT [10] utilizes LLM-powered agents to simulate virtual software teams, implementing meta-programming techniques. It enhances the performance of complex software development tasks through social behaviors such as collaboration and competition.

It is widely acknowledged that existing studies on planning strategies for LLM-powered agents have achieved signal success, which can be categorized into two types: static planning and dynamic planning [11]. Static planning methods, such as CoT (Chain of Thought) [12] and ToT (Tree of Thought) [13], enable LLMs to break down reasoning tasks into intermediate steps or subproblems. These approaches often lead to LLMs generating static task plans or sequences of steps that are not re-planned when issues arise during execution, lacking flexibility and causing delays in updating real-time information [14]. In dynamic planning methods, each step is derived through reasoning based on actions and feedback, providing decent capabilities for single-step invocation and planning [15]. However, due to the lack of overall planning capability, dynamic planning methods may encounter issues such as execution deviations and deficiencies in summarization when handling complex or long-term planning tasks [16]. Therefore, previous methods often suffer from missing steps, lags when updating real-time information and deviations in task execution when using LLM-powered agents. To address these challenges, the ability to correct results through reflection is a distinctive reasoning capability of LLMs. Such capabilities enable LLM-powered agents to iteratively evaluate their outputs and adjust the reasoning process accordingly [17]. Consequently, it is essential to devise strategies that integrate the insight and foresight of static planning with the adaptability of dynamic planning through reflective mechanisms.

Moreover, several studies tackle complex problems by assigning a single agent multiple roles within a task [18]. In this paradigm, there is no feedback mechanism from other agents, nor is there communication between different agents. Notably, humans tend to be limited by their own capabilities and knowledge when dealing with complex tasks, and LLM-powered agents with human-like reasoning face similar limitations. To alleviate these challenges, it is often necessary for team members to cooperate and negotiate with one another, whereas a single agent as an individual lacks the ability to synergize their resources in executing the task [19]. Consequently, a multi-agent framework involves two or more agents, each of which has different roles and responsibilities. The communication and negotiation mechanisms among multiple agents can effectively enhance the overall performance of task solutions [20]. For example, COPPER [21] enhances the collaborative performance of multi-agent systems through a self-reflective mechanism that enables the intelligence agents to learn from environmental feedback and iteratively improve their behavior.

In addition to the aforementioned research, there are also studies dedicated to improving LLMs for tool learning to leverage external resources, such as API calls for intermediate steps [22,23]. By utilizing tools, LLMs can significantly improve an agent’s performance on certain tasks, such as improving their accuracy in mathematical reasoning problems [24] and web searching for relevant news [25]. Several studies have improved the ability of LLMs to use tools through fine-tuning. For example, Toolformer [26] employs a self-supervised approach to fine-tune LLMs so that they can acquire the ability to call APIs. These methods necessitate training with specialized datasets and toolsets, limiting their application to proprietary LLMs and their adaptation to various complex tasks. In contrast, there are also methods for using external tools through searching tool documentation or tool descriptions [27]. The main challenge with these approaches is that as the number of tools increases, LLMs tend to get disillusioned and confused when selecting tools [28]. In this regard, exploiting the rich knowledge and powerful comprehension of LLMs for the semantic enhancement of tool descriptions can improve LLMs’ accuracy in retrieving tools and strengthen their ability to utilize external tools.

To sum up, this paper proposes CoReaAgents, a collaboration and reasoning framework based on LLM-powered agents, which benefit from group intelligence [29]. The CoReaAgents framework enhances task processing accuracy and quality by simulating social division and collaboration among specialized agents, including the Plan Agent, the Tool Agent and the Reflect Agent. The Plan Agent functions as a precise task planner, responsible for task planning and decision making. It employs prospective reasoning to decompose tasks into multiple subtasks with specific dependencies and execution sequences. The Tool Agent functions as a proficient tool user, performing tool augmentation for each tool in the relevant toolset and executing each subtask as a single-step reasoning task. The Reflect Agent functions as an objective task evaluator, reflecting on the results of each subtask and determining the next planning step based on the current results. This ensures dynamic adjustments in task planning and facilitates reflection throughout the process. Moreover, our framework accomplishes overall planning and intermediate steps through the collaboration of multiple team members for continuous adjustment and updating over the course of the tasks. With the assistance of these agents and synergistic mechanisms, the CoReaAgents framework can significantly improve the ability and effectiveness of LLMs in solving complex reasoning tasks. To validate our framework, we conduct extensive experiments on three distinct complex reasoning tasks. The datasets for these tasks include API-Bank and ToolBench for tool learning, FuncQA and SVAMP for math reasoning and HotpotQA for multi-hop QA. The results show that the CoReaAgents framework outperforms various comparative methods in both quantity and quality.

In summary, our contributions can be summarized as follows:

• We propose CoReaAgents, a collaboration and reasoning framework based on LLM-powered agents. This framework simulates social division and cooperation to enhance LLMs’ reasoning and complex task execution capabilities, with a meticulously assembled team of diverse agents.
• Our framework features multiple specialized agents, namely the Plan Agent, which functions as a precise task planner; the Tool Agent, which functions as a proficient tool user; and the Reflect Agent, which functions as an objective task evaluator, thereby effectively targeting complex reasoning tasks.
• Our framework includes multi-agent communication and negotiation mechanisms that facilitate effective exchange and feedback among different agents, addressing the limitations encountered in planning complex tasks that require iterative updates.
• Our approach is experimented with on five open-source and challenging datasets across three different complex reasoning tasks. The results show that the CoReaAgents framework outperforms various comparative methods in both quantity and quality.

2. Related Works

2.1. Complex Reasoning Tasks

In the field of NLP (natural language processing), complex reasoning tasks usually refer to those problems that require deep analysis and understanding of the available information with the application of reasoning mechanisms in order to draw the correct conclusions [30]. This involves considering multiple variables and conditions, inferring outcomes using logical, inductive, deductive and other modes of reasoning [31,32]. Complex reasoning tasks typically require integrating various information sources to build inference chains, uncovering deeper associations and deriving inferred results. Currently, LLMs can handle common tasks like natural language understanding and text generation, but when task complexity exceeds a certain threshold, they may struggle to manage this [33]. Compared to traditional complex reasoning tasks such as logical reasoning and common sense reasoning, tasks such as tool learning, math reasoning and multi-hop QA present unique challenges. Addressing these tasks demands robust reasoning capabilities, sophisticated planning mechanisms and effective tool invocation strategies. As LLMs continue to exhibit strong language comprehension and text generation capabilities, research into using LLMs to tackle these complex tasks deepens and progresses with ongoing innovation.

The tool learning task allows LLMs to enhance their ability to solve problems and perform tasks by invoking external tools, such as Application Programming Interfaces (APIs) [34]. The core goal of this task is to enable the model to understand user commands and to select the appropriate tool to perform a specific operation based on those commands, eventually reaching the demands of the user. Tool learning is a highly complex and diverse domain used to obtain not only strong language comprehension but also the capability to perform multi-step operations and interact with external tools [35]. For this task, DFSDT [36] explores different reasoning paths by simulating a Depth-First Search (DFS) of a decision tree and makes decisions during the search process to find an efficient way to solve a problem. ToolNet [28] is designed to connect LLMs to a large number of tools by constructing a directed graph, thus improving their ability to handle real-world tasks. Nevertheless, the tool learning task demands a high level of operational planning and the utilization of tools.

The math reasoning task involves the application of mathematical knowledge and logical reasoning skills to solve mathematical problems [37]. This type of task usually relates to the understanding of mathematical concepts, executing mathematical operations and developing problem-solving strategies [38]. The solution of this task requires the model to understand problem descriptions in natural language and to extract key information from them, such as numbers, operators and the specific requirements of the problem. The initial idea was to use natural language fundamentals to solve math problems through a series of intermediate steps [39]. Since then, this task has emerged as a crucial method for evaluating and enhancing the ability of NLP models to understand natural language and perform complex computations. Self-Consistency [40] selects the most consistent answer in the final answer set by sampling diverse reasoning paths. Self-Contrast [41] encourages LLMs to autonomously generate multiple different prompts, each representing a unique perspective on problem solving. These perspectives may include different ways of thinking, identities, personalities or preferences and so on. Contrasting differences in perspectives effectively reduce overconfidence or inconsistent feedback when self-evaluating, resulting in improved accuracy and stability in mathematical reasoning. In addition, EASYTOOL [42] designs detailed function usage guides, including parameters and examples, for each arithmetic tool when solving math reasoning problems. These guides help LLMs understand how to use the right arithmetic tools for different scenarios. Due to the limited computational ability of LLMs, it is essential to enhance the capability of LLM-powered agents to leverage external tools for assistance with math reasoning tasks.

The multi-hop QA task requires the model to extract information sequentially from multiple sources, rather than relying on a single source, to obtain the final answer [43]. The completion of multi-hop QA requires integrating information from different documents, which is more complex than using a single document or reasoning based on logic or common sense. In the early days, some research focused on simple QA, which could usually be solved directly [44]. As research on QA tasks advances, many researchers are turning to a more complex QA scenario, which is multi-hop QA. Many studies have proposed a variety of techniques for solving multi-hop QA tasks, including embedding-based approaches, path-based approaches and logic-based approaches [45,46]. These approaches are designed to improve the performance of the model in multi-hop QA tasks, including understanding the complexity of the questions and improving the accuracy of the reasoning. With the development of LLMs, many studies have begun to explore the use of LLMs to handle multi-hop QA tasks. DIETNERD [47] is based on LLMs and aims to enhance public health education about diet and nutrition by summarizing and evaluating peer-reviewed scientific articles. AMOR [48] formalizes reasoning logic as a finite state machine (FSM). In this way, AMOR is able to deal with problems in a stepwise and systematic way until a final answer is found. HGOT [49] uses a divide and conquer strategy to solve problems by constructing a hierarchical, structured graph to organize and optimize the retrieval of relevant information. GMeLLo [50] solves multi-hop QA tasks after knowledge editing by integrating LLMs and knowledge graphs. However, LLM-powered agents still have substantial room for improvement in planning inference paths and comprehending textual content when addressing multi-hop QA tasks.

2.2. LLM-Powered Agents

LLMs have evolved from previous task-specific models for supervised learning on labeled data to modern generalized learning models trained on massive text data [51]. This evolution marks a shift in LLMs from specialization to generalization. The autonomy, environmental awareness and social competence of LLMs enable them to use natural language interactions to accomplish a wide range of tasks [52].

A lot of studies have already started to construct AI agents leveraging LLMs [9,53]. Specifically, they use the LLM as the brain or controller of the agent, extending its reasoning capabilities and action space through strategies such as task planning and tool use. In terms of improving the reasoning ability of LLMs, in order to decrease the difficulty encountered by LLMs in providing answers, some studies have been conducted to improve the accuracy of reasoning through problem decomposition methods. For example, methods like CoT [12] choose to decompose the question first and answer a subset of the question later. In contrast to integrating reasoning into the planning process, ReAct separates reasoning from planning and enhances the reasoning capabilities of LLMs by integrating clear reasoning steps with targeted action strategies [15]. Subsequently, more sophisticated reasoning frameworks have been introduced, like ToT (Tree of thoughts) [13], GoT (Graph of thoughts) [54] and several other variants. On the other hand, the use of tools can reduce the inherent limitations of LLMs, including acquiring real-time information, improving math skills and reducing hallucinations. In mathematics and some specialized fields, utilizing tools can reduce error rates [55]. In the domain knowledge of specific models and APIs, the choice to adopt various external tools to enhance LLMs in multiple ways is prevalent. Many studies have long been focused on how to improve the ability of LLMs to use tools. Toolformer [26] uses tools in a self-supervised manner; subsequently, various external tools have emerged to enhance LLMs in multiple ways. ToolAlpaca [56] proposes to build a multi-agent simulation environment by modeling real-world tool usage scenarios. From there, it automatically generates a tool using corpus, which provides a way for LLMs to learn to generalize their tool use capabilities. ToolLLM [36] addresses the need for real-world APIs by leveraging RapidAPI Hub, including both single-tool and multi-tool scenarios.

Despite the commendable reasoning abilities of LLM-powered agents, they primarily operate as isolated entities [57]. A single agent lacks the capability to collaborate with other agents and acquires knowledge through social interactions. This limitation constrains their potential to learn from the feedback of others, thereby hindering their performance improvement [8]. In addition, they cannot effectively handle complex scenarios that require information sharing. Recent studies have shown that LLMs can improve themselves or better align themselves with human values by interacting with each other [58]. These advances raise the possibility that LLM-powered agents could be expected to engage in challenges in a more natural way. Each agent in a multi-agent framework has different roles and responsibilities, enabling them to coordinate their actions and work together to achieve a goal. This structure reduces the burden on a single agent and thus improves task performance [59]. Some scholars create virtual towns by populating an interactive sandbox environment inspired by the Life Sandbox Game [53]. These agents can perform convincing individual and group social behaviors, providing a whole new perspective. Several studies explore how LLM-powered agents can be applied to Werewolf, which demonstrates the potential of LLM-powered agents in communication games [60]. ChatEval [61] employs multiple agents and debates using different communication strategies to promote the automatic evaluation of LLMs. LangGround [62] is a Multi-Agent Reinforcement Learning (MARL) computational framework that enables agents to learn human-interpretable communication languages in order to collaborate effectively with humans or other agents without prior coordination. AgentDropout [63] identifies and eliminates redundant agents in different communication rounds by optimizing the adjacency matrix of the communication graph to improve the efficiency and performance of multi-agent collaboration. These studies have shown that an effective division of labor among multiple agents can accomplish a larger workload and improve the efficiency and quality of the executions.

3. Method

In this section, we introduce the CoReaAgents framework, a multi-agent collaboration framework that imitates the division of labor in human society. This framework enables not only continuous adjustments to task planning through reflection on the process but also autonomous tool augmentation for task scenarios. Meanwhile, each agent in the CoReaAgents framework coordinates its actions with the others, acting as team members to achieve a same goal.

3.1. Overview

Complex reasoning tasks, characterized by complexity and abstraction, demand advanced cognitive, planning and execution skills from LLM-powered agents. While a single agent has decent reasoning skills, it still essentially completes tasks as a separate individual and cannot handle complex tasks which require competence in multiple domains. To address these challenges, we propose the CoReaAgents framework, in which each agent has distinct functionalities and equal significance, collectively enhancing overall performance in tackling complex tasks. This allows the framework to correct errors and deviations in a timely manner and continuously optimize the task execution process. In contrast, ReAct, although dynamic, lacks a specialized reflection mechanism to systematically evaluate and adjust task planning, while Reflexion focuses on learning and improving task execution through reflection, but its reflection process is relatively independent, unlike the CoReaAgents framework, where the Reflect Agent collaborates closely with the other agents to drive the dynamic adjustment of tasks.

An overview of the CoReaAgents framework is shown in Figure 2, including the Plan Agent, the Tool Agent and the Reflect Agent. In detail, the Plan Agent serves as a precise task planner that thoughtfully considers the task in order to control the overall direction of the task. The Tool Agent serves as a proficient tool user, who has a deep comprehension of external data sources to effectively utilize tools in the completion of a task. The Reflect Agent serves as an objective task evaluator, evaluating the task planning and execution processes from other perspectives, which guarantees the success of the task through continuous reflection and feedback. Through the specialized separation of tasks and a mutual consultation mechanism for each agent, we are able to continuously refine the task plan during task and tool augmentation for autonomous task completion scenarios.

3.2. The Framework of CoReaAgents

3.2.1. Plan Agent: A Precise Task Planner

There are two categories of static and dynamic planning in the current task reasoning strategies. Static planning lacks the ability to flexibly execute tasks and cannot adjust its approach in a timely manner if problems arise during the execution process.Dynamic planning lacks an overview understanding of the task and could deviate from the task target when performing complex tasks. Thus, we propose the Plan Agent in the CoReaAgents framework, which can provide a blueprint for the execution of the task, controlling the general direction for the task’s accomplishment. Specifically, the primary responsibilities of the Plan Agent include tool filtering and task planning.

Tool filtering: The Plan Agent filters the retrieved tools to discard irrelevant and redundant information. It accomplishes this by understanding the description, the parameters and the role of each tool, which ensures the selections are highly relevant to a specific task. This process can significantly avoid the negative impact of irrelevant information on task planning.

Task planning with CCoT: Inspired by GOLLIE [64], we propose CCoT (Code and Comments of Thoughts), which accomplishes task planning with codes and comments. As shown in Figure 3, CCoT comprises two main parts: the first part involves analytical natural language task descriptions given as comment parts, and the second part contains the actions needed to invoke the tool as code segments. This not only ensures the continuity of LLMs in carrying out logical planning but also enables LLMs to maintain consistency between the thoughts involved in task planning and the behavior involved in tool invocation. Utilizing this method, the Plan Agent develops a comprehensive planning strategy by decomposing complex tasks into manageable subtasks that exhibit specific dependency relationships and an established execution order.

Communication with the Tool Agent and the Reflect Agent. The Plan Agent acts as a precise task planner, taking into account the global aspects with a prospective approach to the overall planning of the task (details in Section 3.3.2). It plans an execution strategy that is coordinated with the plan for reflection of the Reflect Agent and the tool augmentation task of the Tool Agent to facilitate dynamic adjustments of the action path.

3.2.2. Tool Agent: A Proficient Tool User

The Tool Agent demonstrates an excellent understanding of tool usage, rapidly altering various tool applications to accommodate environmental changes. The primary responsibilities of the Tool Agent include tool augmentation and task execution.

Tool augmentation. Tools with multiple functions are widely applicable across various scenarios, yet they are often not described in a targeted manner. The Tool Agent leverages the extensive knowledge and strong comprehension abilities of the LLM to enhance the tools required for task completion. As shown in Figure 4, the Tool Agent carries out additional descriptions in the current instruction scenario based on the general description, which improves the accuracy applied by the Plan Agent in planning the task.

Task execution. The results from a particular tool often contain substantial data that are irrelevant to the subtask. Such information is regarded as noise for the subtask, potentially impacting its performance. To optimize tool utility, the Tool Agent executes the specific actions planned by the Plan Agent. Specifically, for each subtask to be executed, the Tool Agent invokes the corresponding tool and performs a task summary to obtain the final results of the subtask.

Execution of the Plan Agent’s planning and its interaction with the Reflect Agent. As a proficient tool user, the Tool Agent can ensure the effective execution of tasks planned by the Plan Agent and provide the CoReaAgents framework with the practical operational capabilities required to complete tasks (details in Section 3.3.1).

3.2.3. Reflect Agent: An Objective Task Evaluator

Recent studies have shown that LLMs often display overconfidence in self-reflecting on their own generated content, leading to stubborn feedback [41]. In this regard, the Reflect Agent assesses and reflects on the completion of intermediate steps and task planning from a tertiary perspective. Specifically, the Reflect Agent monitors and analyzes the plan developed by the Plan Agent and the subtask results generated by the Tool Agent to ensure that the task is performed to the expected standard. As a result, the duties of the Reflect Agent are divided into subtask reflection and plan reflection.

Subtask reflection. To ensure that each subtask is completed successfully, the Reflect Agent reflects on the results of each subtask after its execution. The Reflect Agent determines whether the tool selected for the current subtask satisfies the expectations based on the relevant tool description. It also further determines exceptions in the process of invoking the tool. Finally, the Reflect Agent evaluates if the execution results summarized by the Tool Agent contain the information needed for the subtask.

Plan reflection. In order to advance continuous improvement in task planning, the Reflect Agent constantly forecasts the next step based on currently known information. In this process, the Reflect Agent achieves dynamic task planning by predicting the next pending subtask based on the completed subtasks. Subsequently, the predicted next subtask is compared with the corresponding subtask in the overall plan of the Plan Agent. The progression and learning of complex reasoning tasks by the CoReaAgents framework are achieved by comparing the task target and execution actions of both.

Reflection for the Plan Agent and the Tool Agent. The Reflect Agent enables reflection on the entire process of task planning and execution, seeking out potential for refinement. The dynamic task planning performed by the Reflect Agent is combined with the global planning performed by the Plan Agent to ensure the expected quality of tasks (details in Section 3.3.3).

3.3. The Multi-Agent Communication and Negotiation Mechanisms in the CoReaAgents Framework

Figure 2 illustrates the mechanism through which the various agents act in the CoReaAgents framework. Specifically, the Plan Agent and the Tool Agent collaborate to enable the CoReaAgents framework’s autonomous tool filtering and tool augmentation. The Plan Agent conducts task planning with CCoT, leveraging the results of the tool augmentation and then communicating the plan to the Tool Agent to execute each step of the task. The Reflect Agent provides feedback to the Tool Agent and the Plan Agent through subtask reflection and plan reflection. This process enables the facilitation of iterative refinements throughout task execution.

3.3.1. Autonomous Tool Filter and Tool Augmentation Between the Plan Agent and the Tool Agent

To avoid irrelevant and redundant information from impacting task planning, we design a synergy mechanism between the Plan Agent and the Tool Agent. Specifically, the Plan Agent performs tool filtering on the toolset prior to task planning, while the Tool Agent augments each tool in the filtered toolset.

As shown in Figure 2, Step1 gives a toolset $TS=\{T_1,T_2,T_3,\dots ,T_n\}$ containing all the tools and a brief description of each tool $T_i$ in the $TS$, including tool-related parameters and roles, to make it easy to select the tools that are highly relevant to this task. As shown in Equation (1), the Plan Agent $M_{plan}$ combines prompts $P_{filter}$ and complex task information I to select a related toolset $RTS=\{T_1^{\prime },T_2^{\prime },T_3^{\prime },\dots ,T_m^{\prime }\}$ where $m<n$ from $TS$, which reduces the negative impact of irrelevant information on task planning.

$$\begin{array}{cc}\hfill RTS& =M_{plan}(P_{filter},TS,I)\hfill \end{array}$$

(1)

After the Plan Agent completes tool filtering, the Tool Agent performs tool augmentation in $RTS$. As shown in Figure 4, the Tool Agent combines the task scenario with a general description of the tool to further provide supplementary details specific to the current command scenario. This mechanism can enhance the accuracy of the tools’ application during subsequent task planning.

3.3.2. From Task Planning by the Plan Agent to Task Execution by the Tool Agent

The Plan Agent performs task planning based on enhanced tool descriptions, and the Tool Agent executes each subtask of the overall plan in turn. The Plan Agent analyzes the given complex task instruction Q and performs task planning to obtain a collection of logically related subtasks S. The Plan Agent selects the appropriate tools to assist with the various subtasks when planning a task in conjunction with the enhanced tool descriptions in $RTS$. This process can be expressed by the following Equation (2):

$$\begin{array}{cc}\hfill S& =M_{plan}(P_{plan},RTS,Q)\to \{s_1,s_2,s_3,\dots ,s_n\}\hfill \\ \hfill s_i& =\{t_i,a_i,p_i,r_i\}\hfill \end{array}$$

(2)

where $P_{plan}$ is a task planning prompt, and n is the number of subtasks. The basic attribute data of any subtask $s_i$ in S are shown in

Table 1. The details of subtasks’ basic attributes.

Basic Attribute	Notation	Attribute Description
Current subtask	$s_i$	Logical position in the collection of subtasks
Subtask target	$t_i$	Subtask target expressed through comments
Tool requirement	$a_i$	Tool to be invoked expressed through code
Parameter configuration	$p_i$	Parameters required to invoke the tool
Subtask result	$r_i$	Result of this subtask

.

Following the completion of task planning, the Tool Agent completes each subtask $s_i$ in S and consolidates its result. Specifically, as shown in Equation (3), the Tool Agent $M_{tool}$ determines the parameters $p_i$ for invoking the tool through subtask target $t_i$, the tool to be invoked $a_i$ and an enhanced targeted description of the tool $D_{a_i}$. Eventually, the Tool Agent performs a task summary for $t_i$ on the results obtained from the use of external resources to obtain the final result of the subtask $r_i$. Task planning by the Plan Agent and task execution by the Tool Agent based on CCoT can maximize tool utilization and improve task success rates.

$$\begin{array}{cc}\hfill p_i& =M_{tool}(P_{tool},t_i,a_i,I,D_{a_i})\hfill \\ \hfill r_i& =M_{tool}(P_{sum},t_i,Exe(a_i,p_i))\hfill \end{array}$$

(3)

where $P_{sum}$ is the task summary prompt and $Exe(a_i,p_i)$ indicates that $a_i$ is invoked by $p_i$ using the configured interpreter.

3.3.3. Static and Dynamic Task Planning Combination by the Reflect Agent

The Reflect Agent performs subtask reflection and plan reflection, consulting with the Tool Agent and the Plan Agent. When the Tool Agent completes each subtask, the Reflect Agent performs subtask reflection on its result, as shown in Figure 5.

• <Re-Select> indicates that the tool invoked for this subtask needs to be reselected. The Tool Agent needs to reselect the tool and execute it based on the feedback.
• <Re-Call> indicates that the tool call failed and necessitates a reconsideration of the tool parameters. The Tool Agent needs to analyze the parameters of the call again.
• <Re-Sum> indicates that the Tool Agent needs to execute the subtask again and summarize it based on the feedback.

The Reflect Agent performs plan reflection for the Plan Agent, thereby enabling continuous iterative updates to the task plan:

• The Reflect Agent combines information about completed subtasks $\{s_1,s_2,s_3,\dots ,s_i\}$ to plan the next task $s_{i+1}^{\prime }$, drawing inspiration from ReAct [15].
• $s_{i+1}^{\prime }$ is compared with the corresponding subtask $s_{i+1}$ in the overall plan.
• <Re-Plan> indicates that their task target $t_{i+1}$ or invoked tool $a_{i+1}$ is inconsistent. the Plan Agent should replan the subsequent tasks.

After completing the above steps, dynamic planning with flexible execution can be integrated into each step of the overall planning, realizing the organic combination of static and dynamic planning.

4. Experiments

In this section, we experiment with our approach in several complex reasoning tasks: tool learning, math reasoning and multi-hop QA. We evaluate both the baselines and our approach using GPT-3.5 [65] to ensure a fair comparison with identical model parameters. The experimental results reported for each dataset in this study are calculated as the average of five independent trials. Specifically, for each test set, performance metrics are derived from five repeated experiments conducted under identical experimental conditions. The arithmetic mean is employed to mitigate stochastic variations inherent to individual trials, thereby ensuring both result stability and experimental reproducibility. This methodological design minimizes potential confounding effects from singular experimental artifacts while strengthening the statistical validity of the findings.

4.1. Tool Learning

4.1.1. Settings for Tool Learning

Datasets

• ToolBench [36] is a dataset with multiple types of data that covers multiple domain application scenarios and contains over 16,000 real-time APIs collected from the RapidAPI Hub (https://rapidapi.com/hub accessed on 30 January 2025) that cover 49 categories. We evaluate our approach using the most complex subset of ToolBench, including intra-category multi-tool instructions (I2) and intra-collection multi-tool instructions (I3). The final evaluation is divided into three subsets for testing, I2-Inst (200 test data), I2-Cat (200 test data) and I3-Inst (100 test data).
• API-Bank [34] is a multi-task benchmark consisting of various tools used to evaluate the performance of tool-augmented LLMs. API-Bank involves the offline usage of multiple API tools. We conduct an evaluation on the test data ranging from level-1 to level-2 of this dataset, which comprises a total of 534 test data.

Baselines

We compared the CoReaAgents framework with the following recent and classic baselines:

• ReAct [15] guides LLMs to take appropriate actions at each step to solve a particular problem and carry out reasoning for the actions, iterating the process to finally solve the problem.
• Reflexion [17] enables the LLMs to learn from error information and retry when an error occurs, continuing until the task is successfully completed or the maximum number of reflection attempts is reached.
• DFSDT [36] simulates the Depth-First Search process by constructing a decision tree to explore different solution paths.
• EASYTOOL [42] distills the necessary information from tool documentation and converts it into concise tool descriptions, enhancing LLMs’ ability to select tools more accurately.
• ToolNet [28] organizes the tools into a directed graph, allowing the LLM to start from an initial tool node and iteratively select the next node in the graph until the task is resolved.
• Tool-Planner [66] performs dynamic solution tree planning based on toolkits, which group APIs with the same functionality into a single toolkit. When tool errors occur, LLMs can reselect tools based on toolkits.

Evaluation metrics

For the ToolBench, we use the Pass Rate from ToolEval [36] to evaluate our framework, which is calculated from the proportion of tasks successfully completed with a limited budget. For API-Bank, we use Exact Match (EM) to compare the execution output of LLMs with the real answers.

4.1.2. Main Results from Tool Learning

The CoReaAgents framework demonstrated the most advanced performance on ToolBench and API-Bank.

Table 2. The results of different baselines and the ablation study in terms of Pass Rate (%) and EM (%). The table highlights the highest scores in bold, with underscores indicating the highest scores achieved by prior methods. - indicates that the method is not publicly available. The rightmost column in the table shows the number of tokens completing this task for each baseline.

	ToolBench (Pass Rate)				API-Bank (EM)
Methods	I2-Ins	I2-Cat	I3-Ins	Average	Lv1 + Lv2	Tokens
ReAct	42.5	46.5	22.0	37.0	70.0 5100
Reflexion	58.0	66.0	55.0	59.7	77.0	8750
DFSDT	75.0	71.5	62.0	69.5	72.0	25,000
DFSDT-EASYTOOL	77.5	74.5	65.0	72.3	76.4	-
ToolNet	-	-	-	-	75.0	4112
ToolNet + Reflexion	-	-	-	-	83.0	7950
Tool-Planner	75.5	78.0	66.0	73.2	-	-
CoReaAgents	80.5	79.0	72.0	77.2	84.0	15,000
w/o TA	75.0	74.0	68.0	72.3	79.8
w/o RA	73.0	72.5	65.0	70.2	79.5
w/o TA&RA	70.5	70.0	61.0	67.2	74.5

shows the results from tool learning for all baselines and our approach. For ToolBench, our method outperforms Tool-Planner, the baseline with the best average performance, by over 4.0% in terms of Pass Rate. This validates the comprehensive capabilities of the CoReaAgents framework on the ToolBench. The CoReaAgents framework achieves varying degrees of improvement on both I2 and I3 tasks. Specifically, the CoReaAgents framework shows a significant improvement in the I3 scenario, which demonstrates that our approach is better adapted to multi-category multi-tool task scenarios.

The same situation is also observed in the API-Bank dataset. For the API-Bank dataset, our method outperforms all baselines in terms of Exact Match (EM). For level-1 and level-2 instructions in API-Bank with a small number of tools, the CoReaAgents framework demonstrates a slight enhancement. This indicates that, even with a single tool or a limited number of tools, the CoReaAgents framework can still select the appropriate tools and generate correct answers. In addition, the experimental results from API-Bank to ToolBench illustrate that the performance of the framework remains stable as the number of tools increases, which reflects its good scalability.

The rightmost column in Table 2 shows the average number of tokens consumed by the CoReaAgents framework versus other baselines for completing the tool learning task. The results indicate that, despite the higher computational cost associated with the CoReaAgents framework, the trade-off is justified by the enhanced performance in tool learning tasks.

4.1.3. Ablation Study of Tool Learning

In order to assess the impact of specific strategies or team members in the CoReaAgents framework, we perform ablation studies on tool learning datasets to develop three variants of our framework. Note that task planning by the Plan Agent is an indispensable component for solving complex reasoning tasks, making it impossible to remove the Plan Agent from our framework. The settings for the ablation study are as follows:

• The CoReaAgents framework + w/o TA: the Tool Agent is removed from the CoReaAgents framework, meaning that no tool augmentation and subtask execution are conducted when handling complex tasks.
• The CoReaAgents framework + w/o RA: similarly, the task division of the Reflect Agent, including subtask reflection and plan reflection, is removed from the process.
• The CoReaAgents framework + w/o TA&RA: the Reflect Agent and the Tool Agent are removed from the processing of complex tasks in the CoReaAgents framework, only utilizing the Plan Agent to complete tasks.

For tool learning, it is often necessary to use external tools to obtain the information required to complete the task, and LLMs are expected to make timely adjustments to task planning based on the acquired information. Table 2 shows the results of the ablation study. The results show that removing the Reflect Agent has the greatest impact on the CoReaAgents framework, followed by the removal of the Tool Agent. The main reason for this is that timely adjustments to task planning are more critical in quite complex scenarios. The improvement in effectiveness provided by the Reflect Agent confirms the importance of reflecting on subtasks and overall planning during the process. The impact of removing the Tool Agent confirms that our strategy aids in selecting more appropriate tools and using them effectively.

Whereas removing the Reflect Agent and Tool Agent degrades the performance of the CoReaAgents framework, this strongly supports the idea that collaboration among multiple agents leads to better results than relying solely on a single agent to complete tool learning tasks. The ablation results on the API-Bank dataset suggest that when the number and variety of tools are minor, removing either the Reflect Agent or the Tool Agent has a similar impact on the CoReaAgents framework’s performance.

4.2. Math Reasoning

4.2.1. Settings for Math Reasoning

Datasets

• FuncQA [67] involves 13 arithmetic operation tools (e.g., power, sqrt, lcm), which are used to test the reasoning ability of LLMs in complex mathematical problems. We evaluate our approach using multi-hop problems from this dataset. Multi-hop problems consist of 68 math problems that can be solved with multiple tools.
• SVAMP [37] is a dataset of mathematical application problems designed specifically to test the ability of natural language processing models to solve basic mathematical problems. The dataset contains four arithmetic operations: addition, subtraction, multiplication and division. Each problem contains up to two mathematical expressions and one unknown variable. The sample size of the test set for this dataset is 1000 test data.

Baselines

• CoT [12] improves the performance of LLMs on complex inference tasks by generating intermediate inference steps.
• Self-Consistency [40] samples multiple inference paths and selects the output with the highest consistency as the final answer based on a voting strategy.
• Self-Contrast [41] improves the reflectivity and corrective accuracy of LLMs by creating a diversity of perspectives and comparing the differences in the different perspectives.
• ReAct, Reflexion, EASYTOOL are the same as the baselines in Section 4.1.1.

Evaluation metrics

For the math reasoning task, we use accuracy to evaluate the answers derived from LLMs’ step-by-step reasoning, with a 0.1% error tolerance.

4.2.2. Main Results from Math Reasoning

The CoReaAgents framework demonstrates powerful performance in math reasoning tasks. The results in

Table 3. The results of different baselines and the ablation study on math reasoning. The table highlights the highest scores in bold, with underscores indicating the highest scores achieved by prior methods. - indicates that the method is not publicly available. The rightmost column in the table shows the number of tokens completing this task for each baseline.

Accuracy
Methods	FuncQA (Multi-Hop)	SVAMP	Tokens
CoT	17.64	79.8	433
ReAct	41.17	80.3	2260
Reflexion	42.65	80.5	2312
Self-Consistency	45.59	84.6	5750
EASYTOOL	48.53	84.9	1411
Self-Contrast	-	89.0	-
CoReaAgents	57.35	90.3	3900
w/o TA	50.00	87.1
w/o RA	47.05	85.5
w/o TA&RA	44.12	82.4

show that our framework significantly improves the ability of LLMs to solve complex math reasoning problems. The CoReaAgents framework shows the best behavior both in a Multi-hop subset of FuncQA and in SVAMP. For the Multi-hop subset of FuncQA with multiple math formulas, due to the limited size of the test set and the higher number of correct answers provided by our method, the CoReaAgents framework demonstrates a performance improvement of 8.82% over EASYTOOL. For SVAMP, due to the limited number of formulas involved in the task and the high accuracy that many studies have achieved, it is challenging to obtain significant improvements. As a result, our method achieves a slight improvement compared to other baselines. This could also indicate that the CoReaAgents framework can fully comprehend the reasoning steps behind mathematical problems and apply mathematical formulas. Furthermore, the experimental results from SVAMP to Funcqa illustrate the ability of the CoReaAgents framework to adapt to different types of mathematical problems, from simple arithmetic operations to complex multi-step mathematical reasoning. This adaptability demonstrates the framework’s scalability.

The rightmost column in Table 3 shows the average number of tokens consumed by the CoReaAgents framework versus the other baselines to complete the math reasoning task. The results show that the cost is not significant compared to the improved performance of the CoReaAgents framework in the mathematical reasoning task. If the focus is more on pushing the limits of performance, the CoReaAgents framework could be more effective.

4.2.3. Ablation Study of Math Reasoning

We analyze the effects of different agents in the CoReaAgents framework on the math reasoning task separately. The results of the ablation study are presented in Table 3. Removing the Reflect Agent has the greatest impact on the CoReaAgents framework, while removing the Tool Agent also affects task performance. The reason for this is that complex math problems require objective analysis at each step. The Reflect Agent facilitates subtask reflection and plan reflection, allowing LLMs to analyze the problem from multiple perspectives and make timely adjustments. Due to the limited computational power of LLMs and the high demands of math reasoning tasks in terms of computational capabilities, utilizing external tools for assistance becomes especially crucial. The performance without the Tool Agent on both datasets confirms the effectiveness of tool augmentation and subtask execution performed by the Tool Agent. Eventually, the experimental results indicate that the CoReaAgents framework significantly outperforms a single LLM-powered agent in solving math problems.

4.3. Multi-Hop QA

4.3.1. Settings for Multi-Hop QA

Datasets

• HotpotQA [43] is a dataset of challenging multi-hop QA tasks. It extracts relevant facts and performs multi-hop reasoning based on article passages from Wikipedia. The answers to the questions in HotpotQA cover a wide range of domains, reflecting its diversity and complexity for QA tasks. We randomly selected 500 questions to construct the test set for evaluation.

Baselines

• AMOR [48] decomposes the problem solving process into a series of modular steps, each corresponding to a state in a Finite State Machine.
• UALA [68] quantifies the degree of certainty of a language model in answering a question through various existing measures of uncertainty.
• Self-ask [69] allows the model to explicitly ask and answer a series of subquestions before answering the final question. In this way, the model is able to decompose complex questions more systematically and construct the final answer step by step.
• HGOT [49] leverages the planning capabilities of LLMs. It uses a divide strategy to decompose complex queries into subqueries and build dependency graphs at a deeper level.
• CoT, ReAct, Self-Consistency are the same as the baselines in Section 4.1.1 and Section 4.2.1.

Evaluation metrics

For HotpotQA, we evaluated it with Exact Match (EM) and F1 scores. EM identifies the proportion of predictions that are in precise agreement with the correct answer, while the F1 score evaluates the average token overlap between the prediction and the correct answer.

4.3.2. Main Results from Multi-Hop QA

The CoReaAgents framework shows a slight improvement compared to other baselines. Multi-hop QA tasks place greater emphasis on the LLM’s reasoning capabilities. As shown in

Table 4. The results of different baselines and the ablation study on HotpotQA in terms of EM (%) and F1 (%). The table highlights the highest scores in bold, with underscores indicating the highest scores achieved by prior methods. - indicates that the method is not publicly available.

	HotpotQA
Methods	EM	F1
CoT	34.80	42.32
ReAct	35.47	42.18
Self-Consistency	39.40	-
AMOR	39.60	49.30
UALA	41.30	-
Self-ask	43.98	54.67
HGOT	47.37	59.48
CoReaAgents	48.83	61.77
w/o TA	46.64	58.28
w/o RA	44.87	56.34
w/o TA&RA	41.93	54.83

, the CoReaAgents framework slightly outperforms other reasoning-enhanced baselines on the HotpotQA dataset. Compared to the best-performing HGOT, the CoReaAgents framework improves the EM scores by 1.46% and the F1 scores by 2.29%. This demonstrates that our method realizes autonomous planning and readjustment with the collaboration of multiple agents.

4.3.3. Ablation Study of Multi-Hop QA

In the ablation study results presented in Table 4 for HotpotQA, the impact of removing the Reflect Agent is greater than that of removing the Tool Agent. The reason for this is that the multi-hop QA task is focused on understanding textual content and has less reliance on utilizing external resources. Nevertheless, the Tool Agent can still improve the performance of the CoReaAgents framework on HotpotQA. The main explanation for this is that the Tool Agent summarizes the results for each subtask after completing it, which helps the CoReaAgents framework to integrate critical information. The Reflect Agent emphasizes the significance of reflection by iteratively updating the task plan, which enables the CoReaAgents framework to distill information from multiple sources and obtain a final answer.

4.4. Further Analysis

4.4.1. Specific Analysis of Ablation Study on ToolBench

In this paper, we examine the experimental results from 500 test cases across I2-Ins, I2-Cat and I3-Ins in ToolBench. We summarize and categorize the types of problems in ToolBench that directly lead to task failure and provide further specific analysis. Figure 6 shows the number of various problem types present in ToolBench and their distribution across experimental conditions. The CoReaAgents framework without the Tool Agent makes more errors in tool selection and usage. The experimental results show that the CoReaAgents framework using the Tool Agent for tool augmentation and subtask execution can more effectively select the appropriate tool.

The CoReaAgents framework without the Reflect Agent makes more mistakes in both tool application and task planning. This indicates that the Reflect Agent enables the timely correction of mistakes in selecting or using tools, significantly reducing the occurrence of API hallucinations. In addition, the reflection on the overall planning by the Reflect Agent can guide the task direction to the correct reasoning path in time, which effectively reduces task planning errors.

4.4.2. Analysis of Tool Augmentation by the Tool Agent

The accuracy of tool selection is a key factor in evaluating the ability of LLM-powered agents to solve complex tasks. The CoReaAgents framework primarily enhances tool selection accuracy through tool augmentation. Figure 7 illustrates the impact of tool augmentation on tool selection in both tool learning and math reasoning tasks. The results may not be representative since the CoReaAgents framework employs a few tools for the multi-hop QA task. The results in Figure 7 indicate that tool selection errors lead to task failures more frequently in math reasoning tasks than in tool learning tasks. We found that the reasons for mistakes in math reasoning tasks are centered on formula selection, and there are almost no instances of tool failure or missing parameters.

The experimental results demonstrate that tool augmentation, which provides targeted explanations of tool descriptions, significantly decreases incorrect tool selections and facilitates successful task completion.

4.4.3. Reflection Frequency Statistics for the Reflect Agent

After each step during subtask execution, the Reflect Agent evaluates the feasibility of the task plan. Figure 8 shows the Pass Rate for each subset of ToolBench for different maximum numbers of reflections after each step of the subtask. With the increase in reflection iterations, the Pass Rate for I2 and I3 in ToolBench shows varying degrees of improvement. The bias in test data between I2-Cat and I2-Ins means that issues in I2-Cat can be more easily corrected through reflection. As a result, the Pass Rate of I2-Cat increases more rapidly before reaching six reflection iterations. The complexity of I3-Ins causes its Pass Rate to increase slowly as the number of reflection iterations grows. In summary, we consider that in complex scenarios requiring numerous tool invocations, setting the maximum number of reflection iterations to 12 strikes a balance between performance and efficiency.

4.4.4. Case Study

In order to improve the interpretability of each agent’s decisions, we visualize the collaboration process and decision-making results of the agents through a specific case study. Figure 9 illustrates the success of the CoReaAgents framework in the tool learning task. For the instruction “Update Jerry’s personal information and address. Password is zxcvbn. Address is 345 Main St.”, the Plan Agent performs tool filtering and hands over the results to the Tool Agent for tool augmentation. Then, the Plan Agent performs task planning and the Tool Agent executes subtasks sequentially. The Reflect Agent reflects on the results of the subtask execution and the next steps in this process. The figure shows the results of the Reflect Agent’s feedback during the execution of the subtasks and the task plan without errors.

We conducted a case study to further investigate the performance of the CoReaAgents framework. Figure 10 shows a case study of the CoReaAgents framework involving tool learning, and we compare our method with only a single agent. The results indicate that in complex scenarios requiring external resources, relying solely on a single agent to complete the task leads to planning errors and tool usage mistakes. In contrast, the CoReaAgents framework can perform more accurate task planning and tool usage. As shown in Figure 10, the tool augmentation in the CoReaAgents framework provides targeted enhancements to tool descriptions, increasing tool selection accuracy. The specific collaborative mechanism of the CoReaAgents framework enables real-time adjustments to task planning during execution, significantly improving the success rate of complex tasks.

4.4.5. Limitations

Although the CoReaAgents framework performs well in several complex reasoning tasks, it is not without limitations. As shown in Figure 11, first, the performance of the framework relies heavily on the quality and reliability of the tools provided. If the tools themselves are vulnerable or flawed, this may negatively impact the stability and accuracy of the overall system. Second, the CoReaAgents framework may make errors in selecting tools when there are multiple tools of similar usefulness. In addition, when an instruction fails to state explicit requirements for the CoReaAgents framework, i.e., when the CoReaAgents framework is asked to select parameters on its own, it may make errors during parameter passing, especially when confronted with novel or unseen task types. Nevertheless, we plan to further explore ways to improve the robustness of the system in future research.

5. Conclusions

In this paper, we introduce CoReaAgents, a collaboration and reasoning framework based on LLM-powered agents. This framework simulates social division and cooperation to enhance LLMs’ reasoning and complex task execution capabilities, using a meticulously assembled team of diverse agents, including the Plan Agent, the Tool Agent and the Reflect Agent. The Plan Agent functions as a precise task planner, responsible for task planning and decision making. The Tool Agent functions as a proficient tool user, performing tool augmentation for each tool in the relevant toolset and executing each subtask as a single-step reasoning task. The Reflect Agent functions as an objective task evaluator, performing subtask reflection and plan reflection during the task. Our framework includes multi-agent communication and negotiation mechanisms that facilitate effective exchange and feedback among different agents, addressing the limitations encountered in planning complex tasks that require iterative updates. We conducted experiments on a total of five datasets involving complex reasoning tasks, such as tool learning, math reasoning and multi-hop QA, and supplemented them with qualitative and quantitative analyses. The experiment results demonstrate the adaptability and effectiveness of the CoReaAgents framework in various types of complex tasks.

Additionally, we documented and analyzed the decisions of each agent during task planning, tool selection and result reflection through specific cases. We have provided users with a clear understanding that will help them trust and use our system. To ensure the safety of the system, we also introduced human supervision and intervention mechanisms that allow humans to intervene at critical decision points or when the system becomes abnormal. We developed a program that allows supervisors to monitor the operational status of the system in real time and manually adjust task planning or tool selection if necessary.

6. Future Work

While the CoReaAgents framework has achieved comparative results on several complex tasks, there is still room for improvement in this work. In this paper, we performed experimental comparisons across multiple tasks. However, comparisons with other multi-agent frameworks remain to be conducted. Looking forward, we intend to carry out a more comprehensive comparative analysis. This will not only help to more fully illustrate the potential and advantages of the CoReaAgents framework but also further research into multi-agent systems. Affected by the diversity of complex tasks and datasets, each agent of the CoReaAgents framework needs different prompting samples. We will further investigate the prompt generation method used in our framework, thus enhancing its flexibility and applicability to a wider range of complex tasks. Meanwhile, applying additional memory mechanisms could further improve our framework’s performance on complex reasoning tasks.