06-Agent Patterns
06-Agent Patterns
24-从Agent Loop到Patterns
前面五个模块,我们从 Agent 的基本概念出发,依次讲了工具调用、记忆系统、上下文工程,最后落到 Agent Loop(Runtime)。到这里,一个能跑起来的 Agent 已经成型了:它有一个循环,能调用工具,能维护记忆,能在上下文里做推理。
但当你真正去做项目开发时,你会发现:同样是 Loop,为什么有的 Agent 遇到复杂任务就陷入死循环,有的却能稳稳当当地跑完几十步?为什么有的 Agent 输出一次就交差,有的却能反复打磨直到满意?
差别不在 Loop 本身,而在 Loop 是怎么被组织的。这就是Agent架构模式要解决的问题。
常用的架构模式有四种:ReAct、Plan-And-Execute、Reflection、Multi-Agent,这节课,我们先做一个简单介绍,后续每一个模式我们用一篇文章详细介绍。
一、Agent Loop的不足
先看一个具体的任务,感受一下架构选择带来的差异。
假设我们要做一个 Agent,帮用户完成这样一件事:“调研一下 2026 年国产大模型在代码生成能力上的最新进展,对比 DeepSeek、Qwen、GLM 和 Kimi 的表现,最后生成一份带数据支撑的对比报告。”
这个任务有几个特点:信息不在模型内部,需要多次检索;步骤不止一步,涉及搜索、筛选、对比、写作;对最终输出质量有要求,不能随便糊弄。
如果用一个最朴素的 Loop 来做,循环调用模型、调工具、把结果塞回上下文,大概率会出问题。
模型可能在第一步就去搜了“国产大模型”,拿到一堆泛泛的结果,然后急急忙忙开始写报告,写到一半发现数据不够,又回头搜,搜完又忘了之前写了什么。最终要么循环次数爆掉,要么上下文塞满无关信息,输出质量惨不忍睹。
这不是 Loop 不够好,是 Loop 的组织方式不对。
接下来我们看四种不同的组织方式(即架构模式),分别怎么处理这个任务。
二、架构模式到底是什么
我们在模块五学的 Agent Loop,是一套通用的执行引擎。这个引擎本身不关心“模型应该先规划还是边做边想” “要不要自我反思” “是一个 Agent 还是多个 Agent 协作”。它只是一个“发请求→拿结果→执行→再发请求”的循环。
Agent 架构模式,是在这套基础循环之上,组织「模型怎么决策」和「任务怎么切分」这两件事的固定套路。 它回答的就是两个问题:
- 下一步该怎么定?是模型走一步看一步,还是先定好整个计划再执行?
- 一个大任务怎么组织?是一个循环从头做到尾,还是拆成规划、执行、检查几个阶段,或者分给几个不同的 Agent?
如果你写过后端,可以把这件事直接类比成设计模式。
Agent 架构模式,就像你熟悉的策略模式、责任链模式、观察者模式,它们都不是某个具体的功能,而是对反复出现的一类问题的抽象解法。
在后端里,策略模式解决“算法可替换”,责任链解决“请求沿链传递”,观察者解决“状态变化后通知多方”。它们不绑定 Java、Spring 还是 Go,也不改变数据库、事务、日志这些底层设施。
Agent 架构模式同理:ReAct 解决“边想边做、动态调整”,Plan-and-Execute 解决“先有全局计划、再约束执行”,Reflection 解决“生成后如何批判和迭代”,Multi-Agent 解决“单个 Agent 的上下文、角色和工具集过大问题”。它们不绑定 LangGraph 或任何 SDK,也不改变 Runtime 里的工具校验、循环退出、错误写回和人工审批等基础功能。
设计模式有几个特点,Agent 模式也一样:
第一,它们描述的是结构,不是业务逻辑;
第二,它们都有代价。策略模式减少 if-else 但增加类数量,观察者解耦但让调用链更难追踪。同理,ReAct 灵活但容易局部打转,Reflection 提升质量但 token 翻倍,Multi-Agent 分工但通信和状态同步变复杂;
第三,它们可以组合。设计模式组合使用很常见,同理,Plan-and-Execute 外层加 ReAct 执行器、再套一层 Reflection 也很常见;
第四,误用比不用更糟。我们反复提醒不要为了使用设计模式而使用设计模式,这是过度设计,同理,Agent 里为了使用架构模式而使用架构模式,会让成本和复杂度失控。因此,学 Agent 架构模式,要像学设计模式一样,掌握三件事:它解决什么问题、付出什么代价、什么时候不该用。
三、架构模式一:ReAct
ReAct 的核心思路可以用一句话概括:让模型在每一步都先“想一下” 再 “做一下”,拿到结果后再 “想一下”,如此循环。
这里的“想”,在工程实现上就是让模型输出一段推理文本(Thought),告诉系统它为什么要做下一步。“做”就是输出一个工具调用提议。“拿到结果”就是把工具返回的内容作为 Observation 追加到上下文。
回到调研报告那个任务,如果用 ReAct 来做,Agent 的大致行为会是这样的:
- Thought:我需要先了解国产大模型代码生成能力的整体情况,搜索一个概括性的关键词。
- Action:搜索“2026 国产大模型 代码生成 评测”
- Observation:返回了若干条搜索结果。
- Thought:这些结果里提到了 DeepSeek 和 Qwen,但 GLM 和 Kimi 的信息不够,我需要单独搜一下。
- Action:搜索“GLM 代码生成 2026”
- ……
每一步都是基于上一步的结果临时决定的,没有预先规划好的路线图。
ReAct 最大的优势是灵活。它不需要在开始时就搞清楚所有步骤,而是根据环境反馈动态调整。这种灵活性让它特别适合那些路径不确定的任务,比如开放式研究、故障排查、需要根据中间结果改变策略的探索性工作。
但它的问题也很明显。因为没有全局规划,模型很容易在局部打转。比如搜了三轮还在搜同一个维度的信息,因为它每一步只看到“当前还缺什么”,看不到“整体进度到哪了”。另外,每一步都要调用一次模型(生成 Thought 和 Action),步数一多,token 消耗和延迟就会线性增长。
ReAct 的本质 是:把“推理”和“行动”交织在同一个循环里,用推理指导行动,用行动的结果更新推理。
三、架构模式二:Plan-and-Execute
既然边做边想容易迷路,那能不能先想清楚再动手?这就是Plan-and-Execute的出发点。
Plan-and-Execute 把任务分成两个明确的阶段。第一阶段是规划:让模型基于用户的任务描述,生成一份完整的执行计划,通常是若干个子步骤的列表。第二阶段是执行:按计划逐步执行,每一步可以用一个独立的 Agent 或者工具调用来完成。
回到调研报告的任务,规划阶段可能会生成这样一份计划:
- 搜索 DeepSeek 最新代码生成能力的评测数据
- 搜索 Qwen 最新代码生成能力的评测数据
- 搜索 GLM 最新代码生成能力的评测数据
- 搜索 Kimi 最新代码生成能力的评测数据
- 整理四家的数据,生成对比表格
- 基于对比数据撰写分析报告
执行阶段就按这个列表一步步行事。如果某一步的结果不够理想(比如搜索结果太少),可以触发重规划,调整后续步骤。
Plan-and-Execute 的核心价值在于减少漂移。执行过程中,每一步都有明确的参照,不容易跑偏。这对于步骤多、依赖关系复杂的任务特别重要,比如报告生成、代码审查流水线、多步骤的数据处理。
代价也很直接:规划本身需要一次额外的模型调用,而且规划的质量高度依赖模型对任务的理解能力。如果规划阶段生成了一份糟糕的计划(比如遗漏了关键步骤,或者步骤粒度太粗),执行阶段就会忠实地执行一份错误的计划。此外,规划不是“一次性”的,如果执行中发现实际情况和规划时的假设不符,就需要额外的机制来处理(即重规划)。
还有一点值得注意:Plan-and-Execute 的执行阶段并不排斥 ReAct。实际上,很多生产系统会把两者组合起来,规划器生成宏观步骤,每个步骤的执行器内部用 ReAct 循环来灵活处理该步骤的具体操作。
四、架构模式三:Reflection
ReAct 和 Plan-and-Execute 解决的是“怎么做”的问题,Reflection 解决的是“做得对不对”的问题。
它的核心思路非常直接:Agent 完成一次输出后,不是直接返回,而是先对自己的输出做一次评估,找出问题,然后基于评估结果修改输出。这个过程可以重复多轮。
回到调研报告的任务,如果外层套了 Reflection,流程会是:
- ReAct 或 Plan-and-Execute 生成了一份初稿。
- 评估器检查初稿:数据来源是否可靠?四家的对比维度是否一致?有没有遗漏关键信息?结论是否有数据支撑?
- 评估器输出一份批判意见。
- 生成器基于批判意见修改初稿。
- 重复 2-4,直到达到质量阈值或最大迭代次数。
Reflection 最直接的代价是成本翻倍。每一轮反思至少需要一次额外的模型调用来做评估,如果还要修改,又是一次调用。一个三轮反思的 Agent,token 消耗可能是没有反思时的三到四倍。延迟也会显著增加。所以它不适合那些对速度敏感的场景,也不适合那些“答案对错很明确、一次就能做对”的任务,比如查天气、算数学题,反思并不会让结果更准,只会浪费 token。
Reflection 真正有价值的场景是那些质量维度模糊、需要多轮打磨的任务:写作、代码生成、复杂的分析报告、需要多角度验证的场景。
五、架构模式四:Multi-Agent
前面三种模式,不管怎么组织循环,本质上还是一个 Agent 在做事。Multi-Agent 的思路不同:它把任务拆给多个 Agent,每个 Agent 有自己的角色、工具和上下文,它们通过某种协作机制共同完成任务。
还是开头那个例子。与其让一个 Agent 既搜数据又写报告,不如拆成两个:一个“研究员 Agent”专门负责搜索和整理数据,一个“写作者 Agent”专门负责基于数据撰写报告。研究员把整理好的结构化数据交给写作者,写作者不需要关心搜索的细节,只需要聚焦写作。
这带来的好处是关注点分离。一个 Agent 的上下文窗口是有限的,如果什么都塞进去,注意力会被稀释,决策质量会下降。拆成多个 Agent 之后,每个 Agent 的上下文更聚焦,提示词更简单,工具集更小。
但 Multi-Agent 的代价也是四种模式里最大的。多个 Agent 之间的通信需要额外的机制:消息怎么传递、状态怎么同步、谁来协调、冲突怎么解决。这些问题在单 Agent 场景下根本不存在,在 Multi-Agent 场景下必须逐一处理。
用一句话总结一下,Multi-Agent 的本质是:用多个专业化 Agent 的分工协作,来突破单个 Agent 在上下文容量、能力范围和职责聚焦上的限制。
六、架构选型
知道了四种模式各自的特点,接下来的问题就是:实际开发中怎么选?
这里不展开完整的决策树(下一篇会详细讲每种模式的实现,最后一篇会专门讲选型),但可以给一个简化的判断顺序:
第一问:任务路径确定吗?
如果任务路径基本确定,比如“查天气→算温度差→给出穿衣建议”,每一步的依赖关系清晰,用 ReAct 就足够了。不需要预先规划,因为路径本身没有不确定性。
如果任务路径不确定,比如“帮我调研一下 X 主题”,不知道需要搜几轮、搜什么关键词、中间会发现什么,ReAct 也能用,但容易迷路。这时候可以考虑 Plan-and-Execute,先让模型生成一份粗略的步骤列表,再按步骤执行,中途根据情况重规划。
第二问:对输出质量的要求有多高?
如果输出质量要求高,而且有明确的“好/不好”的判断标准,可以在基础模式上加 Reflection。注意,加 Reflection 的前提是“评估标准是可操作的”,如果评估标准本身模糊(比如“写得好一点”),反思会变成随机修改。
第三问:单个 Agent 的上下文够用吗?
如果任务的上下文需求超出了单个模型的工作窗口,或者不同阶段需要不同的工具集和角色定位,考虑拆成 Multi-Agent。但拆之前先问自己:能不能通过更好的上下文管理和提示词设计,在单 Agent 内解决?Multi-Agent 的工程复杂度更高,能不加就不加。
还有一个经常被忽视的维度是失败成本的不对称性。如果 Agent 判断错了,代价是什么?查天气错了,用户笑一笑就过去了。但如果 Agent 在自动修改生产环境代码,一次错误的决策可能导致服务中断。对于失败成本高的场景,宁可多花成本加 Reflection 和验证环节,也不要追求“快”。
具体落地时,先从最简单的 ReAct 单循环做起,把任务跑通;等确实遇到了瓶颈,再有针对性地升级。 发现模型总走偏、丢目标,就加规划;发现产出质量不稳,就加反思;发现单个模型上下文扛不住、或者子任务能并行,就上多 Agent。每一次升级都对应一个你真实遇到的问题,而不是因为某个模式听起来更高级。这样做出来的系统,既够用,又不会把成本和复杂度做爆。
这里要强调一句:这四种模式不是互斥的单选题,恰恰相反,真实系统几乎都是它们的组合。 一个常见的组合方式是:外层用 Plan-and-Execute 做全局规划,每个计划步骤的执行器内部用 ReAct 来灵活处理具体操作,整体的输出再套一层 Reflection 做质量把关。如果某个步骤特别复杂,还可以把它拆成一个子 Multi-Agent 系统来处理。
本篇小结

