Agent开发 03|架构选型:不同模式怎么选?
《Agent开发》系列 · 第 03 篇
假设我们正在开发一个 AI 客服助手。用户提出:
订单 1001 已经支付成功,但金币没有到账,帮我查一下原因。
系统需要查询订单支付状态、金币发放记录,必要时还要检查账户余额、服务端日志或相关业务规则。但这些步骤应该怎样组织?我们可以先考虑三种常见方式。
1. Workflow(工作流):按照预先设计的流程执行
开发者提前规定主要步骤和条件分支,例如先查询订单,支付成功后再查询金币发放记录。
- 核心特点:流程明确、可控性高、容易测试。
- 适合场景:支付验证、订单状态流转、标准化审批、固定业务处理。
- 主要局限:面对大量未知情况时,流程分支可能越来越复杂。
2. ReAct(Reasoning + Acting,推理与行动):边观察,边决定下一步
模型根据当前信息选择工具,获得结果后再判断下一步需要做什么。
- 核心特点:动态决策、灵活探索、能够根据新信息调整行动。
- 适合场景:故障排查、开放式检索、复杂问题调查。
- 主要局限:可能选错工具、重复查询或过早结束,需要执行预算和安全约束。
3. Planner-Executor(规划器---执行器):先制定计划,再逐步执行
先将复杂目标拆分为若干步骤,再由执行器完成;当执行结果使原计划不再适用时,可以调整计划。
- 核心特点:规划与执行分离,适合管理多阶段任务和步骤依赖。
- 适合场景:复杂数据分析、跨系统调查、长任务、研究报告。
- 主要局限:计划可能不准确,需要额外的规划成本和状态管理。
先记住一个直观区别:Workflow 强调流程可控,ReAct 强调动态探索,Planner-Executor 强调先规划再执行。
不过,这并不意味着 Agent 只有三种架构。实际系统还经常使用 Routing(路由分发)、Parallelization(并行执行)、Orchestrator-Workers(编排者与执行者)、Evaluator-Optimizer(评估与优化)、Multi-Agent(多智能体协作)和 Human-in-the-Loop(人机协同)等模式。而且,它们并不是同一个维度上的互斥选项。
例如,一个系统可以使用 Workflow 控制主要业务流程,通过 Routing 选择专业处理模块,再让某个模块采用 ReAct 动态排查问题,最后由 Evaluator 检查结果质量。
不同模式分别解决什么问题?它们之间有什么关系?在实际工程中应该怎样组合?
一、先建立 Agent 架构的整体认知
1.1 从工具调用到架构设计
**Function Calling(函数调用)**让模型根据任务和工具定义,提出结构化工具调用请求,例如,下面用简化格式表示一个请求:
json
{"name":"get_order_status","arguments":{"order_id":"1001"}}
后端接收请求,校验并执行工具。
**Agent Loop(智能体执行循环)**组织模型与工具之间的多轮交互:
text
调用模型 → 模型请求工具 → 后端执行 → 反馈结果 → 再次调用模型 → 继续或结束
它们解决的是如何调用工具、如何持续执行。但哪些步骤由程序决定、哪些由模型决定、是否需要规划、分工或审批,属于 Agent 架构设计。
1.2 这些模式为什么不属于同一层级?
Agent 架构没有统一且互斥的分类标准。我们常说的"模式",有些描述整体流程,有些描述某个环节的组织方式,还有些描述参与者怎样协作。
例如,Workflow 表示主要执行路径由程序预先安排;Routing 则负责将请求分发到合适的处理模块。一个 Workflow 完全可以先做 Routing,再并行查询多个系统,最后检查结果。
因此,下面的表格是一张帮助理解设计问题的地图,不是一组必须选其一的架构类别。
| 要解决的设计问题 | 常见方式 | 与其他方式的关系 |
|---|---|---|
| 主要步骤怎样确定? | Workflow、ReAct | 可由程序预定义,也可让模型动态选择;固定流程中可以嵌入动态排查 |
| 是否先制定计划? | Planner-Executor | 执行计划时,可以采用固定步骤,也可以让某一步动态探索 |
| 请求交给谁处理? | Routing | 可以作为工作流中的一个步骤 |
| 多项工作怎样安排? | 串行、Parallelization、Orchestrator-Workers | 可以用于工作流或计划执行过程 |
| 结果怎样迭代改进? | Evaluator-Optimizer | 可以组成评估、反馈、修改的循环工作流 |
| 谁参与完成任务? | Multi-Agent、Human-in-the-Loop | 可以叠加在上述流程中,引入多个 Agent 或人工参与 |
本文先比较 Workflow、ReAct 和 Planner-Executor,理解执行步骤与决策如何安排;再介绍其他组织方式,最后讨论组合与选型。
1.3 模式可以组合
text
用户任务
↓
Routing 判断任务类型
├── 标准业务 → Workflow
└── 复杂分析 → Planner-Executor
├── ReAct 动态排查
└── Parallelization 并行统计
↓
Evaluator 检查
↓
可信业务校验
这只是组合示意,不是所有系统都必须具备的组件。简单任务可能只需要一个普通函数。
二、Workflow:让程序控制主要执行流程
2.1 定义与原理
Workflow(工作流)是开发者预先定义主要步骤、条件分支和执行规则的任务组织方式。
text
查询订单支付状态
↓
是否支付成功?
├── 否 → 返回支付状态
└── 是 → 查询金币发放记录
├── SUCCESS → 提示核对余额
├── FAILED → 返回失败信息
└── NO_RECORD → 提示未找到记录
关键在于执行路径由程序控制。Workflow 不等于没有 AI:可以让 LLM 提取订单编号,程序按固定规则查询,最后让 LLM 解释结果。模型处理语言的不确定性,程序控制确定性的业务分支。
2.2 简单实现
python
# 流程片段:工具返回结构与第八节一致,完整程序见附录。
def order_workflow(order_id):
payment = get_order_status(order_id)
if payment == "NOT_FOUND":
return "订单不存在"
if payment == "UNPAID":
return "订单尚未支付"
if payment != "PAID":
return "支付状态未知,需要进一步核对"
grant = get_grant_record(order_id)
if grant is None:
return "没有找到金币发放记录"
if grant.get("status") == "FAILED":
return "金币发放失败"
return "请根据发放记录继续核对"
以上是流程片段,依赖第八节定义的工具函数,不能单独运行。get_order_status() 返回支付状态字符串,get_grant_record() 返回记录字典或 None。完整实现还会区分发放成功、处理中和未知状态。
2.3 优势、局限与适用边界
Workflow 的优势是可控、易测试、成本较可预测、容易审计。主要局限是未知分支增多时,流程设计与维护可能复杂。但分支复杂不代表必须改用 Agent,有时模块化工作流或规则引擎就足够。
适合支付验证、订单流转、标准审批、固定数据处理等规则明确的任务。工程原则是:如果普通程序能够稳定解决,就不必引入不必要的动态模型决策。
三、ReAct:根据观察结果动态决定下一步
3.1 ReAct 是什么?
ReAct 来自 Reasoning + Acting(推理与行动),强调推理、行动与观察之间的交替:
text
判断下一步 → 执行行动 → 观察结果 → 重新判断 → 继续或结束
现代工具调用系统可以通过模型工具请求、结果反馈和 Agent Loop 实现这种思想,不要求对外展示模型完整的内部推理过程。
3.2 订单案例
text
需要排查金币未到账
↓
模型选择 get_order_status("1001")
↓
观察:PAID
↓
模型选择 get_grant_record("1001")
↓
观察:FAILED / GRANT_TIMEOUT
↓
生成当前排查结论
与 Workflow 的关键区别不是是否调用工具,而是下一步工具选择可以由模型根据观察结果动态决定。
3.3 ReAct、Agent Loop、Runtime 的关系
| 概念 | 关注点 |
|---|---|
| Function Calling | 模型如何提出工具调用请求 |
| Agent Loop | 如何组织多轮模型与工具交互 |
| ReAct | 如何根据观察结果选择行动 |
| Runtime | 哪些程序负责执行、校验与控制 |
Runtime(智能体运行时)是实现并管理执行流程的程序,包括模型调用、工具执行、交互记录维护和执行限制。ReAct 可以通过 Agent Loop 实现,但 Agent Loop 不等于 ReAct。
3.4 简化伪代码
python
def react_loop(model, tools, history, max_steps=6):
for _ in range(max_steps):
decision = model(history)
if decision["type"] == "final":
return decision["answer"]
name = decision["tool"]
arguments = decision["arguments"]
if name not in tools:
raise ValueError("未知工具")
result = tools[name](**arguments)
history.append({"tool": name, "result": result})
return "达到最大执行轮数"
这不是某个模型 SDK 的实际协议,历史记录也作了简化。真实工具调用需要按所用 API 保留必要的模型输出、参数和请求标识,并关联工具结果;Runtime 还必须有参数校验、权限、超时、预算和错误处理。
3.5 优势、局限与适用边界
ReAct 适合故障排查、开放式检索和复杂问题调查,优势是灵活探索和动态调整。局限是模型可能选错工具、重复查询、遗漏步骤或提前结束,且成本可能随轮数增加。
优先判断 Workflow 是否已经足够。 只有确实需要动态探索时,才值得引入模型主导的行动选择。
四、Planner-Executor:把规划与执行分开
4.1 为什么需要规划?
如果用户要求"分析最近一周金币未到账投诉增加的原因",可能涉及支付统计、发放失败率、客户端版本、服务端日志、发布记录和最终报告。步骤较多时,直接探索容易遗漏维度、重复查询或偏离目标。
4.2 定义与流程
Planner-Executor(规划器---执行器)将任务规划与具体执行分离。
- Planner:理解目标、拆分步骤、安排依赖。
- Executor:检查并执行步骤,返回结果。
text
用户复杂任务 → Planner 制定计划 → Executor 执行步骤
↓
检查结果
├── 目标已满足 → 生成结论
├── 计划仍适用 → 继续执行剩余步骤
├── 计划需调整 → 重新规划,再交给 Executor
└── 无法继续或预算耗尽 → 停止并说明原因
Planner-Executor 不等于两个 Agent。 可以由一个 LLM 规划、普通 Python 程序执行,也可以进一步使用多个 Agent 分工。
4.3 结构化计划
json
{
"goal": "分析最近一周金币未到账投诉增加的原因",
"steps": [
{"id": 1, "action": "get_payment_statistics"},
{"id": 2, "action": "get_grant_failure_statistics"},
{"id": 3, "action": "get_recent_release_records"},
{"id": 4, "action": "analyze_results"}
]
}
计划不是执行结果。Executor 仍需校验允许的操作、参数、依赖和权限,并处理失败。
python
def execute_plan(plan, handlers):
results = {}
for step in plan["steps"]:
action = step["action"]
if action not in handlers:
raise ValueError(f"不支持的操作: {action}")
results[step["id"]] = handlers[action]()
return results
这是无参数、无依赖的顺序执行示意,仅演示按计划查找并调用处理函数。真实的 analyze_results 必须接收前序步骤的查询结果,例如由 Executor 从 results 取出统计数据并传入分析步骤;计划还应明确依赖哪些步骤、需要什么参数,以及依赖失败后是否继续。这里没有实现这些数据传递与依赖管理能力。
4.4 Re-planning:何时重新规划?
例如分析发现大部分发放失败集中在一次发布之后,就可以将后续计划改为比较发布前后失败率、检查新版本日志和相关配置。时间上的关联只是调查线索,不能直接证明该次发布导致了故障。并非每一步都必须重新规划;频繁规划会增加延迟和成本。
4.5 适用边界
Planner-Executor 适合复杂、多阶段、有依赖、需要进度跟踪的任务。其局限是计划可能错误,规划本身有成本,还需要维护计划版本与执行状态。对单笔订单查询来说通常属于过度设计。
五、除了三种核心模式,还有哪些常见模式?
5.1 Routing:路由分发
Routing 解决不同请求交给哪个处理模块的问题:
text
用户问题 → 分类路由
├── 支付问题 → 支付流程
├── 金币问题 → 发放排查
└── 登录问题 → 账号支持
路由可以使用规则、分类模型、LLM 或组合方式,不要求多个 Agent。
5.2 Parallelization:并行执行
多个相互独立的任务可以并行处理:
text
分析任务
┌────┼────┐
支付统计 发放统计 发布记录
└────┼────┘
汇总结果
存在先后依赖时不能随意并行。并行不一定需要多个 Agent,也不一定降低总资源消耗。
5.3 Orchestrator-Workers:编排者与执行者
Orchestrator 根据具体任务动态拆分子任务,Workers 完成子任务,再由编排者协调和汇总。
text
复杂任务 → Orchestrator 动态拆分
├── 支付分析 Worker
├── 发放分析 Worker
└── 日志分析 Worker
↓
汇总与检查
区别于预先固定的并行步骤,这里子任务可以根据输入动态决定;Workers 不一定必须并行,也不一定都是独立 Agent。
它与 Planner-Executor 的关注点不同:Planner-Executor 强调计划与执行的分离,Orchestrator-Workers 强调动态分派子任务和协调执行者。两者可以结合,例如先生成计划,再由编排者将步骤分派给不同 Workers。
5.4 Evaluator-Optimizer:评估与优化
text
生成初稿 → Evaluator 检查质量
├── 达标 → 输出
└── 不达标 → 反馈 → Optimizer 修改 → 再评估
适合报告、代码和内容质量改进。评价可以来自确定性规则、自动化测试、LLM-as-Judge 或人工评价。LLM-as-Judge 指使用模型按照评分标准评审结果;模型评审也可能出错,需要用人工样本或客观检查校准。必须设置迭代次数与预算上限。
5.5 Multi-Agent 与 Human-in-the-Loop
Multi-Agent 关注多个 Agent 如何分工、协调和交接。常见的 Supervisor(监督者)负责协调分工,Handoff(交接)表示把当前任务的处理权及必要上下文交给另一个 Agent。Human-in-the-Loop 关注哪些步骤需要人工确认、审批或接管。例如 Agent 可以建议补发金币,但实际补发必须经过可信授权和业务执行。这两个主题将在第 04 篇深入讨论。
| 模式 | 核心特色 | 典型场景 |
|---|---|---|
| Workflow | 预定义流程 | 标准业务 |
| ReAct | 动态探索 | 故障排查 |
| Planner-Executor | 先规划再执行 | 复杂多阶段任务 |
| Routing | 分类分发 | 多业务入口 |
| Parallelization | 独立任务并发 | 多来源查询 |
| Orchestrator-Workers | 动态拆分协调 | 复杂任务分工 |
| Evaluator-Optimizer | 评估反馈迭代 | 报告与代码优化 |
| Multi-Agent | 多智能体协作 | 专业角色分工 |
| Human-in-the-Loop | 人工确认控制 | 高风险操作 |
六、三种核心模式的区别
| 维度 | Workflow | ReAct | Planner-Executor |
|---|---|---|---|
| 核心 | 预定义流程 | 根据观察行动 | 规划与执行分离 |
| 决策权 | 主要由程序控制 | 较多由模型决定 | 规划器与执行器分工 |
| 路径 | 通常明确 | 可能动态变化 | 根据计划推进 |
| 可预测性 | 通常较高 | 通常较低 | 取决于计划与控制 |
| 成本 | 可以很低 | 可能随循环增加 | 规划与重规划有开销 |
| 典型任务 | 固定业务 | 动态排查 | 多阶段分析 |
| 风险 | 分支复杂 | 工具误选、重复调用 | 计划错误、状态不同步 |
这是典型倾向而非绝对规律。三者不是"简单→高级→更高级"的技术等级。
最关键的问题是:下一步由谁决定? 程序条件分支对应 Workflow;模型根据观察动态选择对应 ReAct;先制定整体计划再执行对应 Planner-Executor。
七、同一个订单业务如何选型?
任务 A:查询订单支付状态。 取得订单编号、查询订单、返回状态,普通程序或简单 Workflow 即可。
任务 B:排查金币未到账。 如果只有固定的支付状态和发放记录查询,Workflow 足够;如果需要动态检索日志、知识库、余额流水并根据线索深入调查,可以考虑 ReAct。
任务 C:分析一周异常趋势。 涉及统计、日志、版本、发布记录和报告等多个阶段,可以考虑 Planner-Executor;独立查询可并行,局部未知问题可交给 ReAct,报告可增加 Evaluator。
这些不是唯一答案,而是从需求出发的合理起点。
八、工程实践:同一套工具对比三种模式
本节使用 Mock,不需要 API Key。三个示例共用订单工具,但使用不同控制方式。Mock 演示结构,不代表真实模型的推理或规划能力。
三个示例的决策最终都由 Python 规则控制。我们比较的是代码怎样组织决策与执行,不是在证明三种真实 Agent 的效果相同。
下面分段解释实现。文末附录提供完整代码,可直接保存为 agent_architectures.py。配套项目中的脚本位于 demo/03-agent-architectures/agent_architectures.py(相对于文章所在目录)。
8.1 业务数据与工具
python
ORDERS = {"1001": "PAID", "1002": "UNPAID", "1003": "PAID"}
GRANTS = {
"1001": {"status": "FAILED", "error_code": "GRANT_TIMEOUT"},
"1003": {"status": "SUCCESS", "error_code": None},
}
def get_order_status(order_id):
return ORDERS.get(order_id, "NOT_FOUND")
def get_grant_record(order_id):
return GRANTS.get(order_id)
PAID 表示已支付,UNPAID 表示未支付,NOT_FOUND 表示没有找到订单。发放记录中的 FAILED、SUCCESS 和 PENDING 分别表示失败、成功和处理中;查询返回 None 表示没有记录。GRANT_TIMEOUT 是本例自定义的发放业务错误码,不表示当前查询超时,也不足以单独证明底层根因。
本节为了突出控制方式,省略了前面示例中的用户身份、租户隔离和资源访问授权。实际系统仍需在工具执行路径上保留这些检查,更换架构不会改变权限要求。
8.2 Workflow
python
def workflow(order_id):
print("[Workflow] 查询订单")
payment = get_order_status(order_id)
if payment == "NOT_FOUND":
return "订单不存在"
if payment == "UNPAID":
return "订单尚未支付"
if payment != "PAID":
return "支付状态未知,需要进一步核对"
print("[Workflow] 查询发放记录")
grant = get_grant_record(order_id)
if grant is None:
return "没有找到金币发放记录"
if grant.get("status") == "FAILED":
error_code = grant.get("error_code")
return f"发放失败:{error_code}" if error_code else "发放失败,记录未提供错误码"
if grant.get("status") == "SUCCESS":
return "发放记录显示成功"
if grant.get("status") == "PENDING":
return "金币发放处理中"
return "发放状态未知,需要进一步核对"
8.3 ReAct 风格 Mock
python
def mock_react_decide(observations):
if "payment" not in observations:
return "get_order_status"
if observations["payment"] != "PAID":
return "finish"
if "grant" not in observations:
return "get_grant_record"
return "finish"
def react(order_id):
print("[ReAct] 开始")
observations = {}
for step in range(1, 6):
action = mock_react_decide(observations)
print(f"[ReAct] 第 {step} 轮:{action}")
if action == "finish":
return summarize(observations)
if action == "get_order_status":
observations["payment"] = get_order_status(order_id)
elif action == "get_grant_record":
if observations.get("payment") != "PAID":
return "不满足发放记录查询条件"
observations["grant"] = get_grant_record(order_id)
else:
return "未知操作"
return "达到最大执行轮数"
真实 ReAct 可让模型承担 mock_react_decide 的决策职责,Runtime 仍需校验并执行。
8.4 Planner-Executor Mock
python
def mock_planner():
return ["get_order_status", "get_grant_record", "summarize"]
def planner_executor(order_id):
print("[Planner-Executor] 开始")
plan = mock_planner()
observations = {}
for action in plan:
print("[Executor] 检查步骤:", action)
if action == "get_order_status":
observations["payment"] = get_order_status(order_id)
elif action == "get_grant_record":
if observations.get("payment") == "PAID":
observations["grant"] = get_grant_record(order_id)
else:
print("[Executor] 跳过发放记录查询:尚未确认支付成功")
elif action == "summarize":
return summarize(observations)
else:
return "计划包含未知操作"
return "计划没有生成最终结果"
本例只有一次模拟规划与顺序执行,没有动态重规划。执行器会检查每个步骤的条件;支付未确认时跳过发放记录查询,所以"检查步骤"不代表已经调用该工具。计划由本地固定函数产生,本例尚未实现面向任意模型计划的结构校验与依赖调度。
8.5 共用结果整理函数与入口
python
def summarize(observations):
if "payment" not in observations:
return "尚未查询支付状态,无法判断"
payment = observations["payment"]
if payment == "NOT_FOUND":
return "订单不存在"
if payment == "UNPAID":
return "订单尚未支付"
if payment != "PAID":
return "支付状态未知,需要进一步核对"
if "grant" not in observations:
return "尚未查询金币发放记录,无法判断"
grant = observations["grant"]
if grant is None:
return "没有找到金币发放记录"
if grant.get("status") == "FAILED":
error_code = grant.get("error_code")
return f"发放失败:{error_code}" if error_code else "发放失败,记录未提供错误码"
if grant.get("status") == "SUCCESS":
return "发放记录显示成功"
if grant.get("status") == "PENDING":
return "金币发放处理中"
return "发放状态未知,需要进一步核对"
if __name__ == "__main__":
order_id = "1001"
print("Workflow 结果:", workflow(order_id))
print()
print("ReAct 结果:", react(order_id))
print()
print("Planner-Executor 结果:", planner_executor(order_id))
运行需要 Python 3.10 或以上,只使用标准库。保存完整代码后,在脚本所在目录打开终端:
bash
python3 agent_architectures.py
Windows 用户可以根据安装方式使用 python 或 py 替代 python3。要尝试其他订单,修改入口中的 order_id 即可。
对于示例中的订单 1001,三种模式都会得出 发放失败:GRANT_TIMEOUT,但控制方式不同。这个 Demo 不能用于比较真实模型的工具选择、Token 成本、任务成功率或规划质量。Token 是模型处理文本的计量单位,本例没有模型调用,也就没有实际模型 Token 用量。真实差异在未知分支、失败、依赖和重规划场景下更加明显。
九、真实项目如何组合模式?
9.1 Workflow + ReAct
text
用户反馈金币未到账
↓
Workflow:认证与权限检查
↓
Workflow:核实支付状态
├── 未支付、无权限或查询失败 → 按规则返回或处理错误
└── 确认已支付
↓
ReAct:动态排查发放异常
↓
Workflow:检查结果
↓
如需补发 → 创建申请 → 人工审批 → 业务系统幂等执行
Workflow 控制关键流程,ReAct 负责不确定的调查,审批与可信业务系统控制敏感操作。
9.2 Planner-Executor + Parallelization
Planner 制定分析计划,将独立的支付统计、发放统计和版本统计并行执行,汇总后继续分析。并行可能缩短等待时间,但不一定降低资源消耗。
9.3 Planner-Executor + ReAct
Planner 负责整体拆解,Executor 执行统计;某个日志分析步骤交给 ReAct 动态调查,再将结果返回计划执行流程。
9.4 Routing + 多种执行模式
text
用户问题 → Routing
├── 订单查询 → Workflow
├── 故障排查 → ReAct
└── 复杂分析 → Planner-Executor
不同任务不必采用同一种架构。
十、生产级架构选型需要考虑什么?
任务路径是否明确? 重点是后续规则能否预先写清楚,而不只是查询结果是否未知。"已支付就查发放记录"仍是明确的 Workflow 分支;需要根据未知日志线索决定查哪些系统时,才更值得考虑 ReAct。多阶段任务需要显式计划和依赖管理时,可考虑 Planner-Executor。
业务风险有多高? 查询只读,退款、金币补发和余额修改有副作用。敏感操作必须由可信身份认证、权限检查、业务前置条件、必要审批、幂等和结果核对保护。
延迟与成本要求是什么? Workflow 通常更容易预测调用次数;ReAct 可能增加模型轮数;Planner-Executor 有规划和重规划开销;并行可能降低等待时间但增加瞬时消耗。
是否需要中断恢复? 长任务、人工审批和外部事件等待,需要记录 State(任务状态),保存 Checkpoint(恢复检查点),以及执行进度、计划版本与恢复策略。涉及写操作还要有业务幂等,即同一笔操作重复提交也不重复产生业务效果。
如何验证选型? Eval(评测)用于检查任务结果与执行过程是否满足要求;Trace(执行链路记录)用于关联每次模型调用和工具执行,帮助定位失败发生的位置。可以使用同一组任务比较:
| 指标 | 说明 |
|---|---|
| Task Success Rate | 任务成功率 |
| Tool Selection Accuracy | 工具选择正确率 |
| Constraint Violation Rate | 约束违反率 |
| Average Model Calls | 平均模型调用次数 |
| P95 Latency | 95% 的请求延迟不超过的阈值 |
| Cost per Task | 单任务成本 |
| Recovery Success Rate | 中断后恢复成功率 |
比较时应统一任务样本、工具权限和成功标准,记录模型、提示词与预算配置。工具选择可能存在多条合理路径,不宜只用是否匹配唯一固定顺序来评分。
涉及业务操作时,成功应根据可信系统中的实际结果判断;分析报告则应检查证据、结论与任务要求是否一致,不能只看模型是否给出了回答。
十一、一个实用的架构选型方法
- 先问是否真的需要 Agent。 普通程序足够就优先使用普通程序。
- 判断流程是否固定。 固定流程优先 Workflow。
- 判断是否需要动态探索。 查询结果未知不等于需要模型决策。若后续分支规则明确,Workflow 仍然合适;若难以预先列出合理路径,需要模型根据新线索选择行动,再考虑 ReAct。
- 判断是否需要整体规划。 多阶段复杂任务考虑 Planner-Executor。
- 判断是否需要额外组织机制。 多入口用 Routing,独立任务可并行,动态拆分考虑 Orchestrator-Workers,质量迭代考虑 Evaluator-Optimizer,专业分工考虑 Multi-Agent,敏感操作考虑 Human-in-the-Loop。
- 通过测试验证。 比较成功率、延迟、成本、安全和可维护性,再决定是否增加复杂度。
这不是严格的决策算法,而是一套避免过度设计的思考顺序。
十二、面试中如何回答 Agent 架构选型?
12.1 Agent 常见架构模式有哪些?
Agent 架构没有唯一的统一分类标准。从流程控制看有 Workflow 和 ReAct,从规划看有 Planner-Executor 和 Re-planning。此外还有 Routing、Parallelization、Orchestrator-Workers、Evaluator-Optimizer、Multi-Agent 和 Human-in-the-Loop。它们解决不同问题,可以组合使用。
12.2 Workflow、ReAct 和 Planner-Executor 有什么区别?
Workflow 由程序预先定义主要步骤和条件分支,适合规则明确的任务。ReAct 由模型根据观察结果动态选择行动,适合探索性排查。Planner-Executor 将规划与执行分离,适合多阶段复杂任务。选型时考虑不确定性、风险、延迟、成本和可验证性。
12.3 为什么不全部使用 ReAct?
固定业务流程不需要每一步都由模型决策。Workflow 更易测试和控制;ReAct 的灵活性可能带来工具误选、重复执行和额外成本。应优先使用满足需求的简单架构。
12.4 Planner-Executor 一定需要两个 Agent 吗?
不需要。Planner 和 Executor 是逻辑职责,可以由一个 LLM 和普通执行程序分别承担。多个 Agent 是进一步的协作设计。
12.5 Workflow 能不能调用 LLM?
可以。Workflow 强调主要流程由程序控制,不代表每个步骤都必须是确定性代码。可以由 LLM 提取订单编号,程序按固定规则查询,再由 LLM 解释结果。
12.6 ReAct 和 Agent Loop 有什么区别?
Agent Loop 是模型与工具多轮交互的运行机制;ReAct 是根据观察结果选择行动的方法。ReAct 可以通过 Agent Loop 实现,但两者不是同一个概念。
12.7 什么时候需要重新规划?
关键步骤失败、发现重大新信息、目标变化或原计划不适用时可以重新规划。无需每步都重新规划,生产系统还应记录计划版本、执行结果和调整原因。
12.8 如何设计生产级金币未到账处理 Agent?
我会先分离确定性业务流程和不确定性排查。认证、权限、支付验证、审批和补发由 Workflow 与可信业务服务控制。原因不明时用 ReAct 查询订单、发放记录、日志和知识库;批量异常分析可以使用 Planner-Executor,并在独立步骤中并行执行。Runtime 控制工具权限、预算和终止,State/Checkpoint 管理恢复,Eval 与 Trace 验证质量和定位问题。目标不是最大化自主性,而是业务安全、可控和可验证。
十三、总结:Agent 架构的核心是控制权设计
Workflow、ReAct 和 Planner-Executor 很重要,但不是 Agent 架构的全部。Routing、Parallelization、Orchestrator-Workers、Evaluator-Optimizer、Multi-Agent 和 Human-in-the-Loop 解决的是其他维度的工程问题。
这些模式不是从简单到高级的技术等级,也不是必须三选一的分类。它们可以组合,但不意味着每个系统都需要复杂的组合。
- 简单任务,普通程序可能最好。
- 固定流程,Workflow 通常合适。
- 需要根据新线索动态探索的问题,可以考虑 ReAct。
- 复杂长任务,可以考虑 Planner-Executor。
- 分发、并行、协作、评估与审批,按需要加入相应模式。
Agent 架构选型的关键,不是让模型拥有尽可能多的决策权,而是根据任务的不确定性、业务风险和工程成本,把决策权放在最合适的位置。
参考资料
- Anthropic --- Building Effective Agents
- ReAct --- Synergizing Reasoning and Acting in Language Models
- LangGraph --- Overview
- OpenAI --- Agents SDK
- OpenAI --- Function Calling
附录:完整代码
以下单文件程序与配套脚本一致。保存为 agent_architectures.py 后即可运行,无需 API Key 或额外依赖。
python
ORDERS = {"1001": "PAID", "1002": "UNPAID", "1003": "PAID"}
GRANTS = {
"1001": {"status": "FAILED", "error_code": "GRANT_TIMEOUT"},
"1003": {"status": "SUCCESS", "error_code": None},
}
def get_order_status(order_id):
return ORDERS.get(order_id, "NOT_FOUND")
def get_grant_record(order_id):
return GRANTS.get(order_id)
def workflow(order_id):
print("[Workflow] 查询订单")
payment = get_order_status(order_id)
if payment == "NOT_FOUND":
return "订单不存在"
if payment == "UNPAID":
return "订单尚未支付"
if payment != "PAID":
return "支付状态未知,需要进一步核对"
print("[Workflow] 查询发放记录")
grant = get_grant_record(order_id)
if grant is None:
return "没有找到金币发放记录"
if grant.get("status") == "FAILED":
error_code = grant.get("error_code")
return f"发放失败:{error_code}" if error_code else "发放失败,记录未提供错误码"
if grant.get("status") == "SUCCESS":
return "发放记录显示成功"
if grant.get("status") == "PENDING":
return "金币发放处理中"
return "发放状态未知,需要进一步核对"
def mock_react_decide(observations):
if "payment" not in observations:
return "get_order_status"
if observations["payment"] != "PAID":
return "finish"
if "grant" not in observations:
return "get_grant_record"
return "finish"
def react(order_id):
print("[ReAct] 开始")
observations = {}
for step in range(1, 6):
action = mock_react_decide(observations)
print(f"[ReAct] 第 {step} 轮:{action}")
if action == "finish":
return summarize(observations)
if action == "get_order_status":
observations["payment"] = get_order_status(order_id)
elif action == "get_grant_record":
if observations.get("payment") != "PAID":
return "不满足发放记录查询条件"
observations["grant"] = get_grant_record(order_id)
else:
return "未知操作"
return "达到最大执行轮数"
def mock_planner():
return ["get_order_status", "get_grant_record", "summarize"]
def planner_executor(order_id):
print("[Planner-Executor] 开始")
plan = mock_planner()
observations = {}
for action in plan:
print("[Executor] 检查步骤:", action)
if action == "get_order_status":
observations["payment"] = get_order_status(order_id)
elif action == "get_grant_record":
if observations.get("payment") == "PAID":
observations["grant"] = get_grant_record(order_id)
else:
print("[Executor] 跳过发放记录查询:尚未确认支付成功")
elif action == "summarize":
return summarize(observations)
else:
return "计划包含未知操作"
return "计划没有生成最终结果"
def summarize(observations):
if "payment" not in observations:
return "尚未查询支付状态,无法判断"
payment = observations["payment"]
if payment == "NOT_FOUND":
return "订单不存在"
if payment == "UNPAID":
return "订单尚未支付"
if payment != "PAID":
return "支付状态未知,需要进一步核对"
if "grant" not in observations:
return "尚未查询金币发放记录,无法判断"
grant = observations["grant"]
if grant is None:
return "没有找到金币发放记录"
if grant.get("status") == "FAILED":
error_code = grant.get("error_code")
return f"发放失败:{error_code}" if error_code else "发放失败,记录未提供错误码"
if grant.get("status") == "SUCCESS":
return "发放记录显示成功"
if grant.get("status") == "PENDING":
return "金币发放处理中"
return "发放状态未知,需要进一步核对"
if __name__ == "__main__":
order_id = "1001"
print("Workflow 结果:", workflow(order_id))
print()
print("ReAct 结果:", react(order_id))
print()
print("Planner-Executor 结果:", planner_executor(order_id))
运行后,可以将订单改为 1002,对比三种实现如何跳过发放记录查询;再将一条发放记录的状态改为 PENDING,检查它是否被正确识别为处理中。注意观察决策发生在哪里,以及结果怎样传递到下一步。
下一篇
Agent开发 04|协作与审批:怎样分工、何时让人确认?
下一篇将深入 Multi-Agent 的分工、协调、交接与成本,以及 Human-in-the-Loop 如何让退款、金币补发等敏感操作真正进入可信审批流程。