AI Agent 架构原理深度解析：从 ReAct 到 Plan-Execute 再到 Reflection

一、引言：为什么 AI Agent 是大模型时代的关键范式

2024 至 2025 年，大语言模型（Large Language Model，LLM）的能力持续跃迁：从 GPT-4 到 Claude 3.5 Sonnet，从 DeepSeek 到 Qwen、GLM 等开源模型，语言理解与生成能力已接近甚至超越人类平均水平。然而，单纯的“对话能力”正在触及天花板——模型再强，如果只能被动回答问题，就无法真正替代人类完成复杂任务。

AI Agent（智能体）正是在这一背景下成为大模型应用领域最火热的方向。据 LangChain 2024 年发布的《State of AI Agents》报告，超过 51% 的受访企业已在生产环境中使用 Agent，78% 的团队计划在近期部署 Agent 相关能力。从 OpenAI 的 Operator、Anthropic 的 Computer Use，到国内的扣子（Coze）、Dify、FastGPT，Agent 已从学术概念走向工程落地。

但必须承认，很多人对 Agent 的理解还停留在“给大模型加个工具调用”的层面。真正的 Agent 是一个自主感知-决策-行动的循环系统，涉及推理架构、记忆系统、工具使用、多步规划、自我反思、多智能体协作等多个维度的设计。架构设计才是决定 Agent 能力上限的核心要素。

本文将从原理到实现，系统拆解三大经典 Agent 架构范式——ReAct、Plan-Execute、Reflection，并在此基础上深入探讨混合架构、记忆系统、多 Agent 协作、主流框架选型以及当前挑战与未来趋势。无论你是正在搭建第一个 Agent 的工程师，还是希望深入理解 Agent 底层原理的研究者，本文都将为你提供一份完整的知识地图。

二、AI Agent 核心概念与总体架构

2.1 什么是 AI Agent

在人工智能领域，“Agent（智能体）”有着悠久的学术渊源。早在 1995 年，Michael Wooldridge 和 Nicholas Jennings 就在论文《Intelligent Agents: Theory and Practice》中给出了经典定义：

智能体是处于某个环境中的计算机系统，该系统有能力在这个环境中自主行动以实现其设计目标。

Russel 与 Norvig 在《人工智能：一种现代方法》中进一步将智能体描述为“通过传感器感知环境，并通过执行器对环境施加影响的任何事物”。这一“感知-决策-行动”的闭环，构成了所有智能体系统的底层骨架。

当 LLM 出现后，Agent 的定义被赋予了新的内涵。在大模型时代，AI Agent 通常被定义为：

以大语言模型为核心决策引擎，能够自主感知环境、进行推理规划、调用外部工具、维护记忆状态，并朝着明确目标持续行动的智能系统。

这里的关键词是“自主性”（Autonomy）。一个真正的 Agent 不是简单的“LLM + 工具调用”，而是具备以下核心特征的系统：

• 自主循环决策：能够在没有人类逐步干预的情况下，自行决定下一步做什么。
• 主动选择工具：知道什么时候该调用工具、调用哪个工具、如何解读工具返回结果。
• 有明确目标：围绕一个或多个目标展开行动，而非被动应答；
• 具备记忆系统：能记住对话历史、任务上下文，甚至跨会话的长期经验；
• 可反思纠错：能评估自己的输出质量，发现错误并自我改进；
• 多步规划与执行：能将复杂任务拆解为多个子步骤，逐步执行并整合结果。

2.2 Agent 与普通 LLM 的本质区别

为了更直观地理解 Agent 的特殊之处，我们将普通 LLM 对话、Function Calling 应用与完整 Agent 进行对比：

可以看出，从普通 LLM 到完整 Agent，本质上是一个“自主性”不断递增的过程。Function Calling 只是 Agent 工具箱中的一个重要能力，远不是 Agent 的全部。

2.3 Agent 系统的五层核心组件

一个设计良好的 Agent 系统通常由五个核心组件构成，它们协同工作形成完整的感知-决策-行动闭环：

#mermaid-svg-LxwtVerTXjatdKzm{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-LxwtVerTXjatdKzm .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-LxwtVerTXjatdKzm .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-LxwtVerTXjatdKzm .error-icon{fill:#552222;}#mermaid-svg-LxwtVerTXjatdKzm .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-LxwtVerTXjatdKzm .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-LxwtVerTXjatdKzm .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-LxwtVerTXjatdKzm .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-LxwtVerTXjatdKzm .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-LxwtVerTXjatdKzm .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-LxwtVerTXjatdKzm .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-LxwtVerTXjatdKzm .marker{fill:#333333;stroke:#333333;}#mermaid-svg-LxwtVerTXjatdKzm .marker.cross{stroke:#333333;}#mermaid-svg-LxwtVerTXjatdKzm svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-LxwtVerTXjatdKzm p{margin:0;}#mermaid-svg-LxwtVerTXjatdKzm .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-LxwtVerTXjatdKzm .cluster-label text{fill:#333;}#mermaid-svg-LxwtVerTXjatdKzm .cluster-label span{color:#333;}#mermaid-svg-LxwtVerTXjatdKzm .cluster-label span p{background-color:transparent;}#mermaid-svg-LxwtVerTXjatdKzm .label text,#mermaid-svg-LxwtVerTXjatdKzm span{fill:#333;color:#333;}#mermaid-svg-LxwtVerTXjatdKzm .node rect,#mermaid-svg-LxwtVerTXjatdKzm .node circle,#mermaid-svg-LxwtVerTXjatdKzm .node ellipse,#mermaid-svg-LxwtVerTXjatdKzm .node polygon,#mermaid-svg-LxwtVerTXjatdKzm .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-LxwtVerTXjatdKzm .rough-node .label text,#mermaid-svg-LxwtVerTXjatdKzm .node .label text,#mermaid-svg-LxwtVerTXjatdKzm .image-shape .label,#mermaid-svg-LxwtVerTXjatdKzm .icon-shape .label{text-anchor:middle;}#mermaid-svg-LxwtVerTXjatdKzm .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-LxwtVerTXjatdKzm .rough-node .label,#mermaid-svg-LxwtVerTXjatdKzm .node .label,#mermaid-svg-LxwtVerTXjatdKzm .image-shape .label,#mermaid-svg-LxwtVerTXjatdKzm .icon-shape .label{text-align:center;}#mermaid-svg-LxwtVerTXjatdKzm .node.clickable{cursor:pointer;}#mermaid-svg-LxwtVerTXjatdKzm .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-LxwtVerTXjatdKzm .arrowheadPath{fill:#333333;}#mermaid-svg-LxwtVerTXjatdKzm .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-LxwtVerTXjatdKzm .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-LxwtVerTXjatdKzm .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-LxwtVerTXjatdKzm .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-LxwtVerTXjatdKzm .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-LxwtVerTXjatdKzm .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-LxwtVerTXjatdKzm .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-LxwtVerTXjatdKzm .cluster text{fill:#333;}#mermaid-svg-LxwtVerTXjatdKzm .cluster span{color:#333;}#mermaid-svg-LxwtVerTXjatdKzm div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-LxwtVerTXjatdKzm .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-LxwtVerTXjatdKzm rect.text{fill:none;stroke-width:0;}#mermaid-svg-LxwtVerTXjatdKzm .icon-shape,#mermaid-svg-LxwtVerTXjatdKzm .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-LxwtVerTXjatdKzm .icon-shape p,#mermaid-svg-LxwtVerTXjatdKzm .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-LxwtVerTXjatdKzm .icon-shape .label rect,#mermaid-svg-LxwtVerTXjatdKzm .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-LxwtVerTXjatdKzm .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-LxwtVerTXjatdKzm .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-LxwtVerTXjatdKzm :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

用户输入

感知模块输入解析与表示

决策大脑LLM 推理与规划

行动执行器工具调用与执行

外部环境API / 数据库 / 文件系统

观察结果

记忆系统短期 + 长期

反思模块评估与改进

2.4 Agent 的自主层级

并非所有"智能体"都具有相同的自主程度。根据自主性的高低，可以将 Agent 划分为四个层级：

理解这一层级划分有助于我们在实际项目中选择合适的 Agent 形态——不是所有场景都需要全自主 Agent，很多时候半自主的人类监督模式（Human-in-the-Loop）才是工程上的更优解。

三、ReAct 架构：推理与行动的交织

3.1 提出背景与核心思想

ReAct 是 “Reasoning + Acting” 的缩写，由普林斯顿大学和 Google Research 的 Yao 等人于 2022 年在论文《ReAct: Synergizing Reasoning and Acting in Language Models》中提出。这篇论文的核心发现是：将推理（Reasoning）和行动（Acting）结合起来，能够让语言模型在知识密集型任务和决策型任务上同时取得显著提升。

在 ReAct 出现之前，主流方案大致分为两派：

• 纯推理派（Chain-of-Thought，CoT）：让模型"慢慢想"，通过逐步推理提高答案质量。但 CoT 的问题在于模型无法获取外部信息，推理过程可能基于错误或过时的知识。
• 纯行动派（Act-only）：让模型直接调用工具获取信息。但单纯行动缺乏显式的推理过程，模型往往不知道该调用什么工具、如何解读工具返回的结果。

ReAct 的精妙之处在于将两者融合：让 LLM 在推理和行动之间交替进行，形成 Thought → Action → Observation 的循环。推理帮助模型"想清楚"，行动帮助模型"拿到真实信息"，观察结果再反过来修正推理，形成一个自纠错的闭环。

3.2 ReAct 的循环机制

ReAct 的核心循环可以用以下流程图表示：