25-ReAct
上一篇我们从整体上看了四种架构模式的全景,知道了 ReAct 是最基础、最广泛使用的一种。这一篇我们就深入 ReAct。
一、ReAct要解决的问题
ReAct 这个名称来自 2022 年的一篇论文,标题是 “ReAct: Synergizing Reasoning and Acting in Language Models”。
要理解 ReAct 为什么会出现,得先看在它出现之前的方法有什么问题。
在 ReAct 出现之前,让大模型解决复杂任务主要有两条路。
一条路是纯推理:让模型在内部把整个问题想清楚,然后直接输出答案。这就是 Chain-of-Thought 的做法。模型生成一系列推理步骤,最后给出结论。这条路的问题是,模型只能依赖自己训练时记住的知识,如果任务需要外部信息(比如查最新数据、调用某个 API),模型要么不知道,要么会编造一个看起来合理但实际错误的答案。
另一条路是纯行动:让模型直接输出要执行的动作,不解释为什么。比如给定一组工具,模型直接选一个调用,拿到结果后再选下一个。这条路的问题是,模型没有显式的推理过程来指导行动选择,容易在工具选择上犯错,而且一旦出错,调试时很难知道模型当时是怎么想的。
举个例子。用户问“北京今天适合穿什么?”,纯行动模式下模型不解释理由,直接选工具调用:
用户:北京今天适合穿什么?
Action: get_clothing_advice(city="北京", temperature=20)
Observation: {"advice": "建议穿薄外套"}
Final Answer: 建议穿薄外套。问题就藏在第一步:穿衣建议本该依赖今天的真实气温,但模型没有任何推理过程,直接把 temperature=20 这个参数凭空编了进去,它没去查天气,也没说明这个 20 是怎么来的。结果可能恰好不离谱,也可能完全不对,而你在日志里只看到一串动作,根本无法判断模型当时是不是在“瞎蒙”,更谈不上调试。
ReAct 的思路是把这两条路合在一起:让模型在每一步先输出一段推理(Thought),解释它为什么要做下一步,然后再输出一个动作(Action),系统执行这个动作后把结果(Observation)返回给模型,模型基于新的观察继续推理和行动。
还是上面那个问题,用 ReAct 来做,每一步都先写出 Thought 再给 Action:
用户:北京今天适合穿什么?
Thought: 用户要的是穿衣建议,而穿衣建议依赖今天的实际气温。我现在并不知道北京今天多少度,不能凭空假设,应该先查天气拿到真实温度,再据此给建议。
Action: get_weather(city="北京", date="2026-09-29")
Observation: {"temperature": "22°C", "condition": "晴", "humidity": "45%"}
Thought: 现在拿到了真实气温 22°C、天气晴,可以用这些数据调用穿衣建议工具了。
Action: get_clothing_advice(temperature=22, condition="晴")
Observation: {"advice": "建议穿薄外套或长袖衬衫"}
Thought: 已经得到基于真实天气的穿衣建议,可以回答用户了。
Final Answer: 北京今天气温 22°C、晴,建议穿薄外套或长袖衬衫。对比一下就能看出区别:纯行动里那个被凭空编出来的 temperature=20,在 ReAct 里被第一条 Thought 拦了下来,模型意识到“我还不知道温度”,于是先去查天气,拿到真实的 22°C 后才做建议。推理过程把“为什么这么做”显式写了出来,既避免了乱猜参数,也让整条轨迹可追踪、可调试。
这个设计看起来简单,但它解决了两个关键问题。第一,推理过程被显式地写出来了,模型的决策依据变得可追踪、可调试。第二,模型可以通过行动获取外部信息,不再完全依赖内部知识。把推理和行动交替进行,比单独做推理或单独做行动效果更好。
二、ReAct 的核心结构
ReAct 的基本循环可以用三个词概括:Thought、Action、Observation。
Thought 是模型输出的推理文本。它不执行任何操作,只是告诉系统(和读日志的人)模型当前在想什么。比如:“用户想知道北京今天的天气,我需要调用天气查询工具。”
Action 是模型决定要执行的动作。在工程实现上,它通常是一个结构化的输出,包含工具名称和参数。比如:{"tool": "get_weather", "params": {"city": "北京", "date": "2026-09-29"}}。
Observation 是系统执行 Action 后返回的结果。比如:{"temperature": "22°C", "condition": "晴", "humidity": "45%"}。
这三个部分按照固定顺序循环出现。一个完整的 ReAct 轨迹看起来是这样的:
用户:北京今天适合穿什么?
Thought: 用户要的是穿衣建议,而穿衣建议依赖今天的实际气温。我现在并不知道北京今天多少度,不能凭空假设,应该先查天气拿到真实温度,再据此给建议。
Action: get_weather(city="北京", date="2026-09-29")
Observation: {"temperature": "22°C", "condition": "晴", "humidity": "45%"}
Thought: 现在拿到了真实气温 22°C、天气晴,可以用这些数据调用穿衣建议工具了。
Action: get_clothing_advice(temperature=22, condition="晴")
Observation: {"advice": "建议穿薄外套或长袖衬衫"}
Thought: 已经得到基于真实天气的穿衣建议,可以回答用户了。
Final Answer: 北京今天气温 22°C、晴,建议穿薄外套或长袖衬衫。三、ReAct的两种实现方式
ReAct 的思路清楚了,落到代码上有两种写法,一种是早期的,一种是现在的主流。了解早期的写法,能透彻的理解ReAct的本质。
早期写法:让模型输出文本,自己正则解析
论文刚出来那会儿,模型还没有原生的工具调用能力。当时的做法是,在提示词里教会模型按固定格式输出,然后用代码把这段文本解析出来:
你在解决问题时,要严格按以下格式输出:
Thought: <你的思考>
Action: <工具名>[<参数>]
我会把工具的执行结果作为 Observation 返回给你,然后你继续下一轮。
当你能回答时,输出:
Final Answer: <最终答案>模型将Thought和Action以文本的形式返回,以 OpenAI 的 Chat Completions API 为例,它在 response.choices[0].message.content 这个字段里。
Thought: 用户想知道北京今天的天气,我需要调用天气查询工具。
Action: {"tool": "get_weather", "params": {"city": "北京", "date": "2026-09-29"}}你的代码用正则把 Action: 后面的工具名和参数抠出来,执行完,再把结果拼成 Observation: ... ,接到对话后面发回去。
这套能跑,但问题是:解析太脆弱。 模型偶尔会不按格式来,多写一句解释、少一个方括号、参数里带了换行,正则就抠错了。参数是自然语言拼进方括号的,稍微复杂一点(比如要传一个 JSON 对象)就很难可靠解析。你得写一大堆容错代码去兜这些格式问题。
现在的主流:用原生 Function Calling
模块二讲工具调用时说过,现在的模型都支持原生的 Function Calling:你把工具用 JSON Schema 描述好通过 tools 字段传给模型,模型会以结构化的 tool_calls 字段告诉你要调哪个工具、参数是什么。这就把上面那套脆弱的文本解析整个替换掉了。
OpenAI Chat Completions API 在返回工具调用时,通常不会返回Thought。content 是 null,只有 tool_calls:
{
"content": null,
"tool_calls": [{
"id": "call_abc123",
"type": "function",
"function": {
"name": "get_current_weather",
"arguments": "{\"location\": \"Boston, MA\"}"
}
}]
}Responses API 上,推理模型(o 系列、GPT-5)调工具时,output 里会先有一条 reasoning,再有一条 function_call。
ResponseReasoningItem(..., summary=[], type='reasoning')
ResponseFunctionToolCall(arguments='{"city":"London"}', name='get_city_uuid', ...)这里的 summary 是空的。OpenAI 写明:原始思维链不对外返回,你最多能拿到摘要,而且要自己打开 reasoning.summary(auto 或 detailed)。
Claude只有打开 thinking 才可能有思考过程,没开 thinking 时,返回的是 tool_use,没有思考过程。
{ "type": "thinking", "thinking": "The user wants to know the current weather in Paris..." }
{ "type": "tool_use", "name": "get_weather", ... }DeepSeek在thinking 模式下会返回思考过程。用户问的是「杭州明天天气怎么样」,第一轮模型同时给出了思维链、一句说明,以及一次工具调用。
{
"role": "assistant",
"reasoning_content": "The user is asking about the weather in Hangzhou tomorrow. I need to get tomorrow's date first, then call the weather function.",
"content": "Let me check tomorrow's weather in Hangzhou for you. First, let me get tomorrow's date.",
"tool_calls": [
{
"id": "call_00_kw66qNnNto11bSfJVIdlV5Oo",
"type": "function",
"function": {
"name": "get_date",
"arguments": "{}"
}
}
]
}四、Thought VS COT
在ReAct中,我们把Thought 称为思考过程或者推理,那么,它是不是就是在基础课中讲到的COT(Chain Of Thought)?也就是在回答之前先输出一段思考过程。是不是ReAct架构模式,要求使用的模型必须具备COT能力呢?
严格来说,ReAct 不要求模型"具备"某种独立的 CoT 能力,但它要求模型能生成中间推理文本。这两件事并不是一回事。
在论文中,Thought 指的是通过提示词来引导模型"先一步步想,再给答案"。所以,只要模型能生成连贯的文本,原则上就能产出思考过程(Thought)。
但这里有一个实际问题:不同模型被引导出高质量推理的难度差别很大。
早期的一些模型(比如 GPT-3 时代)在被要求"一步步想"时,会输出一些形式上是推理、实质上没有信息量的文本,比如"首先我们需要理解问题,然后我们需要解决它"。这种"走过场"的 Thought 对 ReAct 没有帮助,反而浪费 token。
经过推理能力强化训练的模型(比如 gpt-5.6、claude-sonnet-5、qwen3.8-max、deepseek-v4-flash等具备COT能力的模型),在生成有效推理步骤方面表现稳定得多。它们能自然地输出"当前已知什么、还缺什么、为什么选择这个工具"这类有实质内容的 Thought。
所以更准确的表述是:ReAct 不要求模型有专门的 CoT 能力,但它要求模型有足够的指令遵循能力和推理能力,能产出对决策有指导意义的 Thought。 如果模型在这方面能力弱,ReAct 的效果会明显下降,甚至退化成"纯行动"模式,模型直接输出 Action,Thought 变成一句废话。
这种情况下,有两个应对方式。一是换更强的模型,这是最直接的。二是在提示里给出 Thought 的正反示例,明确要求 Thought 必须包含"当前状态判断"和"下一步理由",用 few-shot 来引导。后一种方式在模型能力有限时能起到一定补偿作用,但天花板还是由模型本身的能力来决定。
ReAct 论文里其实做过消融实验,把 Thought 去掉只留 Action 和 Observation,任务执行的成功率明显下降。
本篇小结

