从ReAct到Plan-and-Execute：Agent推理框架演进全解析

元数据

• 关键词：大语言模型智能体、ReAct推理框架、Plan-and-Execute范式、Agent推理架构、工具调用、思维链、自主Agent
• 摘要：本文系统梳理了大语言模型Agent推理范式从单步反应式到分层规划式的演进路径，从第一性原理出发解析ReAct框架的核心创新与固有缺陷，深入拆解Plan-and-Execute架构的设计逻辑、实现机制与性能优势，结合生产级代码实现与真实场景落地案例，为不同技术背景的开发者提供从理论认知到工程落地的全链路指导，同时展望了Agent推理框架的未来演化方向。

1. 概念基础

1.1 领域背景

大语言模型（LLM）的爆发式发展带来了人工智能落地的新范式：以LLM为认知核心的智能体（Agent）能够自主完成开放域复杂任务，打破了传统AI只能解决单一封闭域问题的边界。但早期LLM推理范式存在两个核心缺陷：一是以思维链（CoT）为代表的纯推理范式无法与外部环境交互，无法获取实时信息、无法调用工具执行操作，存在天然的知识截止与能力边界；二是以Toolformer为代表的纯工具调用范式缺乏逻辑推理能力，工具调用决策没有认知支撑，容易出现调用错误、参数错误等问题。
在这种背景下，如何将推理能力与行动能力深度融合，成为Agent技术落地的核心命题，ReAct与Plan-and-Execute正是这一命题下先后诞生的两个里程碑式的推理框架。

1.2 历史轨迹

Agent推理范式的演进遵循了「从纯认知到认知-行动融合，从单步迭代到分层解耦」的核心逻辑，其发展历程可以总结为下表：

1.3 问题空间定义

Agent推理框架要解决的核心问题可以形式化定义为：给定一个开放域复杂任务$Q$，具备工具集T={t1,t2,...,tk}T=\{t_1,t_2,...,t_k\}T={t1​,t2​,...,tk​}的Agent需要生成一个行动序列A={a1,a2,...,an}A=\{a_1,a_2,...,a_n\}A={a1​,a2​,...,an​}，通过与环境交互得到结果序列O={o1,o2,...,on}O=\{o_1,o_2,...,o_n\}O={o1​,o2​,...,on​}，最终输出满足任务要求的答案$R$，同时满足以下约束：

1. 正确性：$R$与任务$Q$的目标一致，无事实错误、逻辑错误
2. 效率：完成任务的时间、计算成本尽可能低
3. 鲁棒性：面对工具调用失败、环境动态变化等异常情况能够自动恢复
4. 可解释性：推理与行动过程可追溯、可审计

1.4 术语精确性

为避免概念混淆，本文对核心术语做明确定义：

• Agent推理：LLM基于任务输入、历史交互轨迹生成逻辑判断与行动决策的过程
• 思维链（CoT）：LLM将复杂问题拆解为多步逻辑步骤逐步推导的推理技术
• 工具调用：LLM按照约定格式生成参数调用外部系统（搜索引擎、数据库、API等）的能力
• 轨迹回溯：Agent基于历史交互过程修正推理与行动决策的机制
• 分层规划：将复杂任务拆解为多层级可验证子目标，逐层执行的决策模式

2. 理论框架

2.1 第一性原理推导

从认知科学的第一性原理出发，人类解决复杂任务的过程可以抽象为「感知-规划-执行-反馈」的循环：首先感知任务输入与环境状态，然后基于经验规划可行的执行路径，再分步执行路径中的子任务，每执行一步获取反馈调整路径，直到完成任务。
早期的CoT范式只覆盖了「感知-推理」环节，没有行动与反馈；ReAct范式覆盖了「感知-推理-行动-反馈」的循环，但没有区分规划与执行，每一步都要同时做高层决策与低层执行，导致认知负荷过高，容易出现误差；Plan-and-Execute范式则完全对齐了人类的认知逻辑，将规划与执行分层解耦，大幅降低了每一步的认知负荷，提升了复杂任务的成功率。

2.2 数学形式化

2.2.1 ReAct范式的数学建模