#mermaid-svg-K3qiH52n8glbtu61{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-K3qiH52n8glbtu61 .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-K3qiH52n8glbtu61 .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-K3qiH52n8glbtu61 .error-icon{fill:#552222;}#mermaid-svg-K3qiH52n8glbtu61 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-K3qiH52n8glbtu61 .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-K3qiH52n8glbtu61 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-K3qiH52n8glbtu61 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-K3qiH52n8glbtu61 .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-K3qiH52n8glbtu61 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-K3qiH52n8glbtu61 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-K3qiH52n8glbtu61 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-K3qiH52n8glbtu61 .marker.cross{stroke:#333333;}#mermaid-svg-K3qiH52n8glbtu61 svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-K3qiH52n8glbtu61 p{margin:0;}#mermaid-svg-K3qiH52n8glbtu61 .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-K3qiH52n8glbtu61 .cluster-label text{fill:#333;}#mermaid-svg-K3qiH52n8glbtu61 .cluster-label span{color:#333;}#mermaid-svg-K3qiH52n8glbtu61 .cluster-label span p{background-color:transparent;}#mermaid-svg-K3qiH52n8glbtu61 .label text,#mermaid-svg-K3qiH52n8glbtu61 span{fill:#333;color:#333;}#mermaid-svg-K3qiH52n8glbtu61 .node rect,#mermaid-svg-K3qiH52n8glbtu61 .node circle,#mermaid-svg-K3qiH52n8glbtu61 .node ellipse,#mermaid-svg-K3qiH52n8glbtu61 .node polygon,#mermaid-svg-K3qiH52n8glbtu61 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-K3qiH52n8glbtu61 .rough-node .label text,#mermaid-svg-K3qiH52n8glbtu61 .node .label text,#mermaid-svg-K3qiH52n8glbtu61 .image-shape .label,#mermaid-svg-K3qiH52n8glbtu61 .icon-shape .label{text-anchor:middle;}#mermaid-svg-K3qiH52n8glbtu61 .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-K3qiH52n8glbtu61 .rough-node .label,#mermaid-svg-K3qiH52n8glbtu61 .node .label,#mermaid-svg-K3qiH52n8glbtu61 .image-shape .label,#mermaid-svg-K3qiH52n8glbtu61 .icon-shape .label{text-align:center;}#mermaid-svg-K3qiH52n8glbtu61 .node.clickable{cursor:pointer;}#mermaid-svg-K3qiH52n8glbtu61 .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-K3qiH52n8glbtu61 .arrowheadPath{fill:#333333;}#mermaid-svg-K3qiH52n8glbtu61 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-K3qiH52n8glbtu61 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-K3qiH52n8glbtu61 .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-K3qiH52n8glbtu61 .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-K3qiH52n8glbtu61 .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-K3qiH52n8glbtu61 .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-K3qiH52n8glbtu61 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-K3qiH52n8glbtu61 .cluster text{fill:#333;}#mermaid-svg-K3qiH52n8glbtu61 .cluster span{color:#333;}#mermaid-svg-K3qiH52n8glbtu61 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-K3qiH52n8glbtu61 .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-K3qiH52n8glbtu61 rect.text{fill:none;stroke-width:0;}#mermaid-svg-K3qiH52n8glbtu61 .icon-shape,#mermaid-svg-K3qiH52n8glbtu61 .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-K3qiH52n8glbtu61 .icon-shape p,#mermaid-svg-K3qiH52n8glbtu61 .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-K3qiH52n8glbtu61 .icon-shape .label rect,#mermaid-svg-K3qiH52n8glbtu61 .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-K3qiH52n8glbtu61 .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-K3qiH52n8glbtu61 .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-K3qiH52n8glbtu61 :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

否，继续推理

否

是

是

用户提问

Thought：分析问题，生成推理

Action：选择工具并生成调用参数

Observation：观察工具返回结果

信息是否足够回答用户问题？

Thought：结合观察结果继续推理

Action：再次调用工具

Observation：观察新的结果

信息是否足够？

Final Answer：输出最终答案

这个循环的本质是：每一步决策都基于前面所有步骤累积的上下文。模型可以看到完整的思考轨迹和观察历史，从而做出越来越准确的判断。

3.3 完整工作流程拆解

在实际实现中，每轮 ReAct 循环包含四个关键步骤：

第一步：LLM 生成 Thought 和 Action。 系统向 LLM 提供包含工具说明、历史对话和观察结果的提示词（Prompt），要求模型输出结构化内容，通常包含 Thought（思考）和 Action（行动）两个字段，有时还包括 Action Input（行动参数）。

第二步：解析响应。 解析模型输出的结构化文本，提取出要调用的工具名称和参数。这一步需要对模型输出格式做严格约束（如要求输出 JSON），并根据语法规则或正则表达式进行解析。

第三步：执行 Action 调用工具。 根据解析结果，调用对应的工具（如搜索 API、数据库查询、代码执行器等），获取实际执行结果。

第四步：将观察结果加入上下文。 把工具返回结果作为新的 Observation 追加到对话历史中，进入下一轮循环。

当模型认为信息已经足够时，会输出 Final Answer，循环终止。为了防止死循环，通常还会设置最大循环步数（如 10 步）作为兜底。

3.4 ReAct 的优缺点分析

ReAct 架构的优势十分明显：

但 ReAct 也存在不可忽视的不足：

3.5 ReAct 的 Python 实现示例

以下是一个最小化的 ReAct Agent 实现，展示了核心循环逻辑：

import json
import re

class ReActAgent:
"""最小化 ReAct Agent 实现"""

def __init__(self, llm, tools, max_steps=10):
"""
llm: 大模型调用接口，需支持 generate(prompt) -> str
tools: 工具字典 {工具名: 可调用对象}
max_steps: 最大循环步数，防止死循环
"""
self.llm = llm
self.tools = tools
self.max_steps = max_steps
self.history = []

def run(self, question: str) –> str:
self.history.append(f"Question: {question}")

for step in range(self.max_steps):
prompt = self._build_prompt()
response = self.llm.generate(prompt)

# 解析模型输出
thought = self._extract_field(response, "Thought")
action = self._extract_field(response, "Action")
action_input = self._extract_field(response, "Action Input")

self.history.append(f"Thought: {thought}")

# 判断是否结束
if action.strip().lower() == "finish":
return action_input

# 执行工具调用
if action not in self.tools:
observation = f"Error: Unknown tool '{action}'"
else:
try:
result = self.tools[action](action_input)
observation = str(result)
except Exception as e:
observation = f"Error: {e}"

self.history.append(f"Action: {action}")
self.history.append(f"Observation: {observation}")

return "已达到最大步数限制，任务未能完成。"

def _build_prompt(self) –> str:
tool_desc = "\\n".join(
f"- {name}: {func.__doc__ or 'No description'}"
for name, func in self.tools.items()
)
prompt = f"""你是一个自主智能体，请通过 Thought-Action-Observation 循环回答问题。

可用工具：
{tool_desc}

对话历史：
{chr(10).join(self.history)}

请按以下格式输出：
Thought: 你的推理过程
Action: 工具名，或 Finish
Action Input: 工具参数，或最终答案
"""
return prompt

@staticmethod
def _extract_field(text: str, field: str) –> str:
match = re.search(rf"{field}:\\s*(.+)", text)
return match.group(1).strip() if match else ""

# 使用示例
def search(query: str) –> str:
"""搜索外部知识库"""
# 实际场景中调用搜索引擎 API
return f"搜索结果：关于 '{query}' 的 3 条相关信息…"

if __name__ == "__main__":
# 此处 llm 为伪代码，实际需接入真实模型
agent = ReActAgent(llm=MockLLM(), tools={"search": search})
answer = agent.run("2025 年 AI Agent 领域最重要的技术进展是什么？")
print(answer)

3.6 适用场景与改进方向

ReAct 最适合以下场景：

• 开放域问答：需要多轮搜索才能拼凑出完整答案的问题；
• 数据查询分析：需要逐步查询数据库、逐步缩小范围的分析任务；
• 探索性研究：目标不够明确、需要边走边看的任务。

针对 ReAct 的缺点，业界发展出多种改进方案：

• ReAct + 结构化输出：使用 JSON Schema 约束模型输出，避免解析失败；
• ReAct + 工具选择优化：预先筛选相关工具子集，减少提示词长度和误调用概率；
• ReAct + 缓存：对相同 Thought-Action 对的结果做缓存，减少重复调用；
• ReAct + 并行执行：当多个 Action 之间无依赖时并行调用，降低串行延迟。

四、Plan-Execute 架构：先规划后执行

4.1 核心思想与动机

Plan-Execute 架构（又称 Plan-and-Execute）的提出，正是为了解决 ReAct"走一步看一步"导致的方向偏差问题。其核心思想可以概括为一句经典原则：

先想清楚，再动手。

在 ReAct 中，模型每走一步才决定下一步，缺乏对全局的把控。当任务涉及多个子步骤、步骤之间存在依赖关系时，ReAct 很容易"迷路"——在局部最优中徘徊，偏离了全局目标。

Plan-Execute 架构将任务处理明确分为两个阶段：

这种"规划先行"的策略带来两个直接好处：可预测性（整个流程在计划阶段就基本确定）和可并行性（无依赖的步骤可以并行执行，大幅缩短总耗时）。

4.2 组件与工作流程

Plan-Execute 架构的完整流程如下：

#mermaid-svg-6aV0VIRYnQ82oNyn{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-6aV0VIRYnQ82oNyn .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-6aV0VIRYnQ82oNyn .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-6aV0VIRYnQ82oNyn .error-icon{fill:#552222;}#mermaid-svg-6aV0VIRYnQ82oNyn .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-6aV0VIRYnQ82oNyn .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-6aV0VIRYnQ82oNyn .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-6aV0VIRYnQ82oNyn .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-6aV0VIRYnQ82oNyn .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-6aV0VIRYnQ82oNyn .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-6aV0VIRYnQ82oNyn .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-6aV0VIRYnQ82oNyn .marker{fill:#333333;stroke:#333333;}#mermaid-svg-6aV0VIRYnQ82oNyn .marker.cross{stroke:#333333;}#mermaid-svg-6aV0VIRYnQ82oNyn svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-6aV0VIRYnQ82oNyn p{margin:0;}#mermaid-svg-6aV0VIRYnQ82oNyn .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-6aV0VIRYnQ82oNyn .cluster-label text{fill:#333;}#mermaid-svg-6aV0VIRYnQ82oNyn .cluster-label span{color:#333;}#mermaid-svg-6aV0VIRYnQ82oNyn .cluster-label span p{background-color:transparent;}#mermaid-svg-6aV0VIRYnQ82oNyn .label text,#mermaid-svg-6aV0VIRYnQ82oNyn span{fill:#333;color:#333;}#mermaid-svg-6aV0VIRYnQ82oNyn .node rect,#mermaid-svg-6aV0VIRYnQ82oNyn .node circle,#mermaid-svg-6aV0VIRYnQ82oNyn .node ellipse,#mermaid-svg-6aV0VIRYnQ82oNyn .node polygon,#mermaid-svg-6aV0VIRYnQ82oNyn .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-6aV0VIRYnQ82oNyn .rough-node .label text,#mermaid-svg-6aV0VIRYnQ82oNyn .node .label text,#mermaid-svg-6aV0VIRYnQ82oNyn .image-shape .label,#mermaid-svg-6aV0VIRYnQ82oNyn .icon-shape .label{text-anchor:middle;}#mermaid-svg-6aV0VIRYnQ82oNyn .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-6aV0VIRYnQ82oNyn .rough-node .label,#mermaid-svg-6aV0VIRYnQ82oNyn .node .label,#mermaid-svg-6aV0VIRYnQ82oNyn .image-shape .label,#mermaid-svg-6aV0VIRYnQ82oNyn .icon-shape .label{text-align:center;}#mermaid-svg-6aV0VIRYnQ82oNyn .node.clickable{cursor:pointer;}#mermaid-svg-6aV0VIRYnQ82oNyn .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-6aV0VIRYnQ82oNyn .arrowheadPath{fill:#333333;}#mermaid-svg-6aV0VIRYnQ82oNyn .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-6aV0VIRYnQ82oNyn .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-6aV0VIRYnQ82oNyn .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-6aV0VIRYnQ82oNyn .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-6aV0VIRYnQ82oNyn .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-6aV0VIRYnQ82oNyn .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-6aV0VIRYnQ82oNyn .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-6aV0VIRYnQ82oNyn .cluster text{fill:#333;}#mermaid-svg-6aV0VIRYnQ82oNyn .cluster span{color:#333;}#mermaid-svg-6aV0VIRYnQ82oNyn div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-6aV0VIRYnQ82oNyn .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-6aV0VIRYnQ82oNyn rect.text{fill:none;stroke-width:0;}#mermaid-svg-6aV0VIRYnQ82oNyn .icon-shape,#mermaid-svg-6aV0VIRYnQ82oNyn .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-6aV0VIRYnQ82oNyn .icon-shape p,#mermaid-svg-6aV0VIRYnQ82oNyn .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-6aV0VIRYnQ82oNyn .icon-shape .label rect,#mermaid-svg-6aV0VIRYnQ82oNyn .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-6aV0VIRYnQ82oNyn .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-6aV0VIRYnQ82oNyn .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-6aV0VIRYnQ82oNyn :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

