Planning: Breaking Tasks into Executable Steps

Responsible for formulating the Agent's action plan, including breaking complex tasks into multiple subtasks and determining subsequent execution steps. When processing multi-step tasks, an Agent not only needs to create an action plan but also needs to adjust based on task execution. For example, when tool results differ from expectations or when the information obtained is insufficient, the Agent can adjust the original plan and re-determine the next step. The Planning module enables the Agent to dynamically plan and adjust subsequent actions based on task state.

Memory: Remembering Task Progress and Needed Information

Used to store the Agent's memory, including short-term memory and long-term memory. Short-term memory primarily saves information from the current session or task, while long-term memory is used to save information that needs to be retained long-term. Memory is a dynamic, accessible, and updatable system. Dynamic means that memory can change with new information and task state; accessible means the Agent can retrieve and use stored information as needed; updatable means the Agent can supplement or modify existing memory based on new information and execution results. As memory continuously updates, the Agent can leverage interaction and task experience to improve subsequent judgments and decisions, enhancing its adaptability to different tasks and environments.

Tools: Enabling the Model to Actually Execute Operations

Various tools available to the Agent, including search engines, databases, calculators, code execution environments, and various external services provided through APIs. The core function of the Tools module is to extend the Agent's ability to interact with the external environment, enabling the Agent not only to generate content but also to obtain external information and execute specific operations.

When using the Tools module, the Agent needs to determine whether tools are needed based on the current task and context, and which tool to select. Effectively using tools not only means selecting the correct tool but also includes how to use tools efficiently to reduce unnecessary tool usage. When a task requires multiple tools working together, the Agent also needs to decide whether to continue calling other tools based on tool results, and integrate results from different tools. Therefore, the Tools module not only provides the Agent with external capabilities but also requires the Agent to select and use tools reasonably based on task needs.

An Agent is a system integrating LLM, Planning, Memory, and Tools, as shown in the diagram below. These modules work together to enable the Agent to autonomously execute tasks, learn, and improve its behavior.

After Receiving a Task, How Does an Agent Proceed Step by Step?

After receiving a task, an Agent needs to determine how to proceed based on the task objective and current information. For example, some tasks can call tools while determining the next step based on return results; some complex tasks require first breaking down steps and then executing them incrementally; for generated results, further checking and modification can be performed. When a single Agent cannot complete the entire task, multiple Agents can be assigned different roles to collaborate.

Based on task characteristics and execution methods, Agents can adopt different task execution modes. Below we introduce four common modes: ReAct, Plan-and-Execute, Reflection, and Multi-Agent Collaboration, which organize the Agent's task execution process from different aspects such as dynamic execution, task planning, result improvement, and task division.

ReAct Mode

ReAct (Reasoning and Acting) is a task execution approach that combines reasoning and action, proposed by Shunyu Yao et al. The large model reasons and takes action based on current information, then continues reasoning and acting based on new information obtained from the action, until the task is complete.

The typical ReAct process includes Thought (reasoning), Action (action), and Observation (observation). Thought represents the model analyzing current information to determine the next step; when external information needs to be obtained or an operation needs to be performed, the model generates the corresponding Action, such as calling a search tool or querying a database; the result returned by the tool is provided to the model as an Observation, and the model continues to make judgments based on this new information.

During task execution, Thought, Action, and Observation appear alternately based on task needs, forming an execution process where reasoning, action, and observation work together. The typical process can be expressed as:

Thought → Action → Observation → Thought → Action → Observation → ... → Final Result

For example, a user asks: "Who won the 2024 Nobel Prize in Physics? Which one is the oldest among them?"

The Agent first determines that it needs to obtain the list of 2024 Nobel Physics Prize winners, so it calls the search tool to query. After obtaining the list, it finds that it also needs to compare the winners' ages, so it continues to query their birth dates. After obtaining the required information, the Agent compares and generates the final answer.

In this process, the Agent did not determine all execution steps at the start of the task, but rather decided the next step based on each tool's return result. Therefore, ReAct is more suitable for tasks that require continuous interaction with the external environment, such as searching, querying, and tool calling. For complex tasks with many steps, if this step-by-step execution approach is used entirely, there may be missed steps or repeated execution paths.

Plan-and-Execute Mode

Plan-and-Execute divides complex task processing into two phases: planning and execution. After receiving a task, the Agent first analyzes the task objective and breaks down the steps to be completed, forming an overall plan, and then executes step by step according to the plan.

