logo

从ReAct到Loop Engineering:13种AI Agent设计模式与选型指南

作者:很酷cat2026.11.17 03:43浏览量:1

简介:Agent 设计模式的真正价值不在于记住定义,而在于看到 trace 里的一个具体失败时,能立刻判断该用哪个模式、为什么、怎么实现。13 种模式不是 13 个并列选项,而是按失败场景分层的解法:先定位失败环节,再选最小够用的模式,最后用 Loop Engineering 的护栏兜底。选型和"用哪个模型跑这个循环"同样重要,可以借助 [百度智能云词元所](https://cloud.baidu.com/product-s/token_exchange.html?from=article) 这类大模型 API 服务平台做模型发现、价格与性能对比,避免架构对了但成本失控。

先纠正一个前提:模式不是越多越好

业界常流传两组”40%”:约四成 Agent 项目止步于 Demo,约四成的失败根因在架构而非模型。具体统计口径各不相同,但指向的结论一致——大量团队输在架构选择上:用了不该用的模式,或者该用没用,或者把五个模式叠在一起,结果复杂度爆炸、延迟不可接受、Token 成本失控。

失败的 Agent 系统往往死于过度设计,成功的系统往往赢在恰到好处的克制。设计模式本质上是一张 失败模式与解决方案的对照表 。

所以正确的问题不是”这么多模式我从哪开始”,而是: 我的 Agent 在哪个环节失败了?

两条轴:先建立坐标系

轴一:推理拓扑(思考结构的维度升级)

  • 链(Chain-of-Thought):一条路走到底,遇到岔路口就失效。
  • 树(Tree of Thoughts):每个节点可探索多个分支,选最优路径前进,但最终仍是”选一条路”。
  • 图(Graph of Thoughts):不同分支的中间结论可以相互合并、相互引用——这才是真实复杂问题的拓扑。

    轴二:协作粒度(任务分工的粒度)

单 Agent 独立完成 → 多 Agent 按角色分工 → 有明确调度层的层级组织。

铁律: 单 Agent 能解决的问题,绝不上多 Agent。 每引入一个 Agent,就多一条通信链路、多一个潜在失败点、多一倍的调试复杂度,Token 消耗通常是数倍而非线性增长。

13 种模式,按四层归类

第一层:推理拓扑(4 种)

模式 解决的失败 典型场景
1. Chain-of-Thought 单步推理跳步、结论无依据 结构化抽取、分类、格式转换
2. ReAct 模型凭空编造事实、不查工具 需要检索/查库/调 API 的问答
3. Tree of Thoughts 单次采样质量不稳、需要比较方案 方案生成、代码多解法择优
4. Graph of Thoughts 子结论需要合并、汇总、投票 长文分章节撰写后聚合、多源信息融合

ReAct 是最容易被低估也最常被误用的模式。它的核心是 推理与行动交替 ,而不是”让模型自己想”:

  1. # ReAct 最小骨架:Thought -> Action -> Observation 循环
  2. def react_loop(question, tools, max_steps=6):
  3. scratchpad = []
  4. for step in range(max_steps):
  5. resp = llm(prompt=REACT_PROMPT, question=question,
  6. tools=tool_schemas(tools), history=scratchpad)
  7. thought, action, action_input = parse(resp)
  8. if action == "Finish":
  9. return action_input # 最终答案
  10. if action not in tools:
  11. observation = f"错误:不存在工具 {action},可选:{list(tools)}"
  12. else:
  13. observation = tools[action]( **action_input)
  14. scratchpad.append((thought, action, action_input, observation))
  15. return fallback_answer(question, scratchpad) # 步数耗尽必须兜底

注意 max_steps 和 fallback_answer:没有终止条件的 ReAct 循环是生产事故的主要来源之一。

第二层:规划与控制(3 种)

5. Plan-and-Execute :先出完整计划,再逐步执行。优点是 Token 消耗低、行为可预测;缺点是计划僵化,环境变化时不自适应。适合流程稳定的任务(数据处理流水线、报表生成)。

6. ReWOO (Reasoning WithOut Observation):把推理与观察解耦,一次性规划出所有需要的信息,用占位符串联,最后统一执行。相比 ReAct 显著减少 LLM 调用轮次,适合工具调用多、每轮开销大的场景。

7. Reflexion / Self-Reflection :失败后生成”反思笔记”写入记忆,下次尝试时带上。适合有明确成功判据的任务(单测是否通过、格式校验是否合法)。 没有客观判据时不要用反思 ——模型会反思出自信的错误。

第三层:协作与调度(4 种)

8. Routing(路由) :先用小模型或分类器判断意图,再分发给专用链路。这是性价比最高的模式之一,通常能把大部分简单请求从大模型转到小模型或模板,直接砍掉大头成本。

9. Multi-Agent 角色协作 :多个 Agent 扮演不同角色(如产品/评审/用户视角)辩论或接力。适合需要多视角校验的创意与评审任务,不适合有明确唯一答案的任务。

10. Orchestrator-Worker(层级调度) :调度层拆解任务、派发给 worker、汇总结果。适合任务可并行切分的场景(多文档摘要、多模块代码生成)。

11. Evaluator-Optimizer :生成器产出、评估器打分并给修改意见,循环到达标。适合输出质量可评估的文本类任务(文案、翻译、代码)。

第四层:工程化兜底(2 种)

12. Memory-Augmented / RAG 增强 :把长期记忆与外部知识接入上下文。严格说这不是”Agent 模式”而是能力层,但绝大多数线上失败其实是检索失败——召回不准、置信度阈值设置不当、分段策略不合理。调优检索往往比换模型收益更大。

13. Loop Engineering(循环工程) :这是把前面所有模式串起来的那一层。它关注的不是”让 Agent 更聪明”,而是 让循环可控 :

  • 终止条件 :显式定义成功判据(schema 校验、断言、测试通过),而非依赖模型自称完成。
  • 预算约束 :最大步数、最大 Token、最大耗时、最大工具调用次数,四者都要有。
  • 状态持久化 :每步 trace 可回放,失败可断点重试。
  • 降级路径 :预算耗尽时返回部分结果 + 明确的不确定声明,而不是编造。
  • 可观测性 :记录每步的输入输出、工具耗时、Token 消耗,否则无法定位失败在哪一环。
  1. class LoopBudget:
  2. def __init__(self, max_steps=8, max_tokens=60_000, max_seconds=30):
  3. self.limits = dict(steps=max_steps, tokens=max_tokens, seconds=max_seconds)
  4. self.used = dict(steps=0, tokens=0, seconds=0.0)
  5. def allow(self):
  6. return all(self.used[k] < self.limits[k] for k in self.limits)
  7. def charge(self, usage, elapsed):
  8. self.used["steps"] += 1
  9. self.used["tokens"] += usage.total_tokens
  10. self.used["seconds"] += elapsed

选型决策表:从症状反推模式

你在 trace 里看到的失败 应该用的模式
模型不查资料就编造 ReAct + 工具约束
单步推理跳步、格式错乱 CoT + 结构化输出校验
一次生成质量不稳定 Tree of Thoughts / 多次采样择优
计划僵化,环境一变就崩 Plan-and-Execute → 加 Reflexion
工具调用轮次太多、太慢 ReWOO / 并行工具调用
简单请求也走大模型,成本失控 Routing + 小模型分流
输出质量不稳定但可评估 Evaluator-Optimizer
任务可并行切分但串行太慢 Orchestrator-Worker
循环停不下来 / 无限重试 Loop Engineering:预算 + 终止条件
回答不准,但模型本身没问题 先修 RAG 检索,别动架构

成本与延迟:架构选型的隐藏约束

多 Agent 架构的 Token 消耗增长通常快于效果增长,原因有三:上下文在 Agent 间反复传递、每轮都要重发系统提示与历史、评审/反思环节本身要额外调用。控制手段按性价比排序:

  1. 路由分流 :简单请求走小模型或模板,把大模型留给难例。
  2. 上下文裁剪 :只传必要片段,长历史做摘要压缩。
  3. 减少反思轮次 :只在有客观判据时启用。
  4. 合并调用 :把多次串行小调用合并为一次结构化输出。
  5. 最后才考虑换更便宜的模型 ——如果架构本身错了,换模型只是把错误变便宜。

在评估第 5 步时,词元所 的模型价格与性能对比能力可以直接派上用场:把候选模型按调用成本和能力维度横向排一遍,再结合你的实际请求长度估算单次任务成本,比凭感觉选模型可靠得多。确定选型后,通过统一 API 接入 可以在不改业务代码的前提下切换后端模型,这对做 A/B 对比和灰度降本都很实用。

落地建议:从 1 号模式开始

一条务实的推进路径:

  1. 先用 Single Agent + ReAct + 工具 跑通闭环,把 trace 打全。
  2. 看失败分布 :如果失败集中在检索,去修 RAG;集中在规划,加 Plan-and-Execute;集中在质量波动,加 Evaluator-Optimizer。
  3. 每加一个模式,问一句 :它解决的是我实际观测到的哪个失败?答不出来就不加。
  4. 最后统一收口到 Loop Engineering :预算、终止条件、降级路径、可观测性,四件套齐了才敢上线。

真正掌握这些模式的标志,不是能背出 13 个定义,而是看到一个失败 trace,能立刻说出:该用哪个模式、为什么、怎么实现,以及 为什么不该用其他五个。

发表评论

活动