是

否

是

是

否

否

用户任务

Planner分析任务，生成步骤列表

Plan：Step1, Step2, …, StepN

Executor取下一步骤执行

存在无依赖的并行步骤？

并行执行多个步骤

串行执行当前步骤

Evaluator评估执行结果

结果是否符合预期？

还有未执行的步骤？

汇总结果，输出最终答案

Replan基于新信息重新规划

其中四个核心组件的职责如下：

• Planner（规划器）：负责将用户任务分解为可执行的步骤序列。规划时需要考虑步骤之间的依赖关系、资源约束和预期产出。
• Executor（执行器）：负责具体执行计划中的每一步。执行器内部可能嵌套使用 ReAct 或其他策略来完成单个步骤。
• Evaluator（评估器）：负责评估每一步执行结果的质量，判断是否满足预期。评估标准可以是规则、启发式，也可以是 LLM 判断。
• Replan（重新规划）：当评估发现执行结果偏差时，基于新获得的信息对剩余步骤进行调整。

4.3 与 ReAct 的深度对比

Plan-Execute 与 ReAct 并非对立，而是解决了不同层面的问题。以下是两者的系统对比：

一个形象的类比：ReAct 像是在迷宫里边走边找路，每一步都重新判断；Plan-Execute 则是先站在高处画出路线图，再按照路线行进，发现走不通时才回到高处重新画图。

4.4 Plan-Execute 的 Python 实现示例

以下是一个简化的 Plan-Execute Agent 实现：

from dataclasses import dataclass, field
from typing import List, Optional

@dataclass
class PlanStep:
"""计划步骤"""
step_id: int
description: str
depends_on: List[int] = field(default_factory=list)
status: str = "pending" # pending / running / completed / failed
result: Optional[str] = None

class PlanExecuteAgent:
"""最小化 Plan-Execute Agent 实现"""

def __init__(self, planner_llm, executor, evaluator_llm, max_replans=3):
self.planner_llm = planner_llm
self.executor = executor
self.evaluator_llm = evaluator_llm
self.max_replans = max_replans

def run(self, task: str) –> str:
# 第一阶段：规划
plan = self._plan(task)
results = []
replan_count = 0

# 第二阶段：执行
while any(step.status == "pending" for step in plan) or \\
any(step.status == "running" for step in plan):

# 找出所有依赖已完成的 pending 步骤
ready_steps = [
s for s in plan
if s.status == "pending"
and all(plan[d].status == "completed" for d in s.depends_on)
]

if not ready_steps:
# 没有可执行步骤但仍有未完成任务，说明存在循环依赖
break

# 并行执行所有就绪步骤
for step in ready_steps:
step.status = "running"
step.result = self.executor.execute(step.description)
step.status = "completed"
results.append(step.result)

# 评估该步骤结果
if not self._evaluate(step, task):
step.status = "failed"
if replan_count >= self.max_replans:
return f"多次重新规划后仍失败，最后结果：{step.result}"
# 触发 Replan
plan = self._replan(task, plan, results)
replan_count += 1
break

return self.executor.summarize(results)

def _plan(self, task: str) –> List[PlanStep]:
"""调用 Planner LLM 生成步骤列表"""
response = self.planner_llm.generate(
f"请将以下任务拆解为可执行步骤，标注依赖关系：\\n{task}\\n"
"输出 JSON 数组：[{step_id, description, depends_on}]"
)
# 实际需解析 JSON，此处简化为伪代码
return self._parse_plan(response)

def _evaluate(self, step: PlanStep, task: str) –> bool:
"""调用 Evaluator LLM 评估步骤结果"""
response = self.evaluator_llm.generate(
f"任务：{task}\\n步骤：{step.description}\\n结果：{step.result}\\n"
"该结果是否满足步骤预期？回答 yes/no"
)
return "yes" in response.lower()

def _replan(self, task, old_plan, results):
"""基于已有结果重新规划剩余步骤"""
response = self.planner_llm.generate(
f"原始任务：{task}\\n已完成结果：{results}\\n"
"请基于新信息重新规划剩余步骤"
)
return self._parse_plan(response)

def _parse_plan(self, response: str) –> List[PlanStep]:
# 实际需解析 JSON，此处为占位
return [PlanStep(step_id=0, description="示例步骤")]

4.5 适用场景与局限

Plan-Execute 架构特别适合以下场景：

• 多步骤工作流：任务天然具有清晰步骤，如数据处理流水线、报告生成流程；
• 可并行任务：多个子步骤之间无依赖关系，可并行执行；
• 需要可预测性的场景：如合规审核、审批流程，需要预先确认执行路径。

其局限性同样需要正视：

• 规划质量依赖模型能力：如果初始规划不准确，后续执行都会偏离；
• 开销较大：规划本身需要额外的一次（或多次）LLM 调用；
• 对动态变化适应性弱：当任务目标或环境在执行中发生重大变化时，仅靠 Replan 可能不够及时。

五、Reflection 架构：自我反思与改进

5.1 核心思想

如果说 ReAct 解决的是"怎么行动"的问题，Plan-Execute 解决的是"怎么规划"的问题，那么 Reflection 架构解决的是"怎么做得更好"的问题。

Reflection（反思）架构的核心思想是引入自我评估机制：Agent 在执行完动作后，不仅观察结果，还主动评估自己的表现，发现不足并生成改进策略。这一思想受到了认知科学中"元认知（Metacognition）"概念的启发——人类不仅思考，还会思考自己的思考过程，并据此调整策略。

Shinn 等人在 2023 年发表的论文《Reflexion: Language Agents with Verbal Reinforcement Learning》中，将这一思想形式化为一个可复用的 Agent 架构。论文实验表明，引入反思机制后，Agent 在代码生成、决策推理等任务上的表现提升了 20% 以上。

5.2 反思循环机制

Reflection 架构的典型循环包含四个角色：

#mermaid-svg-0jLPQsYhveHrVGjC{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-0jLPQsYhveHrVGjC .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-0jLPQsYhveHrVGjC .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-0jLPQsYhveHrVGjC .error-icon{fill:#552222;}#mermaid-svg-0jLPQsYhveHrVGjC .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-0jLPQsYhveHrVGjC .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-0jLPQsYhveHrVGjC .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-0jLPQsYhveHrVGjC .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-0jLPQsYhveHrVGjC .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-0jLPQsYhveHrVGjC .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-0jLPQsYhveHrVGjC .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-0jLPQsYhveHrVGjC .marker{fill:#333333;stroke:#333333;}#mermaid-svg-0jLPQsYhveHrVGjC .marker.cross{stroke:#333333;}#mermaid-svg-0jLPQsYhveHrVGjC svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-0jLPQsYhveHrVGjC p{margin:0;}#mermaid-svg-0jLPQsYhveHrVGjC .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-0jLPQsYhveHrVGjC .cluster-label text{fill:#333;}#mermaid-svg-0jLPQsYhveHrVGjC .cluster-label span{color:#333;}#mermaid-svg-0jLPQsYhveHrVGjC .cluster-label span p{background-color:transparent;}#mermaid-svg-0jLPQsYhveHrVGjC .label text,#mermaid-svg-0jLPQsYhveHrVGjC span{fill:#333;color:#333;}#mermaid-svg-0jLPQsYhveHrVGjC .node rect,#mermaid-svg-0jLPQsYhveHrVGjC .node circle,#mermaid-svg-0jLPQsYhveHrVGjC .node ellipse,#mermaid-svg-0jLPQsYhveHrVGjC .node polygon,#mermaid-svg-0jLPQsYhveHrVGjC .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-0jLPQsYhveHrVGjC .rough-node .label text,#mermaid-svg-0jLPQsYhveHrVGjC .node .label text,#mermaid-svg-0jLPQsYhveHrVGjC .image-shape .label,#mermaid-svg-0jLPQsYhveHrVGjC .icon-shape .label{text-anchor:middle;}#mermaid-svg-0jLPQsYhveHrVGjC .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-0jLPQsYhveHrVGjC .rough-node .label,#mermaid-svg-0jLPQsYhveHrVGjC .node .label,#mermaid-svg-0jLPQsYhveHrVGjC .image-shape .label,#mermaid-svg-0jLPQsYhveHrVGjC .icon-shape .label{text-align:center;}#mermaid-svg-0jLPQsYhveHrVGjC .node.clickable{cursor:pointer;}#mermaid-svg-0jLPQsYhveHrVGjC .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-0jLPQsYhveHrVGjC .arrowheadPath{fill:#333333;}#mermaid-svg-0jLPQsYhveHrVGjC .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-0jLPQsYhveHrVGjC .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-0jLPQsYhveHrVGjC .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-0jLPQsYhveHrVGjC .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-0jLPQsYhveHrVGjC .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-0jLPQsYhveHrVGjC .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-0jLPQsYhveHrVGjC .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-0jLPQsYhveHrVGjC .cluster text{fill:#333;}#mermaid-svg-0jLPQsYhveHrVGjC .cluster span{color:#333;}#mermaid-svg-0jLPQsYhveHrVGjC div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-0jLPQsYhveHrVGjC .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-0jLPQsYhveHrVGjC rect.text{fill:none;stroke-width:0;}#mermaid-svg-0jLPQsYhveHrVGjC .icon-shape,#mermaid-svg-0jLPQsYhveHrVGjC .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-0jLPQsYhveHrVGjC .icon-shape p,#mermaid-svg-0jLPQsYhveHrVGjC .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-0jLPQsYhveHrVGjC .icon-shape .label rect,#mermaid-svg-0jLPQsYhveHrVGjC .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-0jLPQsYhveHrVGjC .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-0jLPQsYhveHrVGjC .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-0jLPQsYhveHrVGjC :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

是

否

用户任务

Actor生成初步回答 / 执行动作

Draft Output

Evaluator评估输出质量

是否通过评估？

输出最终结果

生成 Feedback指出具体问题

Reflector基于反馈生成改进策略

Actor 依据策略修订输出

四个角色的职责划分如下：

