Agent 推理范式 ReAct Reflexion Plan-and-Execute

你的客服 Agent 在一次对话里烧了 47000 个 token,把同一个 search_knowledge_base 连着调了 73 次——这是 2026 年一个真实的生产事故。根因不在模型不够聪明,而在你给它套的那个推理循环:observation 没能改变它的下一步 reasoning,于是它原地打转。

Agent 的「聪明」一半来自模型,另一半来自你怎么组织它「想—做—观察」的节奏。这个节奏,就是推理范式。

一句话概括:推理范式不是让模型更聪明,而是决定它「怎么把想和做编排起来」——ReAct 是走一步看一步,Plan-and-Execute 是先画地图再上路,Reflexion 是摔了一跤记住教训再来。选错范式,再强的模型也原地打转。

这篇把主流范式讲透:核心机制、什么时候用、什么时候别用、成本画像、真实失败模式,最后回答 2026 年最关键的一个问题——有了会「深度思考」的推理模型,我还要不要手写 ReAct 循环? 全程配可运行的 Go 代码,三种范式跑在同一道题上,你能亲眼看见它们控制流的差别。


一、一条演进主线:从「只会想」到「边想边做边记」

先把脉络理清楚,你才知道每个范式在解决前一个的什么毛病。

graph LR
    A["CoT
只会想"] --> B["ReAct
加行动+接地"] B --> C["Reflexion
加跨轮记忆"] B --> D["Plan-and-Execute
解耦规划"] C --> E["ToT / LATS
加搜索深思"] D --> E

记住这条主线,后面每个范式都是在补前一个的短板。


二、ReAct:走一步看一步

核心机制:Thought → Action → Observation 三步一个循环,滚动到模型给出最终答案为止。Thought 决定下一步干什么,Action 调用工具,Observation 是工具的真实返回,喂回去影响下一轮 Thought。

这是第 02 篇手写的那个 Agent 循环,也是今天绝大多数 Agent 的底座。

看代码——ReAct 就是一个 for 循环,工具结果直接进下一轮:

func runReAct() (string, error) {
    messages := []Message{
        {Role: "system", Content: "你是一个会用工具的助手。需要算数时调用 calculate 工具,不要心算。"},
        {Role: "user", Content: task},
    }
    tools := []Tool{calcTool}
    for i := 0; i < 8; i++ {
        resp, err := callLLM(messages, tools)
        if err != nil {
            return "", err
        }
        choice := resp.Choices[0]
        messages = append(messages, choice.Message)
        if choice.FinishReason != "tool_calls" || len(choice.Message.ToolCalls) == 0 {
            return choice.Message.Content, nil // 模型给出最终答案,循环结束
        }
        for _, tc := range choice.Message.ToolCalls {
            out := runCalc(tc.Function.Arguments)
            // Observation 直接喂回,影响下一轮 Thought
            messages = append(messages, Message{Role: "tool", ToolCallID: tc.ID, Content: out})
        }
    }
    return "", fmt.Errorf("超过最大轮数")
}

何时用:需要对每一步结果做出反应的任务——搜索、浏览网页、fact-checking、需要实时数据和可解释轨迹的场景。
何时别用:能提前拆成清晰顺序步骤的任务(那是 Plan-and-Execute 的活);纯推理任务(那是 CoT/推理模型的活)。

成本画像:token 密集。每一轮都把全部历史重新喂进去做推理,一个 Agent 比普通聊天多约 4 倍 token,多 Agent 系统能到 15 倍。

真实失败模式(2026 生产环境里最常踩的):

失败模式 现象 根因
死循环 同一个工具连调 73 次,烧 47000 token observation 没有改变 reasoning
复合错误 单步 90% 准确,10 步端到端只剩 ~35% 每步误差累乘
目标漂移 长 workflow 里静默偏离原始目标 context 变长后"记忆腐烂"(context rot)
静默失败 status 200、格式正确、结果是错的 坏工具输出进了推理链,模型幻觉出占位数据

所以 ReAct 的真正手艺不在 prompt,在护栏:max iteration 上限、wall-clock 超时、连续错误熔断、把工具的真实错误信息透传给模型(别吞成通用 "Error occurred")。


三、Plan-and-Execute:先画地图,再上路

核心机制:把 Agent 拆成两个角色——Planner 一次性把任务分解成有序步骤(只规划,不执行),Executor 拿着计划逐步执行。

为什么要拆开?三个理由:

代码分两段——先规划:

// 第一步:Planner 一次性把任务拆成有序步骤(不执行,只规划)。
planResp, _ := callLLM([]Message{
    {Role: "system", Content: `你是规划器。把用户任务拆成有序的计算步骤,只输出 JSON:{"steps":["第一步...","第二步..."]},不要执行。`},
    {Role: "user", Content: task},
}, nil)
var pl plan
json.Unmarshal([]byte(extractJSON(planResp.Choices[0].Message.Content)), &pl)

再逐步执行,前一步结果串进下一步:

// 第二步:Executor 拿着计划逐步执行,前一步结果串进下一步。
var scratch string
for i, step := range pl.Steps {
    messages := []Message{
        {Role: "system", Content: "你是执行器。只执行当前这一步,需要算数就调 calculate。已知前序结果:" + scratch},
        {Role: "user", Content: fmt.Sprintf("第 %d 步:%s", i+1, step)},
    }
    // ...执行、把结果累加进 scratch...
}

何时用:能提前分解的顺序任务、研究报告生成(research→outline→draft→review)、长任务省 token。
何时别用:需要对中间结果实时反应的探索型任务(复杂问答搜索还是 ReAct 强)。

成本画像:长任务比 ReAct 省 token。进阶变体 LLMCompiler 让 Planner 直接产出任务 DAG、按依赖并行执行,论文报告约 3.6 倍加速。

失败模式:刚性。早期步骤失败或环境变了,原计划就失效——所以必须配 re-planning(执行到一半发现不对,回去重新规划)。整体效果高度依赖初始计划质量,第一步错了会一路传下去。


四、Reflexion:摔一跤,记住教训再来

核心机制:不更新模型权重,而是用语言做强化。三个模块协作——Actor(解题,可以是 CoT 也可以是 ReAct)、Evaluator(给结果打分)、Self-Reflection(把失败原因写成一段反思文本,存进 episodic memory)。下一次 Actor 带着历史反思重新解题。

关键前提:得有明确的成败信号(单元测试、编译器、精确答案、环境 reward)。没有信号,Evaluator 就打不了分,Reflexion 就退化成瞎重试。

代码里,我用一道答案可被程序精确校验的题,Evaluator 就是一个 math.Abs 比较:

var reflections []string // episodic memory:历次失败的反思
for trial := 1; trial <= 3; trial++ {
    // Actor:带着历史反思重新解题
    sys := "你是解题者。直接给出最终数字答案,只回数字。"
    if len(reflections) > 0 {
        sys += "\n以下是你之前失败的反思,务必吸取:\n- " + strings.Join(reflections, "\n- ")
    }
    resp, _ := callLLM([]Message{{Role: "system", Content: sys}, {Role: "user", Content: task}}, nil)
    got := parseNumber(resp.Choices[0].Message.Content)

    // Evaluator:程序精确校验,这就是「成败信号」
    if math.Abs(got-wantAnswer) < 0.5 {
        return resp.Choices[0].Message.Content, nil // 对了,收工
    }

    // Self-Reflection:让模型对自己的失败生成反思,存进记忆
    refResp, _ := callLLM([]Message{
        {Role: "system", Content: "你是反思器。针对下面这次错误答案,用一句话指出可能哪一步算错了、下次该怎么改。"},
        {Role: "user", Content: fmt.Sprintf("题目:%s\n我的错误答案:%v\n正确答案:%g", task, got, wantAnswer)},
    }, nil)
    reflections = append(reflections, refResp.Choices[0].Message.Content)
}

论文实证:带 self-reflection 比只有 episodic memory 再高 8 个百分点——证明「有反思引导的重试」明显强于「无脑重试」。

何时用:可多次重试、有明确反馈信号的任务,尤其代码生成(跑测试→失败→反思→重写)、序列决策。
何时别用:单次机会、无法重试的任务;没有清晰成败信号的开放任务。

成本画像:多 trial 意味着成本成倍(每次失败要重跑 + 反思),但比起用 RL 微调权重,便宜得多——这正是它的核心卖点。

失败模式:高度依赖反馈质量。反馈信号弱或本身就错时,反思会强化错误方向,越反思越偏。


五、搜索型深思:ToT / GoT / LATS(了解即可)

当任务有多条解路、需要探索和回溯时,把线性推理升级成搜索:

范式 结构 外部反馈 自反思 代价 代表战绩
Tree of Thoughts 树,可回溯 无 无 高 Game of 24:CoT 4% → 74%
Graph of Thoughts 图,可合并路径 无 无 高 需聚合多推理路径时
LATS 树(MCTS) 有 有 5–20× LLM 调用 HumanEval pass@1 ~92%,HotPotQA 翻倍于 ReAct

LATS 是集大成者——把 MCTS 搜索 + 价值函数 + 自反思 + 环境反馈统一进一个循环,本质是 ReAct + Reflexion + ToT 的合体。但代价是 5 到 20 倍的 LLM 调用。除非任务确实需要战略级探索且预算充足,否则别上——简单线性任务用 ToT/LATS 是杀鸡用牛刀。


六、2026 的关键问题:有了推理模型,还要不要手写 ReAct?

这是本篇最该讲清楚的一点。

2024 年起模型分化成两类:快模型(GPT-4o、Claude Sonnet)仍靠 prompt 引导推理;推理原生模型(o 系列、Claude extended thinking)把 CoT 内化进架构,有几千 token 的内部思考预算,不需要你手写 "让我们一步步想"。

于是很多人问:推理模型是不是取代了 ReAct 循环?

答案是:这是个伪命题。 两者是互补,不是二选一。

Anthropic 在《Building Effective Agents》里的立场也印证这点:从最简单的方案开始,只在明确必要时加复杂度;区分 workflow(预定义代码路径编排)和 agent(LLM 动态决定流程);用 interleaved thinking(让模型在工具调用之间思考)把 ReAct 的 Thought 步骤原生吸收进来。

主流工程模式:推理模型当 Planner 产出多步方案 → 每步选合适的模型当 Doer(高智能的贵模型 or 低延迟的便宜模型)。进阶玩法:快模型跑主循环(10+ 次工具调用),不确定时升级到推理模型深思一次、更新理解,再切回快循环。


七、选型指南:一张表定方案

任务特征 选 理由
需要边做边看、实时取数、可解释 ReAct 走一步看一步,observation 影响下一步
能提前拆成清晰顺序步骤、长任务 Plan-and-Execute 先规划省 token,大模型规划小模型执行
子任务相互独立、想并行提速 LLMCompiler 任务 DAG 并行,~3.6× 加速
可重试 + 有明确成败信号(代码/数学) Reflexion 失败写反思,带记忆重试
多解路径、需战略探索、预算充足 ToT / LATS 搜索+回溯,但 5–20× 成本
单次闭合推理,无需外部数据 CoT / 推理模型 不必套循环

决策口诀:


八、动手:三种范式跑同一道题

配套代码在 reasoning-paradigms。任务是一道分步应用题(笔记本打折叠券再乘数量),答案可被程序精确校验。

cd code/reasoning-paradigms
export OPENAI_API_KEY=sk-...
go run .            # 依次跑三种范式做对比
go run . reflexion  # 单跑一种:react | plan | reflexion

你会看到三种截然不同的控制流:ReAct 一个循环里 Thought/Action/Observation 交替;Plan-and-Execute 先打印出完整计划再逐步执行;Reflexion 在答错时打印出反思、带着反思重试。同一道题,同一个模型,范式不同,节奏完全不同——这就是推理范式的意义。


小结

推理范式的本质,是你怎么编排模型的「想」和「做」。ReAct 走一步看一步,适合需要接地和实时反应的任务,但要用护栏防死循环;Plan-and-Execute 先规划再执行,适合可预分解的长任务,但要配 re-planning 防刚性;Reflexion 靠失败记忆重试,适合有成败信号的可重试任务;ToT/LATS 是搜索型深思,强但贵。

2026 年最重要的认知转变:别把「手写 ReAct」和「用推理模型」对立起来——用原生 tool-calling 实现 ReAct 模式,让推理模型跑在循环里,把工程精力投在工具错误处理、迭代上限、状态记忆和停止条件上。停止条件和护栏,才是真正的手艺。


参考资料

资料 来源
ReAct: Synergizing Reasoning and Acting in LLMs arXiv:2210.03629
Reflexion: Language Agents with Verbal Reinforcement Learning arXiv:2303.11366
Plan-and-Act: Improving Planning of Agents for Long-Horizon Tasks arXiv:2503.09572
Language Agent Tree Search (LATS) arXiv:2310.04406
Chain-of-Thought Prompting Elicits Reasoning in LLMs arXiv:2201.11903
Building Effective Agents / Extended thinking anthropic.com/engineering
Plan-and-Execute Agents langchain.com/blog/planning-agents
本篇配套代码 github.com/hua-ri/agent-learning /main/reasoning-paradigms