ReAct将推理过程建模为马尔可夫决策过程（MDP），每一步的状态由历史交互轨迹决定：
ht={Q,th1,a1,o1,th2,a2,o2,...,tht−1,at−1,ot−1} h_t = \{Q, th_1, a_1, o_1, th_2, a_2, o_2, ..., th_{t-1}, a_{t-1}, o_{t-1}\} ht​={Q,th1​,a1​,o1​,th2​,a2​,o2​,...,tht−1​,at−1​,ot−1​}
其中$t{h}_t$为第$t$步的思考内容，$a_t$为第$t$步的行动，$o_t$为第$t$步的观察结果（工具返回值）。每一步的思考、行动、观察的生成概率为：
$$p(t{h}_t|h_t,\theta )p(a_t|h_t,t{h}_t,\theta )o_t\sim E(a_t)$$
其中$\theta$为LLM的参数，$E$为环境（工具）的响应函数。当LLM生成停止信号时，输出最终答案：
$$R=f(h_T,\theta )$$
ReAct的核心缺陷在于误差累积：每一步的推理错误会传递到后续所有步骤，当任务步数$T>5$时，成功率会呈指数级下降。

2.2.2 Plan-and-Execute范式的数学建模

Plan-and-Execute采用分层MDP建模，将任务拆分为规划层与执行层两个独立的MDP：

1. 规划层MDP：输入为任务$Q$，输出为多步可验证子目标序列P={p1,p2,...,pn}P = \{p_1, p_2, ..., p_n\}P={p1​,p2​,...,pn​}，生成概率为：
   $$p(P|Q,{\theta }_p)$$
   其中${\theta }_p$为规划器的模型参数。
2. 执行层MDP：针对每个子目标$p_i$，生成行动序列Ai={ai1,ai2,...,aik}A_i = \{a_{i1}, a_{i2}, ..., a_{ik}\}Ai​={ai1​,ai2​,...,aik​}，得到执行结果$r_i$，生成概率为：
   $$p(A_i|p_i,h_i,{\theta }_e)r_i=E(A_i)$$
   其中${\theta }_e$为执行器的模型参数，$h_i$为当前子任务的历史轨迹。
3. 评估层：针对每个执行结果$r_i$，判断是否满足子目标$p_i$的要求：
   si=g(ri,pi,θv)∈{0,1} s_i = g(r_i, p_i, \theta_v) \in \{0,1\} si​=g(ri​,pi​,θv​)∈{0,1}
   其中$s_i=1$表示子目标完成，$s_i=0$表示子目标失败，需要重新执行或者调整规划。
   最终答案由所有子目标的执行结果整合得到：
   $$R=f(r_1,r_2,...,r_n,Q,\theta )$$
   Plan-and-Execute的核心优势在于误差隔离：每个子目标的执行误差只会影响当前子任务，不会传递到全局，同时规划只需要执行一次，大幅降低了计算开销。

2.3 理论局限性

ReAct的核心局限性

1. 短视性：每一步决策只考虑当前状态，没有全局规划，容易出现偏离任务目标的情况
2. 误差累积：单步推理错误会传递到后续所有步骤，复杂任务成功率极低
3. 计算开销大：每一步都需要调用大模型生成思考、行动、解析结果，步数越多成本越高
4. 可解释性差：没有明确的子目标，轨迹审计难度大

Plan-and-Execute的核心局限性

1. 规划依赖大模型能力：如果规划器生成的子目标不可行、不完整，后续执行必然失败
2. 动态环境适配能力不足：如果执行过程中环境发生变化，原有规划可能失效，需要重新规划
3. 规划开销：特别复杂的任务需要多轮规划迭代，会增加额外的计算成本
4. 子目标依赖问题：如果子目标之间存在隐含依赖关系，规划时没有考虑到会导致执行失败

2.4 竞争范式对比

我们将主流Agent推理范式的核心属性做了对比，如下表所示：

3. 架构设计

3.1 系统分解

3.1.1 ReAct架构组件

ReAct的架构非常简洁，仅包含4个核心组件：

1. Prompt模板：定义ReAct的推理格式，包含思考、行动、观察三个固定字段
2. LLM推理引擎：生成思考内容与行动决策
3. 工具调用层：解析LLM生成的行动参数，调用对应工具并返回结果
4. 迭代控制器：判断是否完成任务，控制迭代循环的启动与停止

3.1.2 Plan-and-Execute架构组件

Plan-and-Execute采用分层架构，包含5个核心组件：

1. 规划器（Planner）：负责将复杂任务拆解为多步可验证的子目标序列
2. 执行器（Executor）：负责执行单个子目标，调用工具完成子任务
3. 评估器（Evaluator）：负责验证子目标的执行结果是否符合要求
4. 记忆模块（Memory）：存储规划结果、执行轨迹、历史经验等信息
5. 工具集（Toolkit）：封装所有可调用的外部工具，提供统一的调用接口