• Actor（执行者）：生成初步输出或执行初步行动。它不需要一次做对，只需要给出一个"草案"。
• Evaluator（评估者）：对 Actor 的输出进行质量评估。评估可以是基于规则（如测试用例是否通过）、基于模型（如 LLM 评分），也可以是两者的结合。
• Reflector（反思者）：基于评估反馈，分析失败原因，总结出改进策略。反思结果通常是自然语言描述的经验教训。
• 修订循环：Actor 依据 Reflector 的改进策略修订输出，再次提交评估，直到通过或达到最大反思次数。

5.3 实际应用：代码生成 Agent

代码生成是 Reflection 架构最经典且成功的应用场景，以 Self-Debugging 和 Reflexion 为代表。其工作流程如下：

#mermaid-svg-5EyfPMFT7mzmX6YR{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-5EyfPMFT7mzmX6YR .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-5EyfPMFT7mzmX6YR .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-5EyfPMFT7mzmX6YR .error-icon{fill:#552222;}#mermaid-svg-5EyfPMFT7mzmX6YR .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-5EyfPMFT7mzmX6YR .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-5EyfPMFT7mzmX6YR .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-5EyfPMFT7mzmX6YR .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-5EyfPMFT7mzmX6YR .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-5EyfPMFT7mzmX6YR .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-5EyfPMFT7mzmX6YR .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-5EyfPMFT7mzmX6YR .marker{fill:#333333;stroke:#333333;}#mermaid-svg-5EyfPMFT7mzmX6YR .marker.cross{stroke:#333333;}#mermaid-svg-5EyfPMFT7mzmX6YR svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-5EyfPMFT7mzmX6YR p{margin:0;}#mermaid-svg-5EyfPMFT7mzmX6YR .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-5EyfPMFT7mzmX6YR .cluster-label text{fill:#333;}#mermaid-svg-5EyfPMFT7mzmX6YR .cluster-label span{color:#333;}#mermaid-svg-5EyfPMFT7mzmX6YR .cluster-label span p{background-color:transparent;}#mermaid-svg-5EyfPMFT7mzmX6YR .label text,#mermaid-svg-5EyfPMFT7mzmX6YR span{fill:#333;color:#333;}#mermaid-svg-5EyfPMFT7mzmX6YR .node rect,#mermaid-svg-5EyfPMFT7mzmX6YR .node circle,#mermaid-svg-5EyfPMFT7mzmX6YR .node ellipse,#mermaid-svg-5EyfPMFT7mzmX6YR .node polygon,#mermaid-svg-5EyfPMFT7mzmX6YR .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-5EyfPMFT7mzmX6YR .rough-node .label text,#mermaid-svg-5EyfPMFT7mzmX6YR .node .label text,#mermaid-svg-5EyfPMFT7mzmX6YR .image-shape .label,#mermaid-svg-5EyfPMFT7mzmX6YR .icon-shape .label{text-anchor:middle;}#mermaid-svg-5EyfPMFT7mzmX6YR .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-5EyfPMFT7mzmX6YR .rough-node .label,#mermaid-svg-5EyfPMFT7mzmX6YR .node .label,#mermaid-svg-5EyfPMFT7mzmX6YR .image-shape .label,#mermaid-svg-5EyfPMFT7mzmX6YR .icon-shape .label{text-align:center;}#mermaid-svg-5EyfPMFT7mzmX6YR .node.clickable{cursor:pointer;}#mermaid-svg-5EyfPMFT7mzmX6YR .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-5EyfPMFT7mzmX6YR .arrowheadPath{fill:#333333;}#mermaid-svg-5EyfPMFT7mzmX6YR .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-5EyfPMFT7mzmX6YR .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-5EyfPMFT7mzmX6YR .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-5EyfPMFT7mzmX6YR .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-5EyfPMFT7mzmX6YR .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-5EyfPMFT7mzmX6YR .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-5EyfPMFT7mzmX6YR .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-5EyfPMFT7mzmX6YR .cluster text{fill:#333;}#mermaid-svg-5EyfPMFT7mzmX6YR .cluster span{color:#333;}#mermaid-svg-5EyfPMFT7mzmX6YR div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-5EyfPMFT7mzmX6YR .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-5EyfPMFT7mzmX6YR rect.text{fill:none;stroke-width:0;}#mermaid-svg-5EyfPMFT7mzmX6YR .icon-shape,#mermaid-svg-5EyfPMFT7mzmX6YR .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-5EyfPMFT7mzmX6YR .icon-shape p,#mermaid-svg-5EyfPMFT7mzmX6YR .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-5EyfPMFT7mzmX6YR .icon-shape .label rect,#mermaid-svg-5EyfPMFT7mzmX6YR .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-5EyfPMFT7mzmX6YR .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-5EyfPMFT7mzmX6YR .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-5EyfPMFT7mzmX6YR :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

是

否

生成代码

运行测试用例

测试全部通过？

接受代码，完成

分析失败原因错误日志 + 堆栈跟踪

总结改进策略如：修正边界条件、调整算法

这个流程之所以高效，是因为测试用例提供了客观、可量化的反馈信号。传统的 LLM 代码生成是一次性的，模型“写完就忘”，不知道自己的代码是否正确。而引入反思循环后，模型可以看到：

这种“生成-测试-反思-改进”的循环，模拟了人类程序员的调试过程，在实践中可以显著提升代码正确率。例如，在 HumanEval 基准测试中，Reflexion 方法将 GPT-4 的一次通过率从 80.1% 提升到 91.0%。

5.4 Reflection 的 Python 实现示例

以下是一个通用的 Reflection Agent 实现框架：

from dataclasses import dataclass
from typing import Optional

@dataclass
class EvaluationResult:
"""评估结果"""
passed: bool
score: float
feedback: str

@dataclass
class Reflection:
"""反思结果"""
failure_analysis: str
improvement_strategy: str

class ReflectionAgent:
"""通用 Reflection Agent 实现"""

def __init__(self, actor_llm, evaluator, reflector_llm, max_reflections=3):
self.actor_llm = actor_llm
self.evaluator = evaluator
self.reflector_llm = reflector_llm
self.max_reflections = max_reflections
self.reflections: list[Reflection] = []

def run(self, task: str) –> str:
draft = self.actor_llm.generate(f"请完成以下任务：\\n{task}")

for turn in range(self.max_reflections):
# 评估当前输出
result: EvaluationResult = self.evaluator.evaluate(draft)

if result.passed:
return draft

# 生成反思
reflection = self._reflect(task, draft, result)
self.reflections.append(reflection)

# 基于反思修订输出
draft = self.actor_llm.generate(self._revision_prompt(
task, draft, reflection
))

# 超出最大反思次数，返回最后一版
return draft

def _reflect(self, task, draft, result) –> Reflection:
prompt = f"""任务：{task}

当前输出：
{draft}

评估反馈：
{result.feedback}

请分析失败原因，并给出具体可行的改进策略。
输出格式：
Failure Analysis: 失败原因分析
Improvement Strategy: 改进策略
"""
response = self.reflector_llm.generate(prompt)
# 解析响应，提取两个字段
return Reflection(
failure_analysis=self._extract(response, "Failure Analysis"),
improvement_strategy=self._extract(response, "Improvement Strategy"),
)

def _revision_prompt(self, task, draft, reflection) –> str:
return f"""任务：{task}

上一版输出：
{draft}

失败原因分析：
{reflection.failure_analysis}

改进策略：
{reflection.improvement_strategy}

请依据改进策略重新完成任务。
"""

@staticmethod
def _extract(text: str, field: str) –> str:
for line in text.split("\\n"):
if line.startswith(field):
return line.split(":", 1)[1].strip()
return ""

# 使用示例：代码生成 + 测试评估
class TestEvaluator:
"""基于测试用例的评估器"""

def __init__(self, test_cases):
self.test_cases = test_cases

def evaluate(self, code: str) –> EvaluationResult:
passed_count = 0
feedback_lines = []

for i, tc in enumerate(self.test_cases):
try:
result = self._run_test(code, tc)
if result == tc["expected"]:
passed_count += 1
else:
feedback_lines.append(
f"Test {i}: expected {tc['expected']}, got {result}"
)
except Exception as e:
feedback_lines.append(f"Test {i}: raised {type(e).__name__}: {e}")

passed = passed_count == len(self.test_cases)
score = passed_count / len(self.test_cases)
feedback = "\\n".join(feedback_lines) or "All tests passed"
return EvaluationResult(passed=passed, score=score, feedback=feedback)

def _run_test(self, code, tc):
# 沙箱环境中执行代码，此处为占位
pass

5.5 Reflection 的局限与改进方向

Reflection 架构的主要局限在于：

• 多轮迭代耗时：每轮反思都需要额外的 LLM 调用，总耗时随反思次数线性增长。
• 评估质量是关键瓶颈：如果 Evaluator 本身不准确，反思方向可能出错。
• 可能过度修正：在多轮修订中，模型可能为了“通过评估”而偏离原始任务目标。
• 反思结果难积累：单次任务中的反思经验如果不存入长期记忆，下次遇到类似任务时仍需从头开始。

改进方向包括：

• 反思记忆化：将成功的反思策略存入长期记忆，供后续类似任务复用。
• 结构化反思：用模板约束反思输出格式，确保反馈具体、可操作。
• 评估多维度化：从正确性、完整性、效率、风格等多个维度综合评估，避免单一指标偏差。

六、混合架构：Plan-Execute-Reflect

6.1 为什么需要混合架构

实际生产环境中，单一的架构范式往往无法应对真实任务的复杂性。ReAct 灵活但缺乏方向，Plan-Execute 有方向但执行粒度较粗，Reflection 能改进质量但本身不解决“怎么执行”的问题。

因此，成熟的 AI Agent 系统通常采用混合架构（Hybrid Architecture），将三种范式的优势结合在一起：

• 用 Plan 做全局规划：先制定整体计划，确定执行路线。
• 用 ReAct 做局部执行：每个计划步骤内部以 ReAct 循环方式灵活执行。
• 用 Reflection 做质量保障：执行完成后反思整体表现，发现问题则重新规划。

6.2 典型混合架构流程

以下是一个生产级的混合架构 Agent 工作流程：