26-Plan-and-Execute
上一篇我们讲完了 ReAct。它的核心是边想边做,每一步根据当前上下文决定下一步动作。这种模式灵活,但有一个绕不开的问题:它是贪心的。
贪心意味着每一步只考虑当前局部最优,不考虑全局。短任务里这没什么问题,走几步就到终点了。但任务一长,问题就暴露出来了。模型可能在某个步骤上过度深入,把大量步数花在一个不重要的细节上;也可能走到一半才发现前面漏了一个关键环节,只能回头补,补完之后又忘了当前要继续做什么。
这一篇要讲的 Plan-and-Execute,就是为了解决这个问题而出现的。
一、ReAct 的漂移问题
先看一个具体的例子,感受一下 ReAct 在长任务上的漂移。
假设我们要做一个 Agent,任务是:“帮我分析一下最近三个月公司客服工单的主要问题类型,找出占比最高的三类,并针对每一类给出改进建议。”
如果用 ReAct 来做,Agent 的行为可能是这样的:
- Thought:我需要先获取最近的客服工单数据。
- Action:查询工单数据库,时间范围最近三个月。
- Observation:返回了 5000 条工单记录。
- Thought:数据量很大,我需要先做分类统计。
- Action:调用分类工具,按问题类型统计。
- Observation:返回了 20 个问题类型及占比。
- Thought:占比最高的三类是“物流延迟”“退款流程复杂”“商品描述不符”。我需要针对物流延迟给出改进建议。
- Action:搜索“物流延迟 改进方案”。
- Observation:返回了一堆通用文章。
- Thought:这些文章太泛了,我需要更具体的。让我搜索“电商 物流延迟 解决方案 案例”。
- Action:搜索……
- Thought:这些案例不太适用。让我换个关键词再搜一次。
- Action:搜索……
- ……
到这里,Agent 已经在“物流延迟”这一个类别上花了好几轮搜索,还没有开始处理另外两类。而它的上下文里,最初的用户目标已经被大量搜索结果淹没了。最终要么步数耗尽,要么模型在写建议时已经忘了用户要的是“三类问题加改进建议”,只写了一个类别就收尾。
这就是漂移。不是模型不聪明,是 ReAct 的结构决定了它只能看到当前这一步,看不到全局。
二、Plan-and-Execute 的核心思路
Plan-and-Execute 的思路很直接:既然边做边想容易迷路,那就先想清楚再动手。
它把任务明确分成两个阶段。
第一个阶段是规划。让模型基于用户的任务描述,生成一份完整的执行计划。这份计划通常是一个步骤列表,每个步骤描述要做什么、可能用什么工具、依赖哪些前置步骤。
第二个阶段是执行。按照计划逐步执行,每一步的输出作为下一步的输入。执行过程中如果发现某一步的结果和预期不符,可以触发重规划,调整后续步骤。
回到刚才的例子,规划阶段可能会生成这样一份计划:
1. 查询最近三个月的客服工单数据
2. 对工单按问题类型做分类统计
3. 找出占比最高的三类问题
4. 针对第一类问题,搜索行业内的改进方案
5. 针对第二类问题,搜索行业内的改进方案
6. 针对第三类问题,搜索行业内的改进方案
7. 汇总三类问题的改进建议,生成分析报告执行阶段就按这个列表一步一步走。每一步的执行器可以是一个工具调用,也可以是一个独立的 ReAct 循环,因为具体到某一步(比如“搜索行业内的改进方案”),路径仍然可能是不确定的,这时用 ReAct 来处理这一步的内部逻辑是合适的。
这种“全局用计划约束,局部用 ReAct 灵活处理”的组合,是实际项目里最常见的做法。
那么,具体计划怎么表示呢?
计划的数据结构选择,直接影响后续的执行和重规划逻辑。
最简单的表示是自然语言步骤列表。Planner 输出一段文字,比如“1. 查询数据 2. 统计分析 3. 生成报告”。Executor 每次把当前步骤的描述拿出来,自己理解要做什么。这种方式实现简单,但程序很难对计划做精确操作,比如判断步骤之间的依赖、或者重规划时只替换某一步。
稍微结构化一点的是JSON 步骤列表,每个步骤有 id、description、tool、depends_on。程序可以解析依赖关系,可以按拓扑序执行,也可以在重规划时只替换部分步骤。这是目前最常用的表示方式。
{
"steps": [
{"id": 1, "description": "调研 Qdrant:性能、部署方式、定价、社区活跃度", "depends_on": []},
{"id": 2, "description": "调研 Milvus:性能、部署方式、定价、社区活跃度", "depends_on": []},
{"id": 3, "description": "调研 pgvector:性能、部署方式、定价、社区活跃度", "depends_on": []},
{"id": 4, "description": "汇总三家资料,按统一维度做对比表", "depends_on": [1, 2, 3]},
{"id": 5, "description": "结合团队情况给出选型建议,产出报告", "depends_on": [4]}
]
}三、Plan-and-Execute 的三个角色
Plan-and-Execute 在工程实现上通常拆成三个角色。理解这三个角色的职责划分,也就理解了Plan-and-Execute。
Planner 负责生成计划。
它的输入是用户的任务描述,输出是一份步骤列表。Planner 的提示词需要引导模型从全局视角看问题,而不是一上来就钻进细节。一个常见的技巧是在提示里要求模型“先列出完成这个任务需要哪些阶段,再把每个阶段拆成具体步骤”。
Executor 负责执行计划中的每一步。
它的输入是目标、步骤、当前步骤,以及前面步骤的输出(甚至是整个对话历史)。Executor 可以是简单的工具调用,也可以是一个完整的 ReAct Agent。如果某一步特别复杂,Executor 内部甚至可以再跑一个 Plan-and-Execute Agent。
Replanner 负责在必要时调整计划。
它的输入是当前执行进度、已完成步骤的结果、以及原始计划,输出是一份更新后的计划。重规划是 Plan-and-Execute 灵活性的来源,但也是最容易出问题的地方。触发条件设计得好,Agent 能优雅地应对意外;设计得不好,Agent 会在重规划里打转。
重规划常见的触发条件有:
第一类是执行失败。某一步的工具调用报错了,或者返回了空结果。这时候需要判断:是重试这一步,还是换一个方法,还是调整后续计划。
第二类是结果和预期不符。比如计划里写“搜索某个关键词,预期能找到至少 5 条相关结果”,实际只找到 1 条。这时候可能需要补充搜索,或者调整后续步骤的假设。
第三类是发现计划遗漏。执行到某一步时,模型意识到原计划没有考虑到某个关键因素。比如做竞品分析时,原计划只列了三家竞品,执行中发现了第四家重要的。
第四类是步骤粒度过粗。某一步的描述太笼统,Executor 执行时不知道从何下手。这时候需要把这一步拆成更细的子步骤。
在实际实现里,不需要每一步都触发重规划检查,那样会让模型调用次数翻倍。更常见的做法是:只在步骤失败、或者每隔 N 步、或者执行到计划的后半段时,才做一次重规划检查。
重规划的次数必须设上限。模型在重规划时容易过度修改,把本来没问题的步骤也改掉。设上限的同时,还要限制重规划只能修改“未完成的步骤”,已完成的部分作为既成事实不再变动。
四、从零实现最小 Plan-and-Execute Agent
下面是一个简化但可运行的实现。在以下代码中,Planner 和 Executor 都用 gpt-5.6;如果是成本敏感的高并发场景,Executor 可以换成 gpt-5.6-luna,因为执行步骤通常比规划步骤多得多。
import json
from openai import OpenAI
client = OpenAI()
# ---------- 工具定义 ----------
TOOLS = [
{
"type": "function",
"function": {
"name": "query_ticket_db",
"description": "查询客服工单数据库,支持按时间范围和问题类型筛选",
"parameters": {
"type": "object",
"properties": {
"start_date": {"type": "string", "description": "开始日期,格式 YYYY-MM-DD"},
"end_date": {"type": "string", "description": "结束日期,格式 YYYY-MM-DD"},
"category": {"type": "string", "description": "问题类型,可选"}
},
"required": ["start_date", "end_date"]
}
}
},
{
"type": "function",
"function": {
"name": "search_web",
"description": "搜索网页获取信息",
"parameters": {
"type": "object",
"properties": {
"query": {"type": "string", "description": "搜索关键词"}
},
"required": ["query"]
}
}
}
]
def execute_tool(name, args):
"""模拟工具执行"""
if name == "query_ticket_db":
return {
"total": 5000,
"categories": {"物流延迟": 0.35, "退款流程复杂": 0.22, "商品描述不符": 0.15}
}
if name == "search_web":
return f"关于「{args['query']}」的搜索结果:……"
return {"error": f"未知工具 {name}"}
# ---------- Planner ----------
PLANNER_PROMPT = """你是一个任务规划器。给定用户的任务,你需要生成一份执行计划。
要求:
1. 从全局视角看问题,先确定完成这个任务需要哪几个阶段。
2. 每个阶段拆成具体、可执行的步骤。
3. 每个步骤描述清楚:做什么、用什么工具(如果知道)、依赖哪些前置步骤。
输出 JSON,格式:
{
"steps": [
{"id": 1, "description": "步骤描述", "tool": "工具名或null", "depends_on": []}
]
}
"""
def plan(task):
response = client.chat.completions.create(
model="gpt-5.6",
messages=[
{"role": "system", "content": PLANNER_PROMPT},
{"role": "user", "content": f"任务:{task}"}
],
response_format={"type": "json_object"},
temperature=0
)
return json.loads(response.choices[0].message.content)["steps"]
# ---------- Executor(每一步 = 一个最小 ReAct 循环,直接读写 state)----------
EXECUTOR_PROMPT = """
你是一个任务执行器,负责完成给定的单个步骤。
根据步骤描述,自主决定是否调用工具、调用哪些工具、以及调用几轮。
你可以多轮调用工具:拿到工具结果后,判断是否还需要继续,直到这一步真正完成。
当你认为这一步已经完成时,直接用自然语言给出该步骤的最终结果,不要再调用工具。
"""
# ---------- State ----------
def init_state(task):
"""贯穿规划与执行的全局状态;execute_step / should_replan 都直接在它上面读写"""
return {
"target": task, # 用户的总目标,全程不变
"steps": [], # 当前计划的步骤列表(Replanner 只替换未完成部分)
"current_step": 0, # 当前执行到第几步(steps 的索引)
"messages": [ # 执行器的完整对话历史,跨步骤累积
{"role": "system", "content": EXECUTOR_PROMPT},
],
}
def execute_step(state, max_turns=6):
"""执行 current_step 指向的步骤,过程中直接修改 state(messages 与当前 step)"""
step = state["steps"][state["current_step"]]
# 把「总目标 + 完整计划 + 当前步骤」作为一条新的 user 消息,追加进共享对话
state["messages"].append({
"role": "user",
"content": (
f"总目标:{state['target']}\n"
f"完整计划:{json.dumps(state['steps'], ensure_ascii=False)}\n"
f"当前步骤:{step['description']}"
),
})
for _ in range(max_turns):
response = client.chat.completions.create(
model="gpt-5.6",
messages=state["messages"],
tools=TOOLS,
tool_choice="auto",
temperature=0,
)
message = response.choices[0].message
state["messages"].append(message)
# 没有工具调用,这一步结束:把最终结果写回当前 step
if not message.tool_calls:
step["result"] = message.content
return
# 一轮里可能有多个(并行)工具调用,全部执行并把结果回灌
for tool_call in message.tool_calls:
name = tool_call.function.name
args = json.loads(tool_call.function.arguments)
result = execute_tool(name, args)
state["messages"].append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": json.dumps(result, ensure_ascii=False),
})
# 达到轮数上限仍未收敛:标记一下,通常交给 Replanner 接管
step["result"] = "(达到最大轮数,该步骤可能未完全完成)"
# ---------- Replanner ----------
REPLANNER_PROMPT = """
你是一个重规划器。给定原始计划、已完成步骤和当前进度,判断是否需要调整后续计划。
如果需要调整,输出更新后的完整计划。如果不需要调整,输出 need_replan 为 false。
输出 JSON,格式:
{"need_replan": true/false, "steps": [...]}
"""
def should_replan(state, original_steps):
completed = state["steps"][:state["current_step"]] # 已完成的步骤(带 result/error)
remaining = state["steps"][state["current_step"]:] # 尚未执行的步骤
context = f"""
原始任务:{state['target']}
原始计划:{json.dumps(original_steps, ensure_ascii=False)}
已完成步骤及结果:{json.dumps(completed, ensure_ascii=False)}
剩余步骤:{json.dumps(remaining, ensure_ascii=False)}
"""
response = client.chat.completions.create(
model="gpt-5.6",
messages=[
{"role": "system", "content": REPLANNER_PROMPT},
{"role": "user", "content": context}
],
response_format={"type": "json_object"},
temperature=0
)
return json.loads(response.choices[0].message.content)
# ---------- 主流程 ----------
def plan_and_execute(task, max_replan=3):
state = init_state(task)
state["steps"] = plan(task)
original_steps = list(state["steps"])
replan_count = 0
while state["current_step"] < len(state["steps"]):
try:
execute_step(state) # 直接在 state 上读写
except Exception as e:
state["steps"][state["current_step"]]["error"] = str(e)
state["current_step"] += 1 # 推进到下一步
remaining = state["steps"][state["current_step"]:]
if remaining and replan_count < max_replan:
decision = should_replan(state, original_steps)
if decision.get("need_replan"):
# 只替换未完成的步骤,已完成的既成事实不动
state["steps"] = state["steps"][:state["current_step"]] + decision["steps"]
replan_count += 1
return state这段代码有几个值得说明的地方。
第一,Executor 是一个 ReAct 循环。它用 messages 维护对话,每一轮拿到模型返回后,把工具结果用 role: "tool" 回拼进去,再让模型决定下一步,直到模型不再调用工具、给出该步骤的最终结果为止。
第二,Planner 和 Replanner 的输出用 response_format={"type": "json_object"} 约束成 JSON。这两个角色需要输出结构化数据,用 JSON 模式可以保证拿到干净的 JSON,同样省去了文本解析的麻烦。如果模型支持 JSON Schema 约束(比如 OpenAI 的 structured outputs),还可以进一步指定字段类型,稳定性更高。
第三,整个运行过程共享一个 state,它记录了 target(总目标)、steps(当前计划)、current_step(执行到第几步)和 messages(完整对话历史)。execute_step 直接在 state 上读写:它把「总目标 + 完整计划 + 当前步骤」追加成一条 user 消息发送给大模型,把模型回复和工具结果都塞进 state["messages"],最后把这一步的结论写回当前 step。
第四,Replanner 只在还有剩余步骤时才触发,且设置了最大重规划次数。不设上限的话,模型可能反复重规划,永远走不到终点。
五、工程实践中的关键细节
讲完了Plan-And-Execute模式的核心结构和最小实现之后,我们来看几个工程实践中的细节问题。
规划粒度
计划里的步骤不能太粗,也不能太细。
太粗的步骤,比如“完成数据分析”,Executor 拿到之后不知道具体要做什么,实际上还是得自己临时拆解,等于绕了一圈又回到了 ReAct。太细的步骤,比如“打开数据库连接” “执行 SQL 查询” “关闭连接”,又会让计划冗长,而且模型可能因为步骤太多而丢失整体目标。
一个经验法则是:每个步骤应该对应一个明确的可交付结果。比如“获取最近三个月的工单数据”是一个可交付结果,“分析数据”不是一个可交付结果,因为它没有说明分析出什么。
如果发现规划出来的步骤太粗,可以在 Planner 的提示词里要求:“每个步骤必须产出具体的中间结果”。如果太细,可以要求:“每个步骤应该至少能在一次工具调用或一次模型调用内完成,不要拆分到操作级别”。
步骤间的状态传递
Executor 执行每一步时,需要知道前面步骤产出了什么。最简单的做法是把前面步骤的所有对话历史都塞进后面步骤的上下文。但这会带来上下文膨胀的问题。
更好的做法是让 Executor 显式声明需要哪些前置步骤的结果。这在计划里通过 depends_on 字段表达。执行某一步时,只把它依赖的那些步骤的结果注入上下文,而不是全部历史。
这个做法还有一个好处:它让步骤之间的依赖关系变得显式,方便做并行调度。没有依赖关系的步骤可以并行执行。
计划的版本管理
每次重规划都会产生一份新计划。如果不记录版本,出了问题很难回溯,不知道当时为什么改了计划,改之前是什么样。
工程上通常会把每一版计划都存下来,连同触发重规划的原因、当时的执行进度。这在调试时非常有用,也是做评估和优化的基础数据。
中间结果的存储
长任务的中间结果可能很大,比如一个搜索结果列表、一份原始数据表。全塞进上下文不现实。
常见的做法是把中间结果存到外部存储(文件、数据库),上下文里只保留一个引用或者摘要。Executor 需要用到完整数据时,再通过工具读取。
这个思路和模块三讲的记忆系统、模块四讲的上下文工程是一致的,只是应用在了 Plan-and-Execute 的场景里。
本篇小结