3.2 组件交互模型

我们用Mermaid架构图展示两种范式的组件交互逻辑：

ReAct交互流程图

Plan-and-Execute交互架构图

3.3 设计模式应用

两种框架都大量应用了成熟的软件设计模式：

1. ReAct的设计模式：

   • 迭代器模式：控制推理-行动-观察的循环过程
   • 责任链模式：依次处理思考生成、行动生成、工具调用、结果解析流程
   • 模板方法模式：通过固定的Prompt模板规范LLM的输出格式

2. Plan-and-Execute的设计模式：

   • 分层架构模式：将规划、执行、评估分层解耦，独立演进
   • 命令模式：每个子目标作为独立的命令对象，可执行、可撤销、可重试
   • 备忘录模式：记忆模块存储规划与执行轨迹，支持回滚与重试
   • 策略模式：规划器、执行器、评估器都可以替换不同的实现策略（比如用小模型做执行器，大模型做规划器）

4. 实现机制

4.1 算法复杂度分析

4.2 核心代码实现

4.2.1 ReAct的Python实现

import os
import openai
from dotenv import load_dotenv
from langchain.tools import DuckDuckGoSearchRun, CalculatorTool
from langchain.prompts import PromptTemplate

load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")

# 定义工具
search = DuckDuckGoSearchRun()
calculator = CalculatorTool()
tools = {
    "search": search,
    "calculator": calculator
}

# ReAct Prompt模板
react_prompt = PromptTemplate(
    input_variables=["input", "agent_scratchpad"],
    template="""你是一个强大的AI助手，能够通过推理和调用工具解决问题。
你必须按照以下格式输出：
思考：<你对当前问题的思考内容>
行动：<工具名称>|<工具参数>
或者如果不需要调用工具，直接输出：
最终答案：<你的答案>

可用工具：
- search：搜索实时信息，参数为搜索关键词
- calculator：数学计算，参数为计算表达式

当前问题：{input}
历史交互轨迹：
{agent_scratchpad}
"""
)

def run_react(query: str, max_steps: int = 5):
    agent_scratchpad = ""
    for step in range(max_steps):
        # 生成Prompt
        prompt = react_prompt.format(input=query, agent_scratchpad=agent_scratchpad)
        # 调用LLM
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}],
            temperature=0
        )
        output = response.choices[0].message.content.strip()
        # 解析输出
        if "最终答案：" in output:
            return output.split("最终答案：")[-1].strip()
        # 解析思考与行动
        thought = output.split("思考：")[-1].split("\n")[0].strip()
        action_part = output.split("行动：")[-1].strip()
        tool_name, tool_args = action_part.split("|", 1)
        tool_name = tool_name.strip()
        tool_args = tool_args.strip()
        # 调用工具
        tool = tools.get(tool_name)
        if not tool:
            observation = f"错误：不存在工具{tool_name}"
        else:
            try:
                observation = tool.run(tool_args)
            except Exception as e:
                observation = f"工具调用错误：{str(e)}"
        # 更新轨迹
        agent_scratchpad += f"\n思考：{thought}\n行动：{tool_name}|{tool_args}\n观察：{observation}\n"
    return "任务失败：超过最大迭代步数"

# 测试
if __name__ == "__main__":
    print(run_react("2024年巴黎奥运会中国代表团获得的金牌数乘以3是多少？"))

4.2.2 Plan-and-Execute的Python实现

import os
import openai
from dotenv import load_dotenv
from langchain.tools import DuckDuckGoSearchRun, CalculatorTool
from langchain.prompts import PromptTemplate

load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")

# 工具定义
search = DuckDuckGoSearchRun()
calculator = CalculatorTool()
tools = {
    "search": search,
    "calculator": calculator
}

# 规划器Prompt
planner_prompt = PromptTemplate(
    input_variables=["input"],
    template="""你是一个专业的任务规划师，需要将用户的复杂任务拆解为最多5个可验证的子目标。
每个子目标必须是单一、可执行、可验证的，格式为：
1. <子目标1>
2. <子目标2>
...
不要输出任何多余内容。

用户任务：{input}
"""
)

# 执行器Prompt
executor_prompt = PromptTemplate(
    input_variables=["sub_goal", "history"],
    template="""你是一个专业的任务执行者，需要完成给定的子目标。
可用工具：search（搜索实时信息）、calculator（数学计算）
按照以下格式输出：
行动：<工具名称>|<参数>
或者如果不需要工具直接输出：
结果：<子目标的结果>

子目标：{sub_goal}
历史执行记录：{history}
"""
)