#mermaid-svg-YA8JCkcvQp7eKIKY{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-YA8JCkcvQp7eKIKY .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-YA8JCkcvQp7eKIKY .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-YA8JCkcvQp7eKIKY .error-icon{fill:#552222;}#mermaid-svg-YA8JCkcvQp7eKIKY .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-YA8JCkcvQp7eKIKY .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-YA8JCkcvQp7eKIKY .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-YA8JCkcvQp7eKIKY .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-YA8JCkcvQp7eKIKY .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-YA8JCkcvQp7eKIKY .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-YA8JCkcvQp7eKIKY .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-YA8JCkcvQp7eKIKY .marker{fill:#333333;stroke:#333333;}#mermaid-svg-YA8JCkcvQp7eKIKY .marker.cross{stroke:#333333;}#mermaid-svg-YA8JCkcvQp7eKIKY svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-YA8JCkcvQp7eKIKY p{margin:0;}#mermaid-svg-YA8JCkcvQp7eKIKY .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-YA8JCkcvQp7eKIKY .cluster-label text{fill:#333;}#mermaid-svg-YA8JCkcvQp7eKIKY .cluster-label span{color:#333;}#mermaid-svg-YA8JCkcvQp7eKIKY .cluster-label span p{background-color:transparent;}#mermaid-svg-YA8JCkcvQp7eKIKY .label text,#mermaid-svg-YA8JCkcvQp7eKIKY span{fill:#333;color:#333;}#mermaid-svg-YA8JCkcvQp7eKIKY .node rect,#mermaid-svg-YA8JCkcvQp7eKIKY .node circle,#mermaid-svg-YA8JCkcvQp7eKIKY .node ellipse,#mermaid-svg-YA8JCkcvQp7eKIKY .node polygon,#mermaid-svg-YA8JCkcvQp7eKIKY .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-YA8JCkcvQp7eKIKY .rough-node .label text,#mermaid-svg-YA8JCkcvQp7eKIKY .node .label text,#mermaid-svg-YA8JCkcvQp7eKIKY .image-shape .label,#mermaid-svg-YA8JCkcvQp7eKIKY .icon-shape .label{text-anchor:middle;}#mermaid-svg-YA8JCkcvQp7eKIKY .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-YA8JCkcvQp7eKIKY .rough-node .label,#mermaid-svg-YA8JCkcvQp7eKIKY .node .label,#mermaid-svg-YA8JCkcvQp7eKIKY .image-shape .label,#mermaid-svg-YA8JCkcvQp7eKIKY .icon-shape .label{text-align:center;}#mermaid-svg-YA8JCkcvQp7eKIKY .node.clickable{cursor:pointer;}#mermaid-svg-YA8JCkcvQp7eKIKY .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-YA8JCkcvQp7eKIKY .arrowheadPath{fill:#333333;}#mermaid-svg-YA8JCkcvQp7eKIKY .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-YA8JCkcvQp7eKIKY .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-YA8JCkcvQp7eKIKY .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-YA8JCkcvQp7eKIKY .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-YA8JCkcvQp7eKIKY .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-YA8JCkcvQp7eKIKY .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-YA8JCkcvQp7eKIKY .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-YA8JCkcvQp7eKIKY .cluster text{fill:#333;}#mermaid-svg-YA8JCkcvQp7eKIKY .cluster span{color:#333;}#mermaid-svg-YA8JCkcvQp7eKIKY div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-YA8JCkcvQp7eKIKY .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-YA8JCkcvQp7eKIKY rect.text{fill:none;stroke-width:0;}#mermaid-svg-YA8JCkcvQp7eKIKY .icon-shape,#mermaid-svg-YA8JCkcvQp7eKIKY .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-YA8JCkcvQp7eKIKY .icon-shape p,#mermaid-svg-YA8JCkcvQp7eKIKY .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-YA8JCkcvQp7eKIKY .icon-shape .label rect,#mermaid-svg-YA8JCkcvQp7eKIKY .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-YA8JCkcvQp7eKIKY .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-YA8JCkcvQp7eKIKY .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-YA8JCkcvQp7eKIKY :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

否

是

否

是

用户任务

Planner 生成整体计划

遍历计划步骤

以 ReAct 方式执行当前步骤

Thought → Action → Observation 循环

当前步骤完成

评估步骤结果

步骤合格？

重试 / 局部调整

所有步骤完成

整体反思评估

整体结果通过？

Replan：调整剩余计划或重做

输出最终结果

在这个流程中，三个架构范式各司其职：Plan 负责“方向”，ReAct 负责“执行”，Reflection 负责“质量”。同时，记忆系统贯穿始终，短期记忆维护当前任务的上下文，长期记忆沉淀每次任务的经验教训。

6.3 生产级实践要点

在设计混合架构 AI Agent 时，以下几个工程实践至关重要：

七、Agent 记忆系统

7.1 记忆的认知分层

记忆是 Agent 区别于“一次性问答机器人”的关键能力。借鉴认知心理学对人类记忆的划分，Agent 的记忆系统通常分为三个层次：

#mermaid-svg-PMtAbLBItJAP3Ql5{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-PMtAbLBItJAP3Ql5 .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-PMtAbLBItJAP3Ql5 .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-PMtAbLBItJAP3Ql5 .error-icon{fill:#552222;}#mermaid-svg-PMtAbLBItJAP3Ql5 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-PMtAbLBItJAP3Ql5 .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-PMtAbLBItJAP3Ql5 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-PMtAbLBItJAP3Ql5 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-PMtAbLBItJAP3Ql5 .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-PMtAbLBItJAP3Ql5 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-PMtAbLBItJAP3Ql5 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-PMtAbLBItJAP3Ql5 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-PMtAbLBItJAP3Ql5 .marker.cross{stroke:#333333;}#mermaid-svg-PMtAbLBItJAP3Ql5 svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-PMtAbLBItJAP3Ql5 p{margin:0;}#mermaid-svg-PMtAbLBItJAP3Ql5 .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-PMtAbLBItJAP3Ql5 .cluster-label text{fill:#333;}#mermaid-svg-PMtAbLBItJAP3Ql5 .cluster-label span{color:#333;}#mermaid-svg-PMtAbLBItJAP3Ql5 .cluster-label span p{background-color:transparent;}#mermaid-svg-PMtAbLBItJAP3Ql5 .label text,#mermaid-svg-PMtAbLBItJAP3Ql5 span{fill:#333;color:#333;}#mermaid-svg-PMtAbLBItJAP3Ql5 .node rect,#mermaid-svg-PMtAbLBItJAP3Ql5 .node circle,#mermaid-svg-PMtAbLBItJAP3Ql5 .node ellipse,#mermaid-svg-PMtAbLBItJAP3Ql5 .node polygon,#mermaid-svg-PMtAbLBItJAP3Ql5 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-PMtAbLBItJAP3Ql5 .rough-node .label text,#mermaid-svg-PMtAbLBItJAP3Ql5 .node .label text,#mermaid-svg-PMtAbLBItJAP3Ql5 .image-shape .label,#mermaid-svg-PMtAbLBItJAP3Ql5 .icon-shape .label{text-anchor:middle;}#mermaid-svg-PMtAbLBItJAP3Ql5 .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-PMtAbLBItJAP3Ql5 .rough-node .label,#mermaid-svg-PMtAbLBItJAP3Ql5 .node .label,#mermaid-svg-PMtAbLBItJAP3Ql5 .image-shape .label,#mermaid-svg-PMtAbLBItJAP3Ql5 .icon-shape .label{text-align:center;}#mermaid-svg-PMtAbLBItJAP3Ql5 .node.clickable{cursor:pointer;}#mermaid-svg-PMtAbLBItJAP3Ql5 .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-PMtAbLBItJAP3Ql5 .arrowheadPath{fill:#333333;}#mermaid-svg-PMtAbLBItJAP3Ql5 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-PMtAbLBItJAP3Ql5 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-PMtAbLBItJAP3Ql5 .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-PMtAbLBItJAP3Ql5 .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-PMtAbLBItJAP3Ql5 .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-PMtAbLBItJAP3Ql5 .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-PMtAbLBItJAP3Ql5 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-PMtAbLBItJAP3Ql5 .cluster text{fill:#333;}#mermaid-svg-PMtAbLBItJAP3Ql5 .cluster span{color:#333;}#mermaid-svg-PMtAbLBItJAP3Ql5 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-PMtAbLBItJAP3Ql5 .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-PMtAbLBItJAP3Ql5 rect.text{fill:none;stroke-width:0;}#mermaid-svg-PMtAbLBItJAP3Ql5 .icon-shape,#mermaid-svg-PMtAbLBItJAP3Ql5 .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-PMtAbLBItJAP3Ql5 .icon-shape p,#mermaid-svg-PMtAbLBItJAP3Ql5 .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-PMtAbLBItJAP3Ql5 .icon-shape .label rect,#mermaid-svg-PMtAbLBItJAP3Ql5 .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-PMtAbLBItJAP3Ql5 .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-PMtAbLBItJAP3Ql5 .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-PMtAbLBItJAP3Ql5 :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

“摘要压缩 / 重要性筛选”

“检索召回”

感知记忆（毫秒级）

当前输入

即时感知

长期记忆（持久化）

事实性知识

用户偏好

历史经验与反思

短期记忆（分钟级）

当前对话历史

任务中间状态

最近工具结果

• 感知记忆（Sensory Memory）：即当前输入，存活时间以毫秒计，是最原始的信息入口，通常直接进入上下文窗口。
• 短期记忆（Short-Term Memory）：即当前对话上下文，存活时间以分钟计。受限于上下文窗口大小，需要通过滑动窗口或摘要压缩来管理。
• 长期记忆（Long-Term Memory）：持久化的知识、事实和经验，通常存储在向量数据库或结构化数据库中。长期记忆让 Agent 具备跨会话的"成长"能力。

7.2 短期记忆管理策略

短期记忆面临的核心矛盾是上下文窗口有限，而任务执行过程中产生的信息量可能远超窗口容量。常用的管理策略包括：

滑动窗口（Sliding Window）：只保留最近 N 轮对话，丢弃更早的内容。实现简单，但会丢失重要的早期信息。

摘要压缩（Summarization）：当对话长度超过阈值时，将早期对话压缩为摘要，用摘要替换原始内容。摘要可以分层进行——"摘要的摘要"形成递归压缩。

重要性筛选（Importance Filtering）：根据信息的重要性评分保留或丢弃内容。例如，关键决策、错误信息、用户偏好通常比一般性的工具返回结果更重要。

混合策略：实际系统通常结合多种策略。例如，保留最近 5 轮原始对话 + 更早对话的摘要 + 长期记忆中检索出的相关信息。

7.3 长期记忆与向量数据库

长期记忆的核心技术挑战是高效检索。当记忆量达到百万级时，不可能将全部记忆放入上下文，必须按相关性进行检索。

基于向量数据库的方案是当前的主流选择：