27-Reflection
前面两篇讲的 ReAct 和 Plan-and-Execute,解决的都是"怎么做"的问题,即怎么组织推理和行动,怎么在全局规划和局部灵活之间取得平衡。它们关心的是执行过程本身。
ReAct 跑完一个循环,输出了一个 Final Answer。Plan-and-Execute 按计划执行完所有步骤,生成了报告。然后呢?直接返回给用户吗?
如果是查天气、算数学题这种答案明确的任务,直接返回没问题。但如果是写一份分析报告、生成一段代码、做一次复杂决策,一次输出就能让人满意的概率并不高。人类专业人士做完一件事,也会回头检查一遍,发现不足就改。Agent 为什么不能这样?
这就是 Reflection 要解决的问题。
一、一次输出为什么不够好
先看一个具体的例子。
假设我们让 Agent 写一段 Python 代码,实现一个功能:给定一个整数列表,返回其中所有两数之和等于目标值的下标对。
Agent 第一次输出的代码可能是这样的:
def two_sum(nums, target):
result = []
for i in range(len(nums)):
for j in range(i + 1, len(nums)):
if nums[i] + nums[j] == target:
result.append([i, j])
return result这段代码逻辑正确,但有几个问题:
时间复杂度是 O(n²),对于大列表性能很差;
没有处理边界情况,比如空列表或者没有找到结果时返回什么;
变量命名不够清晰。
如果 Agent 输出完就直接返回,用户拿到的是这段代码,可能还得自己优化。但如果 Agent 在输出后能自己检查一遍,它可能会发现:
这个实现是暴力解法,可以用哈希表优化到 O(n)
没有处理空列表的情况,应该返回空列表而不是 None
然后它修改代码,输出第二版。第二版可能还有问题,比如哈希表写法有 bug,再检查、再修改。经过两三轮迭代,最终输出的代码质量会明显高于第一版。
这就是 Reflection 的价值:通过自我评估和迭代修改,把输出质量从"能用"提升到"好用"。
二、Reflection 的核心机制
Reflection 的核心结构可以用三个角色概括:生成器(Generator)、评估器(Evaluator 或者 Critiquer)、修改器(Refiner)。
生成器负责产出初始结果。它可以是 ReAct Agent、Plan-and-Execute Agent,甚至是一个简单的单次大模型调用。
评估器负责检查生成器的输出,找出问题。它的输入是原始任务和生成器的输出,输出是一份批判意见:指出哪里不对、哪里不够好、哪里可以改进。
修改器负责根据批判意见修改输出。它的输入是原始输出和批判意见,输出是修改后的版本。
这三个角色形成一个循环:生成 → 评估 → 修改 → 再评估 → 再修改……直到评估器认为输出已经足够好,或者达到最大迭代次数。
这里有一个关键的设计决策:评估器和生成器是不是同一个模型?
如果使用同一个模型,会有一个问题:模型在评估自己的输出时,容易陷入"自我确认",它倾向于认为自己写的东西是对的,很难发现自己的盲区。这和人类一样,自己检查自己的作业,往往看不出错误。
同一个模型自评有盲点,那就换个「视角」。工程上常见的做法是给评估器一套对立的人设,比如「你是一个挑剔的评审,任务是尽可能找出问题,不要轻易说没问题」。
当然,更有效的做法是用不同的模型做评估。比如生成器用 gpt-5.6,评估器用 claude-sonnet-5。不同模型在训练数据、训练方式、能力偏向上有差异,评估器更容易发现生成器忽略的问题。
三、从零实现最小 Reflection Agent
下面是一个简化但可运行的实现。为了控制成本,生成器用 gpt-5.6,评估器用 gpt-5.6-luna,评估通常比生成简单,用更便宜的模型就够了。
import json
from openai import OpenAI
client = OpenAI()
GENERATOR_PROMPT = """你是一个专业的写作助手。请根据用户的要求完成任务。
要求:
1. 直接输出完成结果,不要加额外的解释。
2. 如果需要结构化输出,使用清晰的标题和列表。
"""
EVALUATOR_PROMPT = """你是一个严格的评估者。你需要检查生成结果是否满足用户要求。
评估维度:
1. 准确性:信息是否正确,有没有事实错误。
2. 完整性:是否覆盖了用户要求的所有要点。
3. 清晰度:结构是否清晰,表达是否易懂。
4. 深度:是否停留在表面,有没有深入分析。
输出格式(JSON):
{
"score": 1-10,
"issues": ["问题1", "问题2", ...],
"suggestions": ["改进建议1", "改进建议2", ...]
}
如果 score >= 8,表示可以接受;否则需要修改。
"""
REFINER_PROMPT = """你是一个修改者。你需要根据评估意见修改原始输出。
要求:
1. 只修改评估意见中指出的问题,不要改变其他部分。
2. 保持原始输出的整体结构和风格。
3. 直接输出修改后的完整版本。
"""
def generate(task):
response = client.chat.completions.create(
model="gpt-5.6",
messages=[
{"role": "system", "content": GENERATOR_PROMPT},
{"role": "user", "content": task}
],
temperature=0.7
)
return response.choices[0].message.content
def evaluate(task, output):
response = client.chat.completions.create(
model="gpt-5.6-luna", # 评估用更便宜的模型
messages=[
{"role": "system", "content": EVALUATOR_PROMPT},
{"role": "user", "content": f"原始任务:{task}\n\n生成结果:{output}"}
],
temperature=0
)
text = response.choices[0].message.content
return json.loads(text)
def refine(task, output, evaluation):
context = f"""原始任务:{task}
原始输出:
{output}
评估意见:
问题:{json.dumps(evaluation['issues'], ensure_ascii=False)}
建议:{json.dumps(evaluation['suggestions'], ensure_ascii=False)}
请根据以上意见修改原始输出。"""
response = client.chat.completions.create(
model="gpt-5.6",
messages=[
{"role": "system", "content": REFINER_PROMPT},
{"role": "user", "content": context}
],
temperature=0.5
)
return response.choices[0].message.content
def reflection_agent(task, max_iterations=3, score_threshold=8):
output = generate(task)
history = []
for i in range(max_iterations):
evaluation = evaluate(task, output)
history.append({
"iteration": i + 1,
"score": evaluation["score"],
"issues": evaluation["issues"]
})
if evaluation["score"] >= score_threshold:
break
output = refine(task, output, evaluation)
return output, history
# 使用
if __name__ == "__main__":
task = "写一份关于国产大模型在代码生成领域最新进展的简要分析,涵盖 DeepSeek、Qwen、GLM 和 Kimi。"
result, history = reflection_agent(task)
print("最终输出:")
print(result)
print("\n迭代历史:")
for h in history:
print(f"第 {h['iteration']} 轮:评分 {h['score']},问题:{h['issues']}")这段代码的核心逻辑是:先生成,再评估,如果评分不够高就修改,修改后再评估。最多迭代三轮,或者评分达到 8 分就停止。
有几个设计选择值得说明一下:
第一,评估输出用了结构化的 JSON,包含分数、问题列表、改进建议,方便程序解析。
第二,修改器只根据评估意见修改,不重新生成。这可以避免"越改越偏",如果每轮都重新生成,可能会把原来对的部分也改掉。
第三,评估器用了更便宜的模型。这是成本优化的考虑:评估通常比生成简单,用 gpt-5.6-luna 就够了,没必要用最贵的模型。
以上只是最小实现,在具体的项目里,Reflection 可以放在不同层次,效果和代价都不一样。
放在最外层,把整个 Agent 的输出包起来。不管里面用的是 ReAct 还是 Plan-and-Execute,最终输出后都过一遍 Reflection。
这种方式的优点是实现简单,对内部逻辑无侵入。缺点是反馈周期长,要等整个任务跑完才知道结果好不好,如果不好,修改成本很高。
放在中间层,在每个关键步骤后做 Reflection。比如 Plan-and-Execute 里,每执行完一个步骤就检查这一步的结果是否合理。
这种方式能更早发现问题,避免错误累积。代价是模型调用次数增加,每一步都要多一次评估调用。
放在最内层,在 ReAct 循环的每一步都做 Reflection。
这种方式反馈最及时,但成本也最高。通常只在任务对每一步的准确性要求极高时才这么做,比如自动交易、医疗诊断。
实际项目里,最常见的是外层 Reflection + 关键步骤的中间层 Reflection。
外层保证最终输出质量,中间层在关键决策点做检查。两者结合,既不会成本失控,又能覆盖主要风险点。
四、Reflection 的几种变体
基础的 Reflection 是"生成-评估-修改"循环,但在实际项目里,根据任务类型和需求,会演化出不同的变体。
Self-Refine
它是最基础的Reflection,就是上面代码展示的结构。生成器、评估器、修改器可以是同一个模型,也可以是不同模型。
它的特点是通用性强,几乎任何生成任务都可以套用。但是,缺点也很明显:模型评价自己的产出时,往往和它生成时带着同一套盲点。
它生成这段代码时没想到「非法输入」,你让它回头检查,它很可能同样想不到,反而还会自我感觉良好地说「这段代码逻辑清晰,没有问题」。
自我批判能抓到一些表面的、格式的、明显的疏漏,但抓不到它认知盲区里的错误,而后者恰恰是最致命。
带外部反馈的 Reflection
外部的客观反馈才是 Reflection 真正可靠的来源。所谓外部的客观反馈,是不依赖模型主观判断、由外部世界给出的确定性信号,比如:
- 写完代码,跑一遍测试,测试失败的报错信息就是反馈;
- 写完代码,过一遍编译器 / 类型检查 / linter,报的错就是反馈;
- 产出结构化数据,用 Schema 校验,不合规的地方就是反馈;
- 写完带引用的报告,回到资料里逐条核验(RAG 那套事实核验),核不上的断言就是反馈。
这些反馈的共同点是:它们不来自模型的自我感觉,而来自一个客观的、确定的检查。测试挂了就是挂了,编译不过就是不过。用这种反馈驱动 Reflection,改进才是真的有效。
所以一条实践准则是:能用客观反馈,就绝不用纯自我批判。优先去找你这个任务里有没有可以自动化的客观检查信号,把它接进反思循环。实在没有客观信号的任务(比如纯开放式写作),才退而用自我批判。
带长期记忆的Refletion
它的核心思想是:不仅修改当前输出,还把反思的结论写入长期记忆,用来改进未来的行为。
比如一个代码 Agent 在修复某个 bug 时发现 "我总是忘记处理空输入",它会把这条教训写进记忆,下次生成代码时主动检查空输入。这种机制让 Agent 能够跨任务积累经验,越跑越有经验。
对抗式 Reflection
它的核心思想是:让两个 Agent 扮演对立角色。一个负责生成,一个负责挑刺。
同一个模型自评有盲点,那就换个「视角」。工程上常见的做法是给评估器一套对立的人设,比如「你是一个挑剔的评审,任务是尽可能找出问题,不要轻易说没问题」。更进一步,可以让生成器用一个模型(比如 gpt-5.6),评估器换另一家的模型(比如 claude-sonnet-5 或 glm-5.3),不同模型的盲点不一样,一个漏掉的问题另一个可能抓得到。
额外补充
有些任务确实找不到客观信号,比如写一段产品文案、润色一篇文章。这时候只能用自我批判,Reflection 的效果,很大程度上取决于评估器的质量。如果评估器只会说"这里可以更好",修改器就无从下手。
因此,我们要给评估器一份明确的评估清单,而不是让它笼统地「找问题」。 空泛的自查最没用,模型会敷衍地说「挺好的」。你要把「好」拆成一条条可检查的具体标准,让它逐条核对,这样Reflection才有效。这本质上是把你脑子里的质量标准,显式地交给模型去核对。比如评估一份调研报告,清单可以是:
请逐条检查下面这份报告,对每一条给出「符合 / 不符合 + 具体位置」:
1. 每个数据是否都标注了来源?有没有没来源的断言?
2. 三个候选是否用了完全一致的对比维度?有没有漏项?
3. 结论是否和前面的对比数据一致,有没有自相矛盾?
4. 有没有把「推测」当成「事实」来陈述?五、工程实践中的关键细节
我们再来看工程实践中一些要注意的细节。
停止条件
Reflection 必须有一个明确的停止条件,否则会无限循环下去。
常见的停止条件有三种:
第一种是评分阈值。评估器给出一个分数,达到阈值就停止。比如 10 分制里达到 8 分就认为可以接受。这种方式简单直接,但阈值的设定需要经验。设得太低,质量不够;设得太高,可能永远达不到。
第二种是迭代次数上限。不管质量如何,最多迭代 N 轮。这是兜底机制,防止无限循环。通常 N 取 3 到 5,再多的话边际收益递减,成本却线性增长。
第三种是改进幅度阈值。如果连续两轮的评分没有明显提升,就停止。比如第一轮 6 分,第二轮 6.5 分,第三轮 6.6 分,提升越来越小,说明已经接近当前能力的上限,继续迭代意义不大。
实际项目里通常三种结合使用:评分达到阈值就停,达到最大次数也停,连续两轮没提升也停。
防止越改越差
Reflection 有一个反直觉的风险:修改后的版本可能比原版更差。
这听起来不合理,但确实会发生。原因有这样几个:
评估器可能给出了错误的判断,修改器忠实地执行了错误的建议;
修改器在修改一个问题时引入了新的问题;
多轮修改后,输出变得越来越"四平八稳",失去了原有的个性。
防范措施包括:保留每一版的输出和评分,如果新版评分低于旧版,回退到旧版;限制修改器的改动范围,只改评估意见指出的问题,不要重写整篇;在评估器的系统提示词里加一条"如果原始输出已经足够好,不要为了改而改"。
评估器的偏见
评估器本身也可能有偏见。比如它可能偏好更长、更详细的输出,即使简洁的版本更好。它可能偏好某种特定的写作风格。它可能对某些话题有敏感性。
缓解方式包括:在评估提示词里明确说明"长度不是质量的标准""不要因为风格偏好而扣分";用多个评估器取平均,降低单个评估器的偏见影响;定期用人工评估来校准模型评估的准确性。
成本控制
Reflection 的成本是基础模式的两到三倍。每一轮迭代至少多两次模型调用(一次评估、一次修改),如果迭代三轮,就是六次额外调用。
控制成本的方式有几种:评估器用更便宜的模型;只在关键步骤做 Reflection,不是每一步都做;设置更严格的停止条件,减少迭代轮数;对于简单任务,跳过 Reflection,直接返回。
还有一个容易被忽视的成本:延迟。用户等一个 Agent 输出,本来只要 5 秒,加了 Reflection 后可能变成 20 秒。对于交互式场景,这个延迟可能是不可接受的。所以 Reflection 更适合后台任务、批处理任务,或者用户明确愿意等待的高质量输出场景,如编程等复杂任务处理。
本篇小结