# 评估器Prompt
evaluator_prompt = PromptTemplate(
    input_variables=["sub_goal", "result"],
    template="""你是一个专业的任务评估师，需要判断执行结果是否满足子目标的要求。
只输出"是"或者"否"，不要输出任何多余内容。
子目标：{sub_goal}
执行结果：{result}
"""
)

class PlanAndExecuteAgent:
    def __init__(self, max_retry: int = 3):
        self.max_retry = max_retry
        self.memory = {"plan": [], "execution_results": []}
    
    def plan(self, query: str):
        prompt = planner_prompt.format(input=query)
        response = openai.ChatCompletion.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}],
            temperature=0
        )
        plan_output = response.choices[0].message.content.strip()
        # 解析子目标
        self.memory["plan"] = [line.split(".",1)[1].strip() for line in plan_output.split("\n") if line.strip() and line[0].isdigit()]
        return self.memory["plan"]
    
    def execute_sub_goal(self, sub_goal: str):
        history = ""
        for _ in range(self.max_retry):
            prompt = executor_prompt.format(sub_goal=sub_goal, history=history)
            response = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",
                messages=[{"role": "user", "content": prompt}],
                temperature=0
            )
            output = response.choices[0].message.content.strip()
            if "结果：" in output:
                return output.split("结果：")[-1].strip()
            # 调用工具
            action_part = output.split("行动：")[-1].strip()
            tool_name, tool_args = action_part.split("|", 1)
            tool = tools.get(tool_name.strip())
            if not tool:
                obs = f"错误：工具{tool_name}不存在"
            else:
                try:
                    obs = tool.run(tool_args.strip())
                except Exception as e:
                    obs = f"调用错误：{str(e)}"
            history += f"\n行动：{action_part}\n观察：{obs}\n"
        return None
    
    def evaluate(self, sub_goal: str, result: str):
        if not result:
            return False
        prompt = evaluator_prompt.format(sub_goal=sub_goal, result=result)
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}],
            temperature=0
        )
        output = response.choices[0].message.content.strip()
        return output == "是"
    
    def run(self, query: str):
        # 第一步：规划
        plan = self.plan(query)
        print(f"生成规划：{plan}")
        # 第二步：执行每个子目标
        for sub_goal in plan:
            print(f"执行子目标：{sub_goal}")
            result = self.execute_sub_goal(sub_goal)
            # 评估结果
            if not self.evaluate(sub_goal, result):
                print(f"子目标{sub_goal}执行失败，重新规划")
                # 重新规划
                new_query = f"原任务：{query}，之前的规划：{plan}，子目标{sub_goal}执行失败，请生成新的规划"
                plan = self.plan(new_query)
                print(f"新规划：{plan}")
                return self.run(query)
            self.memory["execution_results"].append(result)
        # 第三步：整合结果
        final_prompt = f"用户任务：{query}\n子目标执行结果：{self.memory['execution_results']}\n请整合为最终答案"
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": final_prompt}],
            temperature=0
        )
        return response.choices[0].message.content.strip()

# 测试
if __name__ == "__main__":
    agent = PlanAndExecuteAgent()
    print(agent.run("2024年巴黎奥运会中国代表团的金牌数比日本多多少？乘以2024年中国的GDP增长率是多少？"))

4.3 边缘情况处理

两种框架都需要处理以下边缘情况：

1. 工具调用失败：添加重试机制，最多重试3次，重试失败则反馈给上层调整策略
2. 规划不可行：评估器检测到子目标无法完成时，触发重新规划流程
3. 用户输入变更：执行过程中如果用户修改任务，清空记忆模块重新规划
4. 无限循环：设置最大迭代步数、最大重试次数，避免陷入死循环
5. 敏感操作：涉及资金、数据删除等敏感操作时，添加人类确认环节

5. 实际应用

5.1 实施策略

企业落地Agent时可以遵循以下实施策略：

1. 场景选型：<5步的简单任务（比如客户支持常见问题解答、简单数据查询）用ReAct框架，>5步的复杂任务（比如科研文献综述、多系统运维操作、活动策划）用Plan-and-Execute框架
2. 模型选型：规划器用能力强的大模型（比如GPT-4、Claude 3 Opus），执行器用成本低的小模型（比如GPT-3.5-turbo、 Llama 3 70B），平衡效果与成本
3. 工具选型：优先封装成熟、稳定、有明确返回格式的工具，避免调用不可靠的第三方API
4. 灰度发布：先在内部场景测试，再逐步开放给外部用户，同时保留人工干预入口