#mermaid-svg-MRncglbm6gwhpaTj{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-MRncglbm6gwhpaTj .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-MRncglbm6gwhpaTj .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-MRncglbm6gwhpaTj .error-icon{fill:#552222;}#mermaid-svg-MRncglbm6gwhpaTj .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-MRncglbm6gwhpaTj .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-MRncglbm6gwhpaTj .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-MRncglbm6gwhpaTj .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-MRncglbm6gwhpaTj .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-MRncglbm6gwhpaTj .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-MRncglbm6gwhpaTj .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-MRncglbm6gwhpaTj .marker{fill:#333333;stroke:#333333;}#mermaid-svg-MRncglbm6gwhpaTj .marker.cross{stroke:#333333;}#mermaid-svg-MRncglbm6gwhpaTj svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-MRncglbm6gwhpaTj p{margin:0;}#mermaid-svg-MRncglbm6gwhpaTj .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-MRncglbm6gwhpaTj .cluster-label text{fill:#333;}#mermaid-svg-MRncglbm6gwhpaTj .cluster-label span{color:#333;}#mermaid-svg-MRncglbm6gwhpaTj .cluster-label span p{background-color:transparent;}#mermaid-svg-MRncglbm6gwhpaTj .label text,#mermaid-svg-MRncglbm6gwhpaTj span{fill:#333;color:#333;}#mermaid-svg-MRncglbm6gwhpaTj .node rect,#mermaid-svg-MRncglbm6gwhpaTj .node circle,#mermaid-svg-MRncglbm6gwhpaTj .node ellipse,#mermaid-svg-MRncglbm6gwhpaTj .node polygon,#mermaid-svg-MRncglbm6gwhpaTj .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-MRncglbm6gwhpaTj .rough-node .label text,#mermaid-svg-MRncglbm6gwhpaTj .node .label text,#mermaid-svg-MRncglbm6gwhpaTj .image-shape .label,#mermaid-svg-MRncglbm6gwhpaTj .icon-shape .label{text-anchor:middle;}#mermaid-svg-MRncglbm6gwhpaTj .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-MRncglbm6gwhpaTj .rough-node .label,#mermaid-svg-MRncglbm6gwhpaTj .node .label,#mermaid-svg-MRncglbm6gwhpaTj .image-shape .label,#mermaid-svg-MRncglbm6gwhpaTj .icon-shape .label{text-align:center;}#mermaid-svg-MRncglbm6gwhpaTj .node.clickable{cursor:pointer;}#mermaid-svg-MRncglbm6gwhpaTj .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-MRncglbm6gwhpaTj .arrowheadPath{fill:#333333;}#mermaid-svg-MRncglbm6gwhpaTj .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-MRncglbm6gwhpaTj .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-MRncglbm6gwhpaTj .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-MRncglbm6gwhpaTj .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-MRncglbm6gwhpaTj .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-MRncglbm6gwhpaTj .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-MRncglbm6gwhpaTj .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-MRncglbm6gwhpaTj .cluster text{fill:#333;}#mermaid-svg-MRncglbm6gwhpaTj .cluster span{color:#333;}#mermaid-svg-MRncglbm6gwhpaTj div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-MRncglbm6gwhpaTj .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-MRncglbm6gwhpaTj rect.text{fill:none;stroke-width:0;}#mermaid-svg-MRncglbm6gwhpaTj .icon-shape,#mermaid-svg-MRncglbm6gwhpaTj .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-MRncglbm6gwhpaTj .icon-shape p,#mermaid-svg-MRncglbm6gwhpaTj .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-MRncglbm6gwhpaTj .icon-shape .label rect,#mermaid-svg-MRncglbm6gwhpaTj .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-MRncglbm6gwhpaTj .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-MRncglbm6gwhpaTj .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-MRncglbm6gwhpaTj :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

新经验 / 新事实

文本向量化Embedding 模型

向量数据库FAISS / Milvus / Pinecone

当前查询 / 上下文

向量化

相似度检索Top-K 召回

重排序可选用 Cross-Encoder

注入上下文

关键设计考量包括：

• Embedding 模型选择：不同语言和领域需要不同的嵌入模型，中文场景可考虑 BGE、M3E 等。
• 索引策略：随着记忆规模增长，HNSW、IVF 等近似最近邻索引可以提供更好的检索性能。
• 元数据过滤：在向量检索之外，结合元数据（如时间、来源、类型）做结构化过滤，以提升召回精度。
• 遗忘机制：长期记忆也需要“遗忘”，过期信息应有淘汰策略，避免检索出过时内容。

7.4 记忆系统实现示例

以下是一个包含短期和长期记忆的 AI Agent 记忆系统实现：

from abc import ABC, abstractmethod
from typing import List, Dict, Any, Optional
from datetime import datetime

class VectorStore(ABC):
"""向量数据库抽象接口"""

@abstractmethod
def add(self, text: str, metadata: Dict[str, Any]) –> None:
"""存储文本及其向量"""

@abstractmethod
def search(self, query: str, top_k: int = 5) –> List[Dict[str, Any]]:
"""检索与 query 最相似的 top_k 条记录"""

class AgentMemory:
"""AI Agent 记忆系统：短期 + 长期"""

def __init__(
self,
short_term_limit: int = 10,
vector_store: Optional[VectorStore] = None,
):
self.short_term: List[Dict[str, str]] = []
self.short_term_limit = short_term_limit
self.long_term = vector_store

def add_observation(self, role: str, content: str) –> None:
"""添加一条观察/消息到短期记忆"""
self.short_term.append({
"role": role,
"content": content,
"timestamp": datetime.now().isoformat(),
})
# 超出限制时触发压缩
if len(self.short_term) > self.short_term_limit:
self._compress()

def _compress(self) –> None:
"""将较早的短期记忆压缩并转入长期记忆"""
# 压缩对象：最早的若干条消息
overflow = self.short_term[:–self.short_term_limit]
if not overflow:
return

# 实际场景中调用 LLM 生成摘要
summary = self._summarize(overflow)

# 摘要存入长期记忆
if self.long_term:
self.long_term.add(
text=summary,
metadata={"type": "summary", "count": len(overflow)},
)

# 用摘要替换被压缩的原始消息
self.short_term = [
{"role": "system", "content": f"[历史摘要] {summary}"}
] + self.short_term[–self.short_term_limit:]

def consolidate(self, text: str, metadata: Optional[Dict] = None) –> None:
"""显式地将重要信息巩固到长期记忆"""
if self.long_term:
self.long_term.add(text=text, metadata=metadata or {})

def retrieve(self, query: str, top_k: int = 5) –> List[Dict[str, Any]]:
"""从长期记忆检索相关信息"""
if not self.long_term:
return []
return self.long_term.search(query, top_k=top_k)

def get_context(self, query: str) –> str:
"""组装当前记忆上下文：短期 + 长期检索结果"""
parts = [f"{m['role']}: {m['content']}" for m in self.short_term]
if self.long_term:
retrieved = self.retrieve(query)
if retrieved:
parts.insert(
0,
"[相关长期记忆]\\n" + "\\n".join(
f"- {r['text']}" for r in retrieved
),
)
return "\\n\\n".join(parts)

def _summarize(self, messages: List[Dict[str, str]]) –> str:
"""占位：实际场景调用 LLM 生成摘要"""
content = " | ".join(m["content"] for m in messages)
return f"[摘要] {content[:200]}…"

八、多 Agent 协作架构

8.1 为什么需要多 Agent

随着任务复杂度增加，单 Agent 的局限性日益凸显：

• 上下文窗口压力：复杂任务涉及的信息量可能超出单个 Agent 的处理能力；
• 能力单一：单一模型在特定领域的表现可能不如多个专业化模型组合；
• 缺乏制衡：单个 Agent 的错误决策无人监督，容易一错到底；
• 并行度受限：单 Agent 天然串行，难以充分利用并行计算资源。

多 Agent 协作架构的核心思路是：将复杂任务分解给多个专业化 Agent，每个 Agent 负责特定子任务，通过通信协议协调完成整体目标。 这类似于人类组织中的分工协作——有人做规划，有人做执行，有人做审查。

8.2 中心化协作模式

中心化模式（Centralized Orchestration）采用"一个大脑，多个手脚"的结构：

#mermaid-svg-81kOzuxpyDHldeY1{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-81kOzuxpyDHldeY1 .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-81kOzuxpyDHldeY1 .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-81kOzuxpyDHldeY1 .error-icon{fill:#552222;}#mermaid-svg-81kOzuxpyDHldeY1 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-81kOzuxpyDHldeY1 .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-81kOzuxpyDHldeY1 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-81kOzuxpyDHldeY1 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-81kOzuxpyDHldeY1 .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-81kOzuxpyDHldeY1 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-81kOzuxpyDHldeY1 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-81kOzuxpyDHldeY1 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-81kOzuxpyDHldeY1 .marker.cross{stroke:#333333;}#mermaid-svg-81kOzuxpyDHldeY1 svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-81kOzuxpyDHldeY1 p{margin:0;}#mermaid-svg-81kOzuxpyDHldeY1 .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-81kOzuxpyDHldeY1 .cluster-label text{fill:#333;}#mermaid-svg-81kOzuxpyDHldeY1 .cluster-label span{color:#333;}#mermaid-svg-81kOzuxpyDHldeY1 .cluster-label span p{background-color:transparent;}#mermaid-svg-81kOzuxpyDHldeY1 .label text,#mermaid-svg-81kOzuxpyDHldeY1 span{fill:#333;color:#333;}#mermaid-svg-81kOzuxpyDHldeY1 .node rect,#mermaid-svg-81kOzuxpyDHldeY1 .node circle,#mermaid-svg-81kOzuxpyDHldeY1 .node ellipse,#mermaid-svg-81kOzuxpyDHldeY1 .node polygon,#mermaid-svg-81kOzuxpyDHldeY1 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-81kOzuxpyDHldeY1 .rough-node .label text,#mermaid-svg-81kOzuxpyDHldeY1 .node .label text,#mermaid-svg-81kOzuxpyDHldeY1 .image-shape .label,#mermaid-svg-81kOzuxpyDHldeY1 .icon-shape .label{text-anchor:middle;}#mermaid-svg-81kOzuxpyDHldeY1 .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-81kOzuxpyDHldeY1 .rough-node .label,#mermaid-svg-81kOzuxpyDHldeY1 .node .label,#mermaid-svg-81kOzuxpyDHldeY1 .image-shape .label,#mermaid-svg-81kOzuxpyDHldeY1 .icon-shape .label{text-align:center;}#mermaid-svg-81kOzuxpyDHldeY1 .node.clickable{cursor:pointer;}#mermaid-svg-81kOzuxpyDHldeY1 .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-81kOzuxpyDHldeY1 .arrowheadPath{fill:#333333;}#mermaid-svg-81kOzuxpyDHldeY1 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-81kOzuxpyDHldeY1 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-81kOzuxpyDHldeY1 .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-81kOzuxpyDHldeY1 .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-81kOzuxpyDHldeY1 .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-81kOzuxpyDHldeY1 .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-81kOzuxpyDHldeY1 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-81kOzuxpyDHldeY1 .cluster text{fill:#333;}#mermaid-svg-81kOzuxpyDHldeY1 .cluster span{color:#333;}#mermaid-svg-81kOzuxpyDHldeY1 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-81kOzuxpyDHldeY1 .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-81kOzuxpyDHldeY1 rect.text{fill:none;stroke-width:0;}#mermaid-svg-81kOzuxpyDHldeY1 .icon-shape,#mermaid-svg-81kOzuxpyDHldeY1 .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-81kOzuxpyDHldeY1 .icon-shape p,#mermaid-svg-81kOzuxpyDHldeY1 .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-81kOzuxpyDHldeY1 .icon-shape .label rect,#mermaid-svg-81kOzuxpyDHldeY1 .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-81kOzuxpyDHldeY1 .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-81kOzuxpyDHldeY1 .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-81kOzuxpyDHldeY1 :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

分配子任务

分配子任务

分配子任务

汇报结果

汇报结果

汇报结果

Orchestrator Agent中央协调者