28-Multi-Agent
前面四篇讲的 ReAct、Plan-and-Execute、Reflection,不管怎么组合,本质上都是一个 Agent 在做事。
但有些复杂任务,一个 Agent 做不好。
不是因为模型不够聪明,而是因为单个 Agent 的结构性限制。上下文窗口有上限,角色定位会冲突,工具集太大会互相干扰。这些问题不是换个更强的模型就能解决的,它们是单 Agent 架构本身的天花板。
Multi-Agent 要解决的就是这个问题:把任务拆给多个 Agent,每个 Agent 有自己的角色、工具和上下文,通过协作机制共同完成任务。
一、单 Agent 的三个瓶颈
先看单 Agent 在复杂任务上会遇到什么问题。
第一个瓶颈是上下文容量。 一个 Agent 在处理复杂任务时,上下文里要装用户输入、系统提示词、工具定义、历史对话、中间结果、工具返回……这些东西加起来很容易超过模型窗口。即使模型支持 200K 甚至 1M token 的上下文,把所有信息塞进去也会导致注意力稀释,而启动压缩又不可避免的丢失细节信息。这些在前面模块中都讲过。
第二个瓶颈是角色冲突。 如果一个 Agent 同时扮演"研究员"和"写作者",它的提示词里就要同时包含"如何搜索"和"如何写作"这两套规范。一个 Agent 同时具备这两种角色,往往两边都做不好。
第三个瓶颈是工具集干扰。 一个 Agent 挂载了 30 个以上工具,模型在选择工具时的准确率会明显低于只挂载 10 个工具。工具越多,描述越容易混淆,模型越容易选错。把工具按职能分给不同的 Agent,每个 Agent 只需要处理自己领域内的几个工具,选择准确率会高很多。
这三个瓶颈有一个共同的解法,那么就是:拆分。
其实,这个解法并不特别,微服务、分布式系统都是应用了同样的处理思想。
二、Multi-Agent 的核心思路
Multi-Agent 的做法是把原本由一个 Agent 承担的工作,拆给多个专业化 Agent。
每个 Agent 有自己的:
- 角色定义:它是做什么的,它的职责边界在哪里。
- 系统指令:它需要按照怎样的规范和约束来干活。
- 工具集:它需要用到哪些工具,不需要用到哪些。
- 上下文:它能看到哪些信息,不需要看到哪些信息。
拆完之后,每个 Agent 的上下文更聚焦,提示词更简单,工具集更小。单个 Agent 的决策质量会因此而提升。
但拆也带来了新的问题:这些 Agent 之间怎么协作?谁来决定任务怎么分配?结果怎么汇总?冲突怎么解决?
这些问题在单 Agent 场景下根本不存在,在 Multi-Agent 场景下必须逐一处理。
所以 Multi-Agent 的难点不是"拆",而是拆完之后怎么组织协作。不同的组织方式,就是不同的拓扑结构。
三、常见的拓扑结构
多个 Agent 怎么组织到一起,有几种常见结构。
Supervisor / Orchestrator-Workers
这是最直观、也最常用的一种结构。
一个主 Agent (Supervisor)负责协调,它把任务拆分开,分派给若干个子 Agent(Worker)去做,再把子 Agent 的结果收回来汇总。子 Agent 之间不直接对话,都只跟主 Agent 打交道。