For example, a user requests: "Analyze the recent business performance of three new energy vehicle companies and create a comparative report." This task involves multiple steps including data collection, data organization, comparative analysis, and report generation. For such multi-step tasks, a plan can first be created as follows:

1. Identify the three companies to compare;
2. Collect each company's business data from the past year;
3. Organize key indicators such as sales volume and revenue;
4. Compare each company's business performance;
5. Summarize differences and generate the report.

After the plan is formed, the Agent completes the tasks sequentially. When executing a step, it can still call search, database, or other tools. If it is found during execution that the original plan cannot continue, or if new task requirements emerge, the original plan can be adjusted.

The typical execution process of Plan-and-Execute can be expressed as:

User Task → Create Plan → Execute Step by Step → Check Task Status → Final Result

Where, when checking task status, if the original plan needs adjustment, re-planning can be done before continuing execution.

Compared to ReAct, Plan-and-Execute emphasizes creating an overall plan before execution, making it suitable for tasks with many steps, clear objectives, and the ability to be broken down in advance. The two modes can also be combined, for example, using Plan-and-Execute to plan complex tasks, and then using ReAct within individual steps to dynamically determine the next operation based on tool return results.

Reflection Mode

The results generated by an Agent the first time may not necessarily meet task requirements. For example, the generated report may miss important information, answers may contain factual errors, or code may not run properly. For such tasks, a checking and improvement process can be added based on preliminary results — this is the basic idea of the Reflection (reflection) mode.

The basic Reflection process can be expressed as: User Task → Generate Preliminary Results → Check Results → Identify Issues → Modify Results → Check Again → ... → Meet Requirements → Final Result.

For example, let an Agent generate a product comparison report based on multiple sources. After completing the first draft, you can further check whether all products that need comparison are covered, whether product parameters are consistent with the original sources, and whether important differences are missed. If incomplete information is found for a product, you can re-search for materials and supplement; if conclusions are inconsistent with the sources, they need to be revised.

In this process, the feedback used to check results can come from different sources. The Agent can check its own execution results, use other Agents or models for evaluation, or combine rules, knowledge bases, or manual review to provide feedback.

This mode is more suitable for tasks with high quality requirements such as report generation, code writing, and complex analysis. However, multiple checks and modifications will also increase the number of model calls and execution time, so in practice, termination conditions are usually set, such as ending when results meet requirements or stopping after reaching the maximum number of checks.

Multi-Agent Collaboration Mode

For some complex tasks, a single Agent may need to simultaneously handle data collection, data analysis, content generation, and result checking. In this case, tasks can be assigned to multiple Agents, each handling different parts, and then collaborating to complete the final goal. Multi-Agent collaboration mainly includes two aspects: task division and information exchange.

When dividing tasks, different Agents are assigned different roles, tasks, tools, and knowledge. For example, to complete an industry research report, a Research Agent, Data Analysis Agent, Writing Agent, and Review Agent can be set up. The Research Agent is responsible for collecting and organizing materials, the Data Analysis Agent processes relevant data, the Writing Agent generates the report, and the Review Agent checks the report.

In terms of information exchange, different collaboration methods can be used among multiple Agents. For tasks that can be clearly divided, multiple Agents can handle different subtasks separately, and results can be aggregated at the end; for tasks with sequential dependencies, one Agent's result can be passed to the next Agent for further processing; for tasks that require repeated discussion or modification, different Agents can exchange information through message interactions. Additionally, a coordinating Agent can be set up to decide which Agent should handle the task next based on the current situation.

Taking the generation of an industry research report as an example, a multi-Agent collaboration approach is shown in the diagram below:

Multi-Agent collaboration can reduce the difficulty of handling complex tasks for a single Agent through division of labor, but the number of Agents is not necessarily better. As the number of Agents increases, task assignment, information delivery, and result coordination also become more complex, while increasing model calls and execution costs. Therefore, for tasks that a single Agent can complete, there is usually no need to introduce multiple Agents.

These task execution modes are not independent of each other and can be combined based on task needs in practical applications. For example, Plan-and-Execute can be used to plan complex tasks, then ReAct can be used to complete steps that require multiple tool calls, with Reflection checking and improving results; for larger-scale tasks, different subtasks can be assigned to multiple Agents to collaborate on completion.