Agent A数据分析

Agent B代码生成

Agent C质量审查

汇总输出

工作方式：Orchestrator 负责任务分解和分发，其他 Agent 执行子任务并汇报结果。Orchestrator 本身通常也由 LLM 驱动，负责理解全局任务、制定协作策略、协调各 Agent 工作。

优点：

• 控制清晰，任务流向一目了然；
• 易于调试，所有协调逻辑集中在 Orchestrator；
• 适合任务结构明确、可预定义分工的场景。

缺点：

• Orchestrator 成为瓶颈和单点故障——它一旦出错，整个系统瘫痪；
• 当 Agent 数量增多时，Orchestrator 的处理压力线性增长。

8.3 去中心化协作模式

去中心化模式（Decentralized Collaboration）中没有中心控制节点，Agent 之间直接通信：

#mermaid-svg-LgiQWEq1reCvlEYg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-LgiQWEq1reCvlEYg .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-LgiQWEq1reCvlEYg .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-LgiQWEq1reCvlEYg .error-icon{fill:#552222;}#mermaid-svg-LgiQWEq1reCvlEYg .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-LgiQWEq1reCvlEYg .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-LgiQWEq1reCvlEYg .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-LgiQWEq1reCvlEYg .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-LgiQWEq1reCvlEYg .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-LgiQWEq1reCvlEYg .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-LgiQWEq1reCvlEYg .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-LgiQWEq1reCvlEYg .marker{fill:#333333;stroke:#333333;}#mermaid-svg-LgiQWEq1reCvlEYg .marker.cross{stroke:#333333;}#mermaid-svg-LgiQWEq1reCvlEYg svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-LgiQWEq1reCvlEYg p{margin:0;}#mermaid-svg-LgiQWEq1reCvlEYg .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-LgiQWEq1reCvlEYg .cluster-label text{fill:#333;}#mermaid-svg-LgiQWEq1reCvlEYg .cluster-label span{color:#333;}#mermaid-svg-LgiQWEq1reCvlEYg .cluster-label span p{background-color:transparent;}#mermaid-svg-LgiQWEq1reCvlEYg .label text,#mermaid-svg-LgiQWEq1reCvlEYg span{fill:#333;color:#333;}#mermaid-svg-LgiQWEq1reCvlEYg .node rect,#mermaid-svg-LgiQWEq1reCvlEYg .node circle,#mermaid-svg-LgiQWEq1reCvlEYg .node ellipse,#mermaid-svg-LgiQWEq1reCvlEYg .node polygon,#mermaid-svg-LgiQWEq1reCvlEYg .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-LgiQWEq1reCvlEYg .rough-node .label text,#mermaid-svg-LgiQWEq1reCvlEYg .node .label text,#mermaid-svg-LgiQWEq1reCvlEYg .image-shape .label,#mermaid-svg-LgiQWEq1reCvlEYg .icon-shape .label{text-anchor:middle;}#mermaid-svg-LgiQWEq1reCvlEYg .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-LgiQWEq1reCvlEYg .rough-node .label,#mermaid-svg-LgiQWEq1reCvlEYg .node .label,#mermaid-svg-LgiQWEq1reCvlEYg .image-shape .label,#mermaid-svg-LgiQWEq1reCvlEYg .icon-shape .label{text-align:center;}#mermaid-svg-LgiQWEq1reCvlEYg .node.clickable{cursor:pointer;}#mermaid-svg-LgiQWEq1reCvlEYg .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-LgiQWEq1reCvlEYg .arrowheadPath{fill:#333333;}#mermaid-svg-LgiQWEq1reCvlEYg .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-LgiQWEq1reCvlEYg .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-LgiQWEq1reCvlEYg .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-LgiQWEq1reCvlEYg .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-LgiQWEq1reCvlEYg .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-LgiQWEq1reCvlEYg .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-LgiQWEq1reCvlEYg .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-LgiQWEq1reCvlEYg .cluster text{fill:#333;}#mermaid-svg-LgiQWEq1reCvlEYg .cluster span{color:#333;}#mermaid-svg-LgiQWEq1reCvlEYg div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-LgiQWEq1reCvlEYg .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-LgiQWEq1reCvlEYg rect.text{fill:none;stroke-width:0;}#mermaid-svg-LgiQWEq1reCvlEYg .icon-shape,#mermaid-svg-LgiQWEq1reCvlEYg .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-LgiQWEq1reCvlEYg .icon-shape p,#mermaid-svg-LgiQWEq1reCvlEYg .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-LgiQWEq1reCvlEYg .icon-shape .label rect,#mermaid-svg-LgiQWEq1reCvlEYg .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-LgiQWEq1reCvlEYg .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-LgiQWEq1reCvlEYg .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-LgiQWEq1reCvlEYg :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

直接通信

直接通信

直接通信

直接通信

直接通信

Agent A

Agent B

Agent C

Agent D

工作方式：每个 Agent 根据自身能力和当前状态自主“认领”任务。Agent 之间通过点对点消息传递进行协商、委托和结果共享。

优点：

• 弹性好，单个 Agent 故障不会导致全局瘫痪。
• 可扩展性强，新增 Agent 无需修改中央逻辑。
• 适合动态、开放的任务环境。

缺点：

• 协调复杂，可能出现任务冲突或重复劳动。
• 缺乏全局视角，可能出现“各自为政”的局面。
• 调试困难，问题定位需要追踪复杂的消息传递路径。

8.4 层级协作模式

层级模式（Hierarchical Organization）将 Agent 组织成树状结构：

#mermaid-svg-LIkeVQeAyorGXctv{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-LIkeVQeAyorGXctv .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-LIkeVQeAyorGXctv .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-LIkeVQeAyorGXctv .error-icon{fill:#552222;}#mermaid-svg-LIkeVQeAyorGXctv .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-LIkeVQeAyorGXctv .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-LIkeVQeAyorGXctv .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-LIkeVQeAyorGXctv .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-LIkeVQeAyorGXctv .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-LIkeVQeAyorGXctv .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-LIkeVQeAyorGXctv .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-LIkeVQeAyorGXctv .marker{fill:#333333;stroke:#333333;}#mermaid-svg-LIkeVQeAyorGXctv .marker.cross{stroke:#333333;}#mermaid-svg-LIkeVQeAyorGXctv svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-LIkeVQeAyorGXctv p{margin:0;}#mermaid-svg-LIkeVQeAyorGXctv .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-LIkeVQeAyorGXctv .cluster-label text{fill:#333;}#mermaid-svg-LIkeVQeAyorGXctv .cluster-label span{color:#333;}#mermaid-svg-LIkeVQeAyorGXctv .cluster-label span p{background-color:transparent;}#mermaid-svg-LIkeVQeAyorGXctv .label text,#mermaid-svg-LIkeVQeAyorGXctv span{fill:#333;color:#333;}#mermaid-svg-LIkeVQeAyorGXctv .node rect,#mermaid-svg-LIkeVQeAyorGXctv .node circle,#mermaid-svg-LIkeVQeAyorGXctv .node ellipse,#mermaid-svg-LIkeVQeAyorGXctv .node polygon,#mermaid-svg-LIkeVQeAyorGXctv .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-LIkeVQeAyorGXctv .rough-node .label text,#mermaid-svg-LIkeVQeAyorGXctv .node .label text,#mermaid-svg-LIkeVQeAyorGXctv .image-shape .label,#mermaid-svg-LIkeVQeAyorGXctv .icon-shape .label{text-anchor:middle;}#mermaid-svg-LIkeVQeAyorGXctv .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-LIkeVQeAyorGXctv .rough-node .label,#mermaid-svg-LIkeVQeAyorGXctv .node .label,#mermaid-svg-LIkeVQeAyorGXctv .image-shape .label,#mermaid-svg-LIkeVQeAyorGXctv .icon-shape .label{text-align:center;}#mermaid-svg-LIkeVQeAyorGXctv .node.clickable{cursor:pointer;}#mermaid-svg-LIkeVQeAyorGXctv .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-LIkeVQeAyorGXctv .arrowheadPath{fill:#333333;}#mermaid-svg-LIkeVQeAyorGXctv .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-LIkeVQeAyorGXctv .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-LIkeVQeAyorGXctv .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-LIkeVQeAyorGXctv .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-LIkeVQeAyorGXctv .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-LIkeVQeAyorGXctv .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-LIkeVQeAyorGXctv .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-LIkeVQeAyorGXctv .cluster text{fill:#333;}#mermaid-svg-LIkeVQeAyorGXctv .cluster span{color:#333;}#mermaid-svg-LIkeVQeAyorGXctv div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-LIkeVQeAyorGXctv .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-LIkeVQeAyorGXctv rect.text{fill:none;stroke-width:0;}#mermaid-svg-LIkeVQeAyorGXctv .icon-shape,#mermaid-svg-LIkeVQeAyorGXctv .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-LIkeVQeAyorGXctv .icon-shape p,#mermaid-svg-LIkeVQeAyorGXctv .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-LIkeVQeAyorGXctv .icon-shape .label rect,#mermaid-svg-LIkeVQeAyorGXctv .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-LIkeVQeAyorGXctv .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-LIkeVQeAyorGXctv .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-LIkeVQeAyorGXctv :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

顶层 Agent战略规划

中层 Agent领域 A 管理

中层 Agent领域 B 管理

底层 Agent子任务 1

底层 Agent子任务 2

底层 Agent子任务 3

底层 Agent子任务 4

工作方式：

• 上层 Agent 做规划决策，将目标分解为领域级子目标；
• 中层 Agent 做任务分解，将领域子目标进一步拆分为具体任务；
• 底层 Agent 做具体执行，完成粒度最小的子任务。

层级模式结合了中心化的控制力和去中心化的灵活性：每一层都有自主决策权，但整体方向由上层把控。这种结构特别适合大型组织类任务，如企业级工作流自动化。

8.5 通信协议设计

AI Agent 间通信是多 AI Agent 系统的核心挑战。常见的通信方式包括：

通信消息的结构设计直接影响系统效率。一个好的消息格式应包含以下字段：

以下是一个多 Agent 通信的时序图示例：

