ReAct vs Plan-and-Execute¶

一句话：ReAct 是"边想边做"的思考-行动-观察循环，Plan-and-Execute 是"先规划后执行"的分步求解；企业级 Agent 通常用意图分类器在两者间动态切换，形成混合推理。

概念¶

ReAct（Reasoning + Acting） 由 LLM 在每一轮交替输出三段内容：

Thought（思考）：分析当前状态，决定下一步动作；
Action（行动）：调用一个外部工具（检索、查询、计算等）；
Observation（观察）：读取工具返回结果，喂回下一轮思考。

循环往复，直到 LLM 给出最终答案。它的优势是反应快、可纠错——每一步都能根据观测结果调整，适合简单查询和强反馈场景。

Plan-and-Execute（先规划后执行） 则先把任务拆成有序的子步骤清单，再依次执行：

Plan（规划）：LLM 一次性输出完整步骤列表（如"①查订单 ②查物流 ③计算运费 ④汇总"）；
Execute（执行）：按计划逐步调用工具或子 Agent；
（可选）Replan（重规划）：执行中若发现计划失效，重新生成计划。

它的优势是全局视野强、可控，适合需要多步且步骤间有依赖的复杂任务。

维度	ReAct	Plan-and-Execute
决策时机	每步即时决策	先规划再执行
适合任务	简单、单轮或弱依赖	复杂、多步、强依赖
Token 成本	步数不定，可能偏多	一次性规划，路径可控
纠错能力	强（每步反馈）	弱，需显式 replan
可解释性	中	高（有显式计划）

原理¶

企业实践中，单一范式都有短板：纯 ReAct 在多步任务里容易"走偏"且 Token 消耗大；纯 Plan-and-Execute 对简单查询又是杀鸡用牛刀。报告 §5.3 中彭超案例采用的 "ReAct + Plan-and-Execute 混合推理"，其核心就是一层意图分类器做动态路由：

简单查询（如"我的订单到哪了"）→ 走 ReAct，快速响应，延迟低；
复杂多步任务（如"帮我处理这笔退货并通知客户"）→ 走 Plan-and-Execute，拆解执行；
意图分类器可用一个轻量分类模型或规则 + LLM 混合实现，根据 query 复杂度、涉及系统数、是否含多约束等特征判分。

下面给出两种范式的最小实现骨架。

JavaPython

// LangChain4j 风格：ReAct 与 Plan-and-Execute 的混合路由
public class HybridAgent {

    private final ChatLanguageModel model;
    private final ToolRegistry tools;
    private final IntentClassifier classifier; // 意图分类器

    public String run(String userQuery) {
        // 1. 意图分类，动态切换范式
        Intent intent = classifier.classify(userQuery);
        if (intent == Intent.SIMPLE) {
            return react(userQuery);          // 简单查询走 ReAct
        } else {
            return planAndSolve(userQuery);   // 复杂任务走 Plan-Solve
        }
    }

    /** ReAct：思考-行动-观察循环 */
    private String react(String query) {
        ReActAgent agent = AiServices.builder(ReActAgent.class)
                .chatLanguageModel(model)
                .tools(tools.all())            // 注册全部可用工具
                .build();
        return agent.answer(query);
    }

    /** Plan-and-Execute：先规划后执行 */
    private String planAndSolve(String query) {
        // Step 1: Plan —— LLM 一次性产出步骤列表
        List<TaskStep> plan = model.generate(
            PromptTemplates.planPrompt(query, tools.descriptions())
        ).parseSteps();

        // Step 2: Execute —— 逐步执行（失败可触发 replan）
        StringBuilder ctx = new StringBuilder();
        for (TaskStep step : plan) {
            String result = executor.run(step, tools);
            ctx.append(step.summary()).append(" => ").append(result).append("\n");
        }
        // Step 3: 汇总
        return model.generate(PromptTemplates.summarize(query, ctx.toString()));
    }
}

# LangGraph 风格：混合推理状态图
from langgraph.graph import StateGraph, END
from typing import TypedDict, Literal

class AgentState(TypedDict):
    query: str
    intent: str
    plan: list[str]
    results: list[str]
    answer: str

def classify_node(state: AgentState) -> AgentState:
    # 意图分类器：简单 -> react，复杂 -> plan
    state["intent"] = classifier.predict(state["query"])
    return state

def route(state: AgentState) -> Literal["react", "planner"]:
    return "planner" if state["intent"] == "complex" else "react"

def react_node(state: AgentState) -> AgentState:
    # ReAct：思考-行动-观察循环
    state["answer"] = react_agent.run(state["query"], tools=tools)
    return state

def planner_node(state: AgentState) -> AgentState:
    # Plan-and-Execute Step1：生成计划
    state["plan"] = llm.invoke(plan_prompt(state["query"])).steps
    return state

def executor_node(state: AgentState) -> AgentState:
    # Plan-and-Execute Step2：逐步执行，可触发 replan
    for step in state["plan"]:
        state["results"].append(executor.run(step))
    state["answer"] = llm.invoke(summarize_prompt(state))
    return state

g = StateGraph(AgentState)
g.add_node("classify", classify_node)
g.add_node("react", react_node)
g.add_node("planner", planner_node)
g.add_node("executor", executor_node)
g.set_entry_point("classify")
g.add_conditional_edges("classify", route, {"react": "react", "planner": "planner"})
g.add_edge("planner", "executor")
g.add_edge("react", END)
g.add_edge("executor", END)
graph = g.compile()

实战要点¶

混合而非二选一：意图分类器是"混合推理"的关键，简单查询走 ReAct 保延迟（响应 < 800ms P95 的基础），复杂任务走 Plan-and-Execute 保可控。报告将"混合推理"列为 2026 前沿基线要素之一。
ReAct 要设循环上限：Thought-Action-Observation 循环必须有最大步数和超时，否则工具异常或 LLM 反复"思考"会拖垮延迟与 Token 成本。
Plan-and-Execute 要支持 replan：执行中某步失败或观测与预期不符时，应回退到规划阶段重拟计划，而非硬执行错误计划。
工具描述质量决定 ReAct 成败：ReAct 依赖 LLM 自主选工具，工具的 name/description/参数 schema 写得越清晰，选错工具概率越低（工具成功率 98% 的前提）。
可观测：每一步的 Thought/Action/Observation 都要落 Trace，既是调试依据，也是 CoT 归因、负样本挖掘的数据源。

本节相关题目¶

难度	题目	链接
基础	ReAct 的思考-行动-观察循环是什么	→ 题库
进阶	ReAct vs Plan-and-Execute 如何按场景选择、意图分类器如何切换	→ 题库
深度	设计企业级 Agent 平台如何落地混合推理	→ 题库