这种结构清晰、好控制,绝大多数 Multi-Agent 系统都是这种架构,或者它的层级化版本(子 Agent 底下再带自己的子 Agent)。
理解 Multi-Agent,抓住一个要点就够了:
对主 Agent 来说,一个子 Agent 本质上就是一个工具,只不过这个工具内部自己带了一个完整的循环和一块独立的上下文。
回想模块二讲工具调用:主 Agent 调一个普通工具,是发出参数、拿回结果,它不关心工具内部怎么实现的。调一个子 Agent 也是一样:主 Agent 把一个子任务(比如「调研 Qdrant」)作为参数发给子 Agent,子 Agent 内部跑它自己的 ReAct 循环、调它自己的工具、用它自己的上下文窗口,最后把一份结果交回来。
主 Agent 看到的,只是「派了个活、拿回个结果」,中间那一大堆过程它完全看不到,也不需要看到。
这个「看不到中间过程」恰恰是 Multi-Agent 最大的价值,也就是上下文隔离。
模块四讲上下文工程时提过一句「大块探索交给子 Agent」,说的就是这件事:子 Agent 在它自己的窗口里可能读了二十个网页、调了十几次工具,产生了几万 token 的中间过程,但这些统统留在子 Agent 那边,最后回传给主 Agent 的只是一份干净的结论。
主 Agent 的上下文因此保持干净,不会被各个子任务的过程细节撑爆。
Handoff
Supervisor 模式是中心化的,Handoff 模式是去中心化的。
在 Handoff 模式里,Agent 之间可以直接传递控制权。Agent A 处理完自己这部分后,判断下一步应该由 Agent B 来处理,就把控制权直接交给 B,不需要经过中心节点。
这种结构适合那种流程不确定、下一步由谁处理取决于当前结果的任务。比如客服系统:用户的问题可能先由"咨询 Agent"接待,如果发现是退款问题,就转给"退款 Agent";退款 Agent 处理完后,如果需要物流信息,再转给"物流 Agent"。
Handoff 模式的优点是灵活,没有中心瓶颈。缺点是控制流不透明,出了问题很难追踪是哪个环节决定的。另外,如果 Agent 之间的交接规则设计得不好,可能出现"踢皮球":A 推给 B,B 推回给 A。

Ensemble
Ensemble 模式是让多个 Agent 独立处理同一个任务,然后汇总它们的结果。
比如同一个问题,让三个 Agent 分别回答,然后由汇总Agent选出最终答案。比如,让三个 Agent 分别写一段代码,然后由第四个 Agent 选出最好的。
这种结构适合那种 单个 Agent 的输出不够可靠、需要多视角验证 的任务。比如事实核查、风险评估。
它的优点是鲁棒性高。单个 Agent 犯错不会影响最终结果。缺点是成本成倍增加。