Agent BAgent AOrchestratorAgent BAgent AOrchestrator#mermaid-svg-G7IF17J9sawXi46m{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-G7IF17J9sawXi46m .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-G7IF17J9sawXi46m .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-G7IF17J9sawXi46m .error-icon{fill:#552222;}#mermaid-svg-G7IF17J9sawXi46m .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-G7IF17J9sawXi46m .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-G7IF17J9sawXi46m .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-G7IF17J9sawXi46m .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-G7IF17J9sawXi46m .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-G7IF17J9sawXi46m .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-G7IF17J9sawXi46m .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-G7IF17J9sawXi46m .marker{fill:#333333;stroke:#333333;}#mermaid-svg-G7IF17J9sawXi46m .marker.cross{stroke:#333333;}#mermaid-svg-G7IF17J9sawXi46m svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-G7IF17J9sawXi46m p{margin:0;}#mermaid-svg-G7IF17J9sawXi46m .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-G7IF17J9sawXi46m text.actor>tspan{fill:black;stroke:none;}#mermaid-svg-G7IF17J9sawXi46m .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-G7IF17J9sawXi46m .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-svg-G7IF17J9sawXi46m .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-svg-G7IF17J9sawXi46m .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-svg-G7IF17J9sawXi46m #arrowhead path{fill:#333;stroke:#333;}#mermaid-svg-G7IF17J9sawXi46m .sequenceNumber{fill:white;}#mermaid-svg-G7IF17J9sawXi46m #sequencenumber{fill:#333;}#mermaid-svg-G7IF17J9sawXi46m #crosshead path{fill:#333;stroke:#333;}#mermaid-svg-G7IF17J9sawXi46m .messageText{fill:#333;stroke:none;}#mermaid-svg-G7IF17J9sawXi46m .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-G7IF17J9sawXi46m .labelText,#mermaid-svg-G7IF17J9sawXi46m .labelText>tspan{fill:black;stroke:none;}#mermaid-svg-G7IF17J9sawXi46m .loopText,#mermaid-svg-G7IF17J9sawXi46m .loopText>tspan{fill:black;stroke:none;}#mermaid-svg-G7IF17J9sawXi46m .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-G7IF17J9sawXi46m .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-G7IF17J9sawXi46m .noteText,#mermaid-svg-G7IF17J9sawXi46m .noteText>tspan{fill:black;stroke:none;}#mermaid-svg-G7IF17J9sawXi46m .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-svg-G7IF17J9sawXi46m .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-svg-G7IF17J9sawXi46m .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-svg-G7IF17J9sawXi46m .actorPopupMenu{position:absolute;}#mermaid-svg-G7IF17J9sawXi46m .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-G7IF17J9sawXi46m .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-G7IF17J9sawXi46m .actor-man circle,#mermaid-svg-G7IF17J9sawXi46m line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-svg-G7IF17J9sawXi46m :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}发送任务请求（含 deadline）请求数据支持返回数据提交子任务结果汇总并评估

8.6 冲突处理与一致性

多 Agent 并行执行时不可避免会出现资源冲突和结果矛盾。常见的冲突处理策略包括：

优先级仲裁（Priority Arbitration）：为每个 Agent 预定义优先级，冲突时高优先级 Agent 的执行先进行。例如，在修改共享文件时，“审查 Agent"的优先级高于"生成 Agent”。

投票机制（Voting）：当多个 Agent 对同一问题给出不同答案时，采用多数决原则。这是最简单也最常用的意见融合方式，LlamaIndex 等框架已将投票集成到多 Agent 编排中。

乐观并发控制（Optimistic Concurrency Control）：借鉴数据库领域的思想——先执行、后检测冲突，检测到冲突时再回滚重做。这种策略在冲突概率较低的场景下效率很高。

共识算法（Consensus Algorithm）：对于高价值决策，可以采用更严格的共识机制。例如，要求 N 个 Agent 中至少 M 个达成一致才采纳决策（类似拜占庭容错的简化版本）。

九、Agent 框架全景对比

9.1 主流框架介绍

2024-2025 年，Agent 开发框架呈现百花齐放的态势。以下是主流框架的概况：

LangChain：最早流行的 LLM 应用开发框架，内置 ReAct 和 Plan-Execute 模式的实现，生态最丰富。其优势在于庞大的工具集成（数百个第三方 API 连接器）和活跃的社区。但抽象层次多，学习曲线较陡，生产级性能优化需要较多经验。

LangGraph：LangChain 团队推出的图状态机框架，将 Agent 流程建模为有向图（节点 + 边），支持循环、条件分支和并行执行。特别适合构建复杂的多步骤、多 Agent 工作流，也是目前生产环境采用率上升最快的框架之一。

CrewAI：专注于多 Agent 协作的框架，内置 Role-Playing 设计模式，每个 Agent 可以定义角色、目标、背景故事。其"团队协作"的抽象非常直观，适合快速搭建多 Agent 演示系统。但在超大规模、高并发场景下的性能表现需要额外优化。

AutoGen：微软出品的多 Agent 对话框架，核心理念是让多个 Agent 通过对话协作完成复杂任务。支持灵活的对话模式（如两人对话、群聊、嵌套对话），适合研究多 Agent 交互模式。2024 年 AutoGen 经历了一次较大架构调整，v0.4 版本的重构改善了 API 一致性。

OpenAI Swarm：OpenAI 推出的轻量级多 Agent 框架，核心概念是 Agent 间的 “handoff”（任务转交）机制。代码量极小（核心仅数百行），适合快速原型和学习多 Agent 编排概念。

其他值得关注的框架：

• Dify / Coze（扣子）：低代码/无代码 Agent 搭建平台，将 Agent 开发门槛大幅降低，适合非程序员和快速验证场景；
• LlamaIndex：以数据检索和 RAG 见长，其 Agent 模块与数据管道深度集成；
• Camel：侧重角色扮演式 Agent 协作，在模拟社会行为方面有特色；
• Semantic Kernel：微软的企业级 Agent 框架，与企业级安全、可观测性集成较好。

9.2 框架选型决策矩阵

选择框架时，应根据项目需求从多个维度综合评估：

9.3 选型建议

简单工具调用：如果你的需求只是"让 LLM 按意图调用几个 API"，直接使用原生 Function Calling 或轻量封装即可，不必引入重框架。过度设计是 Agent 项目失败的常见原因。

单 Agent 复杂推理：推荐 LangChain 或直接基于 LangGraph。LangChain 的 ReAct 实现成熟，文档和示例丰富，适合快速起步。

多步骤工作流：首选 LangGraph。其图状态机模型天然适合表达"步骤 → 条件分支 → 循环 → 并行"的工作流，且支持可视化调试。

多 Agent 协作：CrewAI 和 AutoGen 都是不错的选择。CrewAI 的角色抽象更直观，适合业务团队；AutoGen 的对话式协作更灵活，适合研究型团队。生产环境建议在 LangGraph 之上自建多 Agent 编排，以获得最大控制力。

快速原型验证：OpenAI Swarm 或低代码平台（Coze、Dify）可以在数小时内跑通概念验证。

需要特别强调的是：框架是工具，不是目的。真正决定 Agent 质量的，永远是架构设计质量、提示词工程水平、工具设计合理性和记忆管理策略。不要陷入"框架选型焦虑"，先明确需求，再选框架。

十、Agent 的挑战与未来趋势

10.1 当前核心挑战

尽管 Agent 技术发展迅猛，但距离"可靠的自主智能体"仍有显著距离。当前面临的核心挑战包括：

1. LLM 幻觉导致错误操作。这是 Agent 场景中最危险的问题。在对话中，幻觉只是一个错误答案；在 Agent 中，幻觉可能导致执行错误的工具调用——发送错误的邮件、修改错误的数据、执行危险的操作。缓解手段包括：工具调用的参数校验、敏感操作的二次确认、执行前的结果预判等。

2. 多轮推理 Token 消耗大。复杂任务可能产生数万甚至数十万 Token 的上下文，既增加成本又拖慢响应。需要在上下文管理、推理压缩和模型长上下文能力之间寻求平衡。

3. 串行执行延迟长。每一步 LLM 调用（通常 2-10 秒）加上工具执行时间，使得端到端延迟可能达到分钟级。并行优化、流式输出、缓存机制是缓解延迟的关键手段。

4. 安全边界模糊。Agent 的自主性带来安全风险：如何确保 Agent 不会执行有害操作？如何限制其权限范围？沙箱环境、权限分级、操作审计是必要的安全措施。

5. 行为非确定难以评估。同一个任务，Agent 每次执行的路径和结果可能不同，导致测试和评估非常困难。需要建立多维度评估体系（任务完成率、执行效率、资源消耗、安全合规性等）。

10.2 未来发展趋势

展望 2026 年及以后，Agent 技术将在以下方向持续演进：

1. 多 Agent 协作走向成熟。从简单的主从结构发展为更加复杂的组织形态，Agent 之间将出现类似人类组织中的角色分化、协商机制和冲突解决机制。Agent 团队的"社会智能"将成为新的研究热点。

2. 工具自主学习与创造。当前 Agent 的工具是预定义的，未来 Agent 将能够自主学习新工具、组合现有工具，甚至为自己"创造"新工具。这需要更强的代码生成能力和安全沙箱支持。

3. 跨会话长期记忆落地。从简单的对话历史存储，发展为结构化的经验积累系统。Agent 将能记住用户偏好、历史决策、成功策略，并在新任务中主动应用这些经验——真正实现"越用越聪明"。

4. 形式化安全约束。从"提示词层面的安全约束"进化为"系统层面的形式化保障"。例如，用状态机严格定义 Agent 的合法状态转移，用类型系统约束工具调用的参数空间，用运行时监控检测异常行为。

5. 端侧轻量 Agent。大模型小型化趋势（如 Phi、Qwen 小模型系列）使端侧 Agent 成为可能。手机、PC、IoT 设备上的本地 Agent 将带来隐私保护和低延迟的优势，开辟全新的应用场景。

6. Agent 与 RAG、工作流引擎的深度融合。Agent 不再是孤立系统，而是与检索增强生成、业务流程管理、自动化运维等系统深度集成，成为企业智能化改造的基础设施。

10.3 工程落地建议

基于一线实践经验，本文对 Agent 工程落地提出以下建议：

十一、总结

11.1 三大架构范式速览

11.2 核心洞察

回顾全文，可以提炼出三条核心洞察：

第一，ReAct 是基础。 几乎所有 Agent 都包含"推理-行动"循环，它是智能体实现自主性的最小闭环。理解 ReAct 是理解一切 Agent 架构的起点。

第二，Plan-Execute 解决方向性问题。 先想清楚再动手，通过全局规划避免在局部迷路。这是从"能做事"走向"做对事"的关键跃迁。

第三，Reflection 解决质量问题。 做完后检查改进，通过自我评估实现持续提升。这是 Agent 从"可用"走向"可靠"的必经之路。

实际系统通常不是单一架构的纯粹实现，而是三者的有机混合体：用 Plan 定方向，用 ReAct 做执行，用 Reflection 保质量，再辅以扎实的记忆系统和合理的多 Agent 编排，才能构建真正生产级的 AI Agent。

下一篇我们将深入 Agent 工具调用机制：Function Calling、Tool Use 的底层原理，以及如何为 Agent 设计高效的工具集。同时，我们也将拆解一个端到端的生产级 Agent 案例，从需求分析到架构设计再到代码实现。

附录：延伸阅读

• Yao 等，2022，《ReAct: Synergizing Reasoning and Acting in Language Models》
• Shinn 等，2023，《Reflexion: Language Agents with Verbal Reinforcement Learning》
• LangChain，《State of AI Agents》报告
• Wooldridge & Jennings，1995，《Intelligent Agents: Theory and Practice》
• Russel & Norvig，《人工智能：一种现代方法》
• LangGraph 官方文档（多 Agent 编排模式）
• OpenAI Swarm 官方仓库（轻量级多 Agent handoff）