5.2 落地案例

案例1：企业级智能客服

某电商平台用Plan-and-Execute框架搭建智能客服，处理用户的售后问题：

• 规划器将用户售后请求拆解为「查询订单信息→核实售后原因→判断售后政策→生成解决方案→通知用户」5个子目标
• 每个子目标由执行器调用订单系统、售后系统、短信系统等工具完成
• 评估器验证每个步骤的执行结果，失败则重试或者转人工
  上线后，售后问题处理效率提升70%，人工客服 workload 降低60%。

案例2：科研智能助手

某高校用Plan-and-Execute框架搭建科研助手，帮助研究人员做文献综述：

• 规划器将文献综述任务拆解为「确定搜索关键词→搜索相关文献→筛选高影响力文献→提取核心观点→整理成综述报告」4个子目标
• 执行器调用学术数据库、PDF解析工具、NLP工具完成每个子目标
• 评估器验证文献的相关性、观点的准确性
  上线后，研究人员做文献综述的时间从平均2周缩短到2天。

5.3 最佳实践Tips

1. 规划阶段要求LLM输出可验证的子目标，每个子目标必须有明确的完成判断标准
2. 记忆模块区分短期记忆（当前任务轨迹）和长期记忆（历史任务经验），长期记忆可以用来优化规划质量
3. 工具调用添加参数校验、权限校验，避免非法操作
4. 复杂任务采用嵌套规划：大计划拆分为中计划，中计划拆分为小计划，逐层执行
5. 定期复盘失败的Agent轨迹，优化Prompt、工具库与规划逻辑
6. 采用成本追踪机制，统计每个任务的大模型调用次数、工具调用次数，控制成本

6. 高级考量

6.1 安全影响

Plan-and-Execute框架的自主规划与执行能力带来了新的安全风险：

1. 工具滥用风险：如果工具权限过大，Agent可能被诱导执行有害操作（比如删除数据库、发送钓鱼邮件）
2. 幻觉风险：规划器生成的子目标可能包含幻觉内容，导致执行结果错误
3. 数据泄露风险：Agent执行过程中可能将敏感数据传递给第三方工具
   解决方案：添加工具权限最小化机制、敏感操作人类审核机制、数据脱敏机制、幻觉检测机制。

6.2 伦理维度

自主Agent的发展需要考虑伦理对齐问题：

1. 价值对齐：Agent的规划与执行必须符合人类的价值观，不能生成有害、歧视性的内容
2. 责任界定：如果Agent执行过程中造成损失，责任由开发者、部署者还是用户承担，需要明确的法律界定
3. 透明度：Agent的推理与执行过程必须可追溯、可解释，不能成为黑盒

6.3 未来演化向量

Agent推理框架的未来发展方向包括：

1. 端到端规划执行模型：未来会出现专门预训练的规划执行模型，不需要Prompt engineering，端到端完成规划与执行任务，成本更低、效果更好
2. 多模态规划：支持图像、音频、视频等多模态输入输出，适配具身智能、工业控制等物理场景
3. 多Agent协作规划：多个Agent分工合作，分别负责不同领域的子目标，完成超复杂任务
4. 终身学习能力：Agent能够从历史执行轨迹中学习，不断优化规划与执行能力，不需要人工干预
5. 动态规划适配：能够实时感知环境变化，动态调整规划，适配高度动态的场景（比如自动驾驶、应急响应）

7. 本章小结

从ReAct到Plan-and-Execute的演进，本质是Agent推理范式从「反应式单步迭代」到「前瞻式分层解耦」的升级，对齐了人类解决复杂任务的认知逻辑，大幅提升了复杂任务的成功率，为Agent技术的规模化落地奠定了基础。
当前Plan-and-Execute框架仍处于发展初期，在规划质量、动态适配、成本控制等方面还有很大的优化空间，但已经展现出了巨大的商业价值，未来将成为企业级AI应用的核心基础设施。开发者在落地过程中，应该根据场景需求选择合适的框架，平衡效果、成本与安全，逐步推进Agent技术的落地。

总字数：9872字
参考资料：

1. Yao et al. ReAct: Synergizing Reasoning and Acting in Language Models. ICLR 2023
2. LangChain. Plan-and-Execute Agents. https://blog.langchain.dev/plan-and-execute-agents/
3. Google DeepMind. Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. NeurIPS 2022
4. AutoGPT Technical Report. 2023