四、通信机制:消息传递 vs 共享状态
确定了拓扑结构之后,下一个问题是:Agent 之间怎么交换信息?
我们结合一个具体例子来看。
假设有一个内容生产系统,包含三个 Agent:研究员负责搜集资料,写作者负责基于资料写初稿,审核者负责检查初稿的事实和逻辑。用户给一个主题,系统最终输出一篇带数据支撑的分析文章。
三个 Agent 的协作顺序是:研究员先工作,把资料交给写作者;写作者写完初稿,交给审核者;审核者给出修改意见,写作者修改,再交给审核者。如此反复,直到审核通过。
在这个协作流程里,Agent 之间需要传递的信息包括:研究员整理的事实、写作者写的初稿、审核者给出的修改意见。
这些信息怎么传,就是通信机制要解决的问题。最常见的两种方式是消息传递和共享状态。
消息传递
消息传递是指 Agent 之间直接发送消息。Agent A 把结果发给 Agent B,B 收到后处理,再把结果发给 C。消息里通常包含前一个Agent的处理结果。
def sequential_pipeline(topic):
# 第一步:研究员搜集资料
research_output = researcher_agent.run(
f"请搜集关于「{topic}」的事实和数据。"
)
# 第二步:写作者基于资料写初稿
# research_output 直接拼进写作者的输入
draft_output = writer_agent.run(
f"请基于以下资料写一篇文章。\n\n资料:\n{research_output}"
)
# 第三步:审核者检查初稿
# draft_output 直接拼进审核者的输入
review_output = reviewer_agent.run(
f"请检查以下初稿的问题。\n\n初稿:\n{draft_output}"
)
return review_output这里需要解释一下:消息传递里的“发送”,在代码层面就是把 Agent A 的输出,拼接到 Agent B 的输入里。
在分布式场景下,消息传递才涉及真正的网络传输,Agent A 把消息序列化成 JSON,通过 HTTP 或消息队列发给 Agent B 所在的进程,Agent B 反序列化后放进自己的上下文。
消息队列的好处是解耦。Agent 不需要知道其他 Agent 在哪里、怎么调用。
这种解耦带来的灵活性是:你可以方便地新增 Agent、改变消息路由、或者让多个 Agent 订阅同一个收件箱。但代价是调试变难了:出了问题,你不知道消息在哪个环节丢了或者被错误处理了。需要额外的日志和追踪机制。
如果对方不是你自己系统里的 Agent,而是别的团队、用别的框架部署的独立服务,字段格式就不能靠私下约定。这时可以用 A2A(Agent2Agent)协议来暴露服务和通信。它是Google提出来的一套开放协议,用来让一个 Agent 发现另一个远程 Agent,把任务委托过去,再拿回结果。
这跟之前讲过的MCP很相似,都是为了解决通信问题而提出的一套协议。这里我们不展开讲解,感兴趣的话,可以自己研究吧。
状态共享
Agent 之间不直接发消息,而是读写一个公共的状态对象。比如用数据库表来存状态。Agent A 把结果写到状态里的某个字段,Agent B 从状态里读取这个字段。
还是刚才那个内容生产系统,这次我们定义一个状态对象:
state = {
"topic": "国产大模型代码生成能力分析",
"research_facts": [], # 研究员写入
"draft": "", # 写作者写入
"review_comments": [], # 审核者写入
"status": "researching" # 当前阶段
}这个状态对象是整个系统的公共数据区。每个 Agent 只读写自己负责的字段,不关心其他字段是怎么来的。
研究员完成工作后,把整理好的事实写入 research_facts,然后把状态切换到写作阶段。写作者Agent发现状态中的statue为writing,于是就开始执行自己的流程。
state["research_facts"] = [
{"model": "DeepSeek", "benchmark": "HumanEval", "score": 85.2, "source": "官方技术报告"},
{"model": "Qwen", "benchmark": "MBPP", "score": 78.5, "source": "第三方评测"},
{"model": "GLM", "benchmark": "HumanEval", "score": 81.0, "source": "官方博客"},
{"model": "Kimi", "benchmark": "MBPP", "score": 76.3, "source": "第三方评测"}
]
state["status"] = "writing"其实,你有没有发现,Agent之间的通信机制,跟我们做其他业务开发时,多个系统之间的通信机制没啥两样,要么通过 HTTP接口,要么通过消息队列,要么通过数据库共享数据表。这也应征了前面反复提到的,Agent开发跟其他业务系统开发,没啥大的区别,都是在解决一堆工程问题!
五、从零实现最小 Multi-Agent 系统
下面实现一个最小的Supervisor结构的Multi-Agent系统。
这个例子实现一个"产品分析"任务:用户给出一个产品名称,系统派出研究员 Agent 搜集信息,分析师 Agent 做分析,最后由 Supervisor 汇总。
import json
from openai import OpenAI
client = OpenAI()
# ---------- 工具定义 ----------
def search_web(query: str) -> str:
"""模拟网页搜索"""
return f"关于「{query}」的搜索结果:该产品在2026年市场份额为23%,同比增长15%。"
def analyze_data(data: str) -> str:
"""模拟数据分析"""
return f"分析结论:{data} 数据显示增长势头良好,建议加大投入。"
# 工具的 JSON Schema 定义
SEARCH_TOOL = {
"type": "function",
"function": {
"name": "search_web",
"description": "搜索网页获取产品信息",
"parameters": {
"type": "object",
"properties": {
"query": {"type": "string", "description": "搜索关键词"}
},
"required": ["query"]
}
}
}
ANALYZE_TOOL = {
"type": "function",
"function": {
"name": "analyze_data",
"description": "对数据进行分析并给出结论",
"parameters": {
"type": "object",
"properties": {
"data": {"type": "string", "description": "待分析的数据"}
},
"required": ["data"]
}
}
}
# 工具名到实际函数的映射
TOOL_FUNCTIONS = {
"search_web": search_web,
"analyze_data": analyze_data
}
def execute_tool(name, args):
if name not in TOOL_FUNCTIONS:
return {"error": f"未知工具 {name}"}
return TOOL_FUNCTIONS[name](**args)
# ---------- Worker Agent ----------
class WorkerAgent:
def __init__(self, name, role, tools, model="gpt-5.6"):
self.name = name
self.role = role
self.tools = tools
self.model = model
def run(self, task):
prompt = f"""你是{self.role}。你的任务是:{task}
根据任务描述,选择合适的工具调用。如果任务不需要工具,直接给出结果。
"""
response = client.chat.completions.create(
model=self.model,
messages=[{"role": "user", "content": prompt}],
tools=self.tools,
tool_choice="auto",
temperature=0
)
message = response.choices[0].message
if message.tool_calls:
tool_call = message.tool_calls[0]
name = tool_call.function.name
args = json.loads(tool_call.function.arguments)
result = execute_tool(name, args)
return {"worker": self.name, "tool_used": name, "result": result}
return {"worker": self.name, "tool_used": None, "result": message.content}
# ---------- Supervisor Agent ----------
class SupervisorAgent:
def __init__(self, workers, model="gpt-5.6"):
self.workers = workers
self.model = model
def dispatch(self, user_task):
worker_desc = "\n".join([
f"- {w.name}: {w.role}"
for w in self.workers
])
prompt = f"""你是一个任务调度器。用户任务:{user_task}
可用的 Worker:
{worker_desc}
请把任务拆成子任务,分配给合适的 Worker。输出 JSON:
{{"assignments": [{{"worker": "worker名", "task": "子任务描述"}}]}}
"""
response = client.chat.completions.create(
model=self.model,
messages=[{"role": "user", "content": prompt}],
response_format={"type": "json_object"},
temperature=0
)
return json.loads(response.choices[0].message.content)["assignments"]
def summarize(self, user_task, results):
results_text = json.dumps(results, ensure_ascii=False, indent=2)
prompt = f"""用户任务:{user_task}
各 Worker 的执行结果:
{results_text}
请基于以上结果,生成一份完整的最终回答。
"""
response = client.chat.completions.create(
model=self.model,
messages=[{"role": "user", "content": prompt}],
temperature=0.5
)
return response.choices[0].message.content
# ---------- 主流程 ----------
def multi_agent_system(user_task):
researcher = WorkerAgent(
name="研究员",
role="负责搜集产品信息和市场数据",
tools=[SEARCH_TOOL]
)
analyst = WorkerAgent(
name="分析师",
role="负责分析数据并给出结论",
tools=[ANALYZE_TOOL]
)
supervisor = SupervisorAgent(workers=[researcher, analyst])
# 1. 分派任务
assignments = supervisor.dispatch(user_task)
# 2. 执行子任务
results = []
for assignment in assignments:
worker_name = assignment["worker"]
task = assignment["task"]
worker = next(w for w in [researcher, analyst] if w.name == worker_name)
result = worker.run(task)
results.append(result)
# 3. 汇总结果
final_answer = supervisor.summarize(user_task, results)
return final_answer
if __name__ == "__main__":
result = multi_agent_system("分析一下某国产大模型在2026年的市场表现,并给出是否值得投资的建议。")
print(result)这段代码虽然简化了很多,但保留了 Supervisor 模式的核心结构:Supervisor 负责分派和汇总,Worker 负责执行具体任务,Worker 之间不直接通信,所有信息都通过 Supervisor 中转。
实际项目中,这个结构会更复杂。比如 Worker 可能需要多轮执行、Supervisor 可能需要根据 Worker 的中间结果动态调整分派、Worker 之间可能需要共享一些状态。但基本的骨架就是这样。
虽然自己从零实现 Multi-Agent 系统也是可行的,但生产项目里通常会借助框架,主流的框架有:LangGraph、AutoGen、CrewAI等,关于框架,我们会在下一个模块中详细讲解。
六、工程实践中的关键细节
我们再来看工程实践中一些要注意的细节。
角色设计
Multi-Agent 系统里,角色的划分直接决定了系统的效果。
好的角色划分应该满足两个条件:职责单一,边界清晰。
边界清晰意味着两个 Agent 不应该做同一件事。如果研究员和写作者都在搜网页,那拆分的意义就没了。
职责单一意味着每个 Agent 的职责可以用一句话说清楚,而且这句话不包含"或者"。比如"负责搜索和整理数据"就有问题,搜索和整理是两个不同的工作,应该拆给两个 Agent,或者明确这个 Agent 是先搜后整理。
你有没有发现,这跟微服务中的服务划分有点类似?
通信协议
Agent 之间传递什么信息,用什么格式,需要提前定义好。
最常见的方式是用结构化的 JSON。每个 Agent 的输出都遵循一个 schema,包含任务 ID、结果类型、数据内容、状态码等字段。这样接收方可以程序化地解析,不需要理解自然语言。
但结构化 JSON 有一个代价:它限制了 Agent 输出的灵活性。如果某个 Agent 想传递的信息不适合预定义的 schema,就需要额外处理。
终止条件
Multi-Agent 系统比单 Agent 更容易失控,因为它涉及多个 Agent 的交互。
常见的失控模式有两种。一种是无限对话:两个 Agent 来回传递任务,谁也说不清什么时候该结束。另一种是任务漂移:每个 Agent 都在做自己认为对的事,但合起来偏离了原始目标。
终止条件需要同时在两个层面设置。单个 Agent 层面:每个 Agent 的最大执行步数、最大重试次数。系统层面:整个任务的最大执行时间、最大模型调用次数、以及一个明确的"任务完成"信号。
"任务完成"信号的设计很重要。可以由 Supervisor 判断,也可以由一个专门的"完成检查"Agent 判断。判断标准应该写清楚:所有子任务是否都有结果、结果是否满足质量要求、是否有未解决的冲突。
调试与可观测性
Multi-Agent 系统最难的部分是调试。出了问题,你不知道是哪个 Agent 的决策错了,还是通信环节丢了信息,还是协调机制有缺陷。
解决方式是记录完整的执行轨迹。每个 Agent 的输入、输出、工具调用、决策依据都要记下来。LangGraph 和 AutoGen 都提供了追踪功能,可以可视化整个执行流程。这跟微服务的调用链追踪非常类似。
本篇小结

29-Agent和Workflow
前面几篇讲的都是"纯 Agent"的架构——从 ReAct 到 Plan-and-Execute,从 Reflection 到 Multi-Agent,它们的共同点是:下一步做什么,由模型自己决定。
但真实项目里,很多系统并不是纯 Agent。更常见的情况是:一部分用工作流(workflow),一部分用 Agent,两者拼在一起。比如用户发一条消息进来,先用大模型做意图识别,判断用户想干什么,然后交给对应的工作流去处理。工作流里如果需要灵活决策,再调用一个 Agent。
这种混合架构在生产环境里非常普遍,但很少有课程专门讲它。这一篇我们就来补上这块。
一、为什么不是所有事都该交给 Agent
先想一个问题:假设你要做一个客服系统,用户可能问"我的订单到哪了""我要退款""这个商品有货吗""你们的退货政策是什么"。
如果全部用 Agent 来做,会是什么样?
Agent 收到用户消息,自己判断该调用哪个工具,自己决定查询参数,自己组织回复。看起来灵活,但有几个问题。
第一是成本。 每一次用户消息都要调用模型来决策,即使用户问的只是"我的订单到哪了"这种简单问题,也要走一遍"推理→选工具→执行→组织回复"的完整循环。如果一个客服系统每天处理十万条消息,这个成本会非常可观。
第二是可靠性。 Agent 的决策依赖模型,而模型有概率出错。用户问"订单到哪了",Agent 可能误判为"用户想查物流政策",然后去搜政策文档,给出了一个答非所问的回复。对于简单、明确的问题,用工作流可以做到 100% 的确定性。
第三是可测试性。 工作流的每一步是确定的,可以写单元测试。Agent 的行为依赖模型的输出,很难写稳定的测试。如果一个系统的核心流程是"查询订单→获取物流状态→格式化回复",用工作流实现,每个环节都能独立测试;用 Agent 实现,测试就变成了"跑一百遍看它有没有出错"。
第四是延迟。 Agent 的每一步都要调用模型,一次完整循环可能几秒钟。工作流可能几百毫秒就完成了。对于实时性要求高的场景,这个差距很关键。
所以,对于那些步骤固定、判断规则明确、输出格式确定的任务,工作流是更好的选择。Agent 应该用在那些步骤不确定、需要动态决策、需要理解自然语言输入的环节。
实际上,真实的项目开发中,通常是两者结合:用 Agent 做理解和决策,用工作流做确定性的执行。
二、大模型做意图识别,路由到工作流
用户输入先进大模型做意图识别,识别出的意图决定走哪条工作流。这是混合架构里最常见的一种模式。
还是用客服系统来举例。用户发来一条消息,系统先调用一次模型,判断用户的意图属于哪一类:
用户消息:"我上周买的那个耳机,到现在还没发货,能帮我看看吗?"
意图识别结果:
{
"intent": "query_order_status",
"confidence": 0.92,
"entities": {"product": "耳机", "time": "上周"}
}拿到意图之后,系统就不需要再让模型来决策了。意图是 query_order_status,就直接走"查询订单状态"这条工作流。工作流里做的是确定的事:根据用户 ID 查订单表,拿到订单号,调物流接口查状态,把状态格式化成用户能看懂的话,返回。
整条链路上,只有意图识别这一步用了模型。后面的查询、格式化、返回,都是确定性的代码。
这样做的好处非常明显。意图识别只需要一次模型调用,成本远低于 Agent 循环。工作流部分完全确定,不会出现"模型今天心情不好,把订单查询做成了退款申请"这种情况。而且工作流可以并行、可以缓存、可以做精细的错误处理,这些都是 Agent 循环不擅长的。
当然,意图识别本身也可能出错。模型可能把"我要退款"误判为"查询订单",或者遇到一个训练时没见过的意图,不知道该分到哪一类。所以这个模式里,有几个工程细节需要处理好。
第一,意图的分类体系要设计好。 意图类别不能太粗,也不能太细。太粗(比如只有"咨询"和"投诉"两类),路由到工作流后还是不知道该做什么。太细(比如把"查物流"拆成"查快递公司""查预计到达时间""查是否发货"),模型分类的准确率会下降。一个经验是:每个意图对应一条明确的工作流。如果两条工作流处理的事情差不多,就应该合并成一个意图。
第二,要有兜底机制。 当模型给出的置信度低于阈值,或者识别出的意图不在预定义列表里,不能直接丢给工作流。常见的做法是转人工,或者走一个通用的 Agent 流程来处理这些"不确定"的输入。
第三,意图识别和槽位抽取一起做。 用户说"我上周买的那个耳机还没发货",意图是"查询订单状态",槽位是"耳机"和"上周"。这两个信息一起给到工作流,工作流才能准确地查询。如果只给意图不给槽位,工作流还得再去问用户"你买的是哪个商品"。如果必填槽位缺失,系统不应该硬着头皮往下走,而应该追问用户。
用代码来表示这个模式,结构大致是这样:
import json
from openai import OpenAI
client = OpenAI()
INTENT_PROMPT = """你是一个意图识别器。根据用户消息,判断意图并抽取实体。
预定义的意图和对应的输出格式:
1. query_order_status(查询订单状态)
输出JSON格式:
{"intent": "query_order_status", "confidence": 0.0-1.0, "entities": {"order_id": "订单号或null", "product": "商品名称或null", "time_range": "时间范围或null"}}
注意:order_id 和 product 至少提供一个。
2. request_refund(申请退款)
输出JSON格式:
{"intent": "request_refund", "confidence": 0.0-1.0, "entities": {"order_id": "订单号(必填)", "refund_reason": "退款原因或null", "refund_amount": "退款金额或null"}}
3. query_product(查询商品信息)
输出JSON格式:
{"intent": "query_product", "confidence": 0.0-1.0, "entities": {"product_name": "商品名称(必填)", "attributes": ["属性1", "属性2"]}}
4. query_policy(查询政策)
输出JSON格式:
{"intent": "query_policy", "confidence": 0.0-1.0, "entities": {"policy_type": "政策类型(必填)"}}
5. complaint(投诉)
输出JSON格式:
{"intent": "complaint", "confidence": 0.0-1.0, "entities": {}}
6. unknown(无法识别)
输出JSON格式:
{"intent": "unknown", "confidence": 0.0-1.0, "entities": {}}
注意:
- 根据识别出的意图,按对应的输出格式填写 entities 字段。
- 只填写当前意图对应的字段,不要填写其他意图的字段。
- 如果用户没有提供某个字段,该字段设为 null,不要编造。
"""
def recognize_intent(user_message):
response = client.chat.completions.create(
model="gpt-5.6-luna", # 意图识别任务简单,用便宜模型
messages=[
{"role": "system", "content": INTENT_PROMPT},
{"role": "user", "content": user_message}
],
response_format={"type": "json_object"},
temperature=0
)
return json.loads(response.choices[0].message.content)
def handle_message(user_message, user_id):
intent_result = recognize_intent(user_message)
intent = intent_result["intent"]
confidence = intent_result["confidence"]
entities = intent_result.get("entities", {})
# 置信度低或未知意图,走兜底
if confidence < 0.7 or intent == "unknown":
return fallback_handler(user_message, user_id)
# 路由到对应的工作流
if intent == "query_order_status":
return workflow_query_order_status(user_id, entities)
elif intent == "request_refund":
return workflow_request_refund(user_id, entities)
elif intent == "query_product":
return workflow_query_product(entities)
elif intent == "query_policy":
return workflow_query_policy(entities)
elif intent == "complaint":
return workflow_complaint(user_id, user_message)
else:
return fallback_handler(user_message, user_id)每个 workflow_xxx 都是一个确定性的函数,里面可能查数据库、调 API、拼回复,但不调用模型做决策。这样整个系统的行为就是可预测、可测试、可审计的。
实际上,意图识别除了可以将用户的任务路由到不同workflow处理之外,还可以路由到不同的agent处理,这样做的好处前面提到过,保证每个agent的角色单一,上下文不会过大,工具集不会过多。
四、工作流里嵌 Agent
混合架构不只有"Agent 做路由、工作流做执行"这一种方向。反过来,工作流里也可以嵌 Agent。
假设客服系统里有一条工作流是"处理投诉"。这条工作流的前几步是确定的:记录投诉内容、查询用户历史订单、判断投诉是否在有效期内。但到了"生成道歉和补偿方案"这一步,就不确定了。道歉的语气要因情况而异,补偿方案要根据用户的消费历史和投诉严重程度来定,这些都不是简单的规则能覆盖的。
这时候,工作流可以在这个节点上调用一个 Agent,让 Agent 基于上下文来生成道歉和补偿方案。Agent 的输出回到工作流里,工作流继续走后面的确定性步骤:把方案发给用户、记录处理结果、安排跟进。
用代码来表示,大概是这样:
def workflow_complaint(user_id, user_message):
# 确定性步骤:记录投诉
complaint_id = db.create_complaint(user_id, user_message)
# 确定性步骤:查询用户历史
user_history = db.get_user_history(user_id)
recent_orders = db.get_recent_orders(user_id, limit=5)
# 确定性步骤:判断是否在有效期内
if not is_within_complaint_window(complaint_id):
return "您的投诉已超过有效期,请联系人工客服。"
# 非确定性步骤:交给 Agent 生成道歉和补偿方案
apology_and_compensation = complaint_agent.run(
user_message=user_message,
user_history=user_history,
recent_orders=recent_orders
)
# 确定性步骤:记录方案
db.save_compensation_plan(complaint_id, apology_and_compensation)
# 确定性步骤:发送给用户
send_message(user_id, apology_and_compensation)
# 确定性步骤:安排跟进
schedule_followup(complaint_id, days=3)
return "您的投诉已受理,我们会在 3 天内跟进。"这个工作流里,只有"生成道歉和补偿方案"这一步用了 Agent,其他步骤都是确定的。这样做的好处是,工作流的主体逻辑仍然可靠、可测试,Agent 只在真正需要灵活性的地方介入。
实际项目里,这种"工作流为主、Agent 为辅"的结构往往比"Agent 为主"更常见,因为它把不确定性控制在最小的范围内。
五、Agent 里嵌工作流
还有一种方向是 Agent 里嵌工作流。Agent 在决策过程中,可以把一条工作流当作一个工具来调用。
比如一个智能运维 Agent,它接收到告警后需要判断问题的严重程度、定位根因、执行修复。其中"执行修复"这个环节,可能对应一条已经固化的运维工作流:先重启服务,检查健康状态,如果还没恢复就回滚到上一个版本,再检查。
这条工作流是运维团队经过多次实践总结出来的,步骤固定,不需要 Agent 临时决策。Agent 只需要在判断出"需要执行修复"之后,调用这条工作流,拿到执行结果,再继续自己的推理。
用代码表示,就是把工作流包装成一个工具函数:
def execute_repair_workflow(service_name, issue_type):
"""执行标准修复工作流"""
# 步骤1:重启服务
restart_result = restart_service(service_name)
if restart_result.success:
return {"status": "recovered", "action": "restart"}
# 步骤2:检查健康状态
health = check_health(service_name)
if health.ok:
return {"status": "recovered", "action": "restart"}
# 步骤3:回滚到上一个版本
rollback_result = rollback_service(service_name)
if rollback_result.success:
return {"status": "recovered", "action": "rollback"}
# 步骤4:升级到人工处理
return {"status": "escalated", "action": "manual_intervention"}
# 把工作流注册为 Agent 的工具
REPAIR_TOOL = {
"type": "function",
"function": {
"name": "execute_repair_workflow",
"description": "执行标准修复流程:重启服务、检查健康、必要时回滚",
"parameters": {
"type": "object",
"properties": {
"service_name": {"type": "string"},
"issue_type": {"type": "string"}
},
"required": ["service_name", "issue_type"]
}
}
}Agent 在推理时,如果需要执行修复,就调用这个工具。工作流内部的所有步骤都是确定的,Agent 不需要关心中间过程,只需要拿到最终结果。
这种结构把"什么情况下需要修复"交给 Agent 判断,把"怎么修复"交给工作流执行。判断是 Agent 擅长的,执行是工作流擅长的,各取所长。
本篇小结

