Agent 能力成熟度模型 L1 → L7

从纯文本理解到组织级生态集成，Agent 能力的 7 个跃迁层级。

L1LLM

L2Tools

L3State

L4Planning

L5Composition

L6Collaboration

L7Ecosystem

L1 — LLM：纯文本/多模态理解

核心跃迁：从无 AI 到纯理解。模型能读取文本、图片、代码，输出分析结果，但不能操作环境。

业务场景

代码审查意见、报错解读
截图 → 分析 UI 问题（"这是 CORS 错误，需要配置 Access-Control-Allow-Origin"）
架构图 → 评审反馈
设计稿 → 描述还原度差异

典型操作

输入一张报错截图 → 输出 "这是 CORS 错误，需要配置 Access-Control-Allow-Origin"

技术要点

依赖 context window 大小（4K→200K tokens）
Zero-shot / Few-shot 提示即可
多模态模型（GPT-4V, Claude Vision, Gemini）支持图像输入

当前行业位置（2026）：大多数生产系统在 L2-L3，领先团队在 L4-L5，L6-L7 仍属前沿探索。Gartner 预测 2026 年 40% 企业应用将嵌入 Agent（主要 L2-L4 层级）。

前沿 Vellum · Six Levels of Agentic Behavior · DextraLabs · Maturity Model 2025 · Six Maturity Levels

推理与规划框架

从线性推理到蒙特卡洛树搜索，Agent 的 9 种推理模式。

框架全景：复杂度阶梯

Level 1 — 单次推理 CoT（线性思维链） Level 2 — 多路径推理 Self-Consistency（采样+投票） / ToT（树状探索+剪枝） Level 3 — 推理+行动 ReAct（思考↔工具交替） / Function Calling（结构化工具调用） Level 4 — 战略规划 Plan-and-Execute（规划执行分离） / ReWOO（一次规划全计划）/ DAG 调度 Level 5 — 自适应搜索 LATS（蒙特卡洛树搜索） / 动态重规划 Level 6 — 经验学习 Reflexion（语言强化学习，从失败中积累经验）

Chain-of-Thought (CoT) — 思维链

Wei et al. (2022) 发现只需在提示中加一句 "Let's think step by step"，就能大幅提升 LLM 在数学、逻辑等推理任务上的表现。CoT 是所有 Agent 推理的基石。

CoT 的三种形态

Zero-Shot CoT

提示末尾加 "Let's think step by step"，无需示例即可激活推理。

现代模型上 Zero-Shot 常常追平甚至超过 Few-Shot CoT。

Few-Shot CoT

提供 2-5 个 "问题 → 推理过程 → 答案" 的示例。模型学习推理模式并泛化。

关键发现：推理链的格式和步骤结构比内容正确性更重要（即使推理有误，格式正确就能提升效果）。

Self-Consistency

采样 N 条推理路径 → 提取答案 → 多数投票。

GSM8K +17.9%，SVAMP +11.0%，AQuA +12.2%。2025 改进版支持加权投票。

CoT 效果数据

Benchmark	无 CoT	Zero-Shot CoT	Few-Shot CoT	Self-Consistency
GSM8K（数学）	~18%	~58%	~57%	74.4%
SVAMP（算术）	~65%	~79%	~80%	86.8%
AQuA（代数）	~25%	~48%	~52%	58.4%

数据基于 PaLM 540B。现代模型（GPT-4、Claude）基线更高，但 CoT 增量依然显著。

Wei et al. 2022 · Prompt Guide · CoT · Self-Consistency Guide

Tree of Thoughts (ToT) — 思维树

CoT 是一条线，ToT 是一棵树。Agent 同时探索多条推理路径，评估每个中间状态，剪掉无望的分支。

四个模块

Thought Decomposer — 定义"一步思考"的粒度
Thought Generator — 生成候选下一步
State Evaluator — 评估状态（value 或 vote）
Search Algorithm — BFS 或 DFS 系统探索

BFS vs DFS

BFS：每层保留 top-b 候选（beam），适合浅层问题。空间 O(b^d)。

DFS：沿最有希望的路径深入，遇死路回溯。空间 O(d)，适合深层探索。

剪枝策略

Value-based：评估为 "impossible" 的直接剪掉
Beam 剪枝：BFS 每层只保留 top-b
深度限制 + 重复检测

2025 Forest-of-Thought：多棵树并行搜索

Princeton NLP ToT · Prompt Guide

ReAct — 推理 + 行动

ReAct = Reasoning + Acting（Yao et al., 2022）。目前最广泛使用的 Agent 推理模式。

核心循环

┌──────────┐ ┌──────────┐ ┌────────────┐ │ Thought │──────→│ Action │──────→│Observation │ │ 分析现状 │ │ 调用工具 │ │ 获取结果 │ │ 决定下步 │ │ (外部执行) │ │ (注入上下文) │ └──────────┘ └──────────┘ └─────┬──────┘ ▲ │ └───────────────────────────────────────┘ 循环直到 Final Answer

Prompt 模板

Answer the following questions. You have access to these tools: {tool_descriptions} Use this format: Question: the input question Thought: you should always think about what to do Action: the action to take, one of [{tool_names}] Action Input: the input to the action Observation: the result of the action ← 框架注入，非模型生成 ... (repeat N times) Thought: I now know the final answer Final Answer: the final answer

实现伪代码

def react_loop(question, tools, llm, max_iter=10): messages = [system_prompt(tools), user_msg(question)] for i in range(max_iter): response = llm.generate(messages) if "Final Answer:" in response: return extract_answer(response) action, input = parse_action(response) # 解析工具调用 observation = tools[action].execute(input) # 执行工具 messages.append(f"{response}\nObservation: {observation}") return "Max iterations reached"

ReAct 的 5 种失败模式

失败模式	表现	缓解策略
无限循环	重复相同的 Action/Observation	重复检测 + 步数上限 + 概率性放弃
幻觉工具	调用不存在的工具名	约束解码、严格解析、tool_choice
上下文溢出	长链条耗尽 context window	历史步骤摘要化、滑动窗口
选错工具	持续用错误的工具	改进工具描述、few-shot 示例
误读结果	忽略或曲解 Observation	结果格式化、关键信息高亮

Yao et al. 2022 论文 · Prompt Guide · Mercity 完整指南

Plan-and-Execute — 规划执行分离

用户目标 ──→ [PLANNER 强模型] ──→ Plan: [Step1, Step2, Step3...] │ ┌──────▼──────┐ ┌────→│ EXECUTOR │ (弱模型/便宜模型) │ │ 执行单步+工具 │ │ └──────┬──────┘ │ 结果 + 状态 │ ┌──────▼──────┐ │ │ REPLANNER │ 需要时重规划 └─────│ 评估→继续/调整│ └─────────────┘

成本优化

Planner 用 Claude Opus / GPT-4（调用 1 次），Executor 用 Haiku / GPT-4o-mini（调用 N 次）。可降低 ~90% 成本。

ReWOO 变体

一次性生成全计划 + 变量替换：#E1 = Search["X"], #E2 = Calc[#E1+Y]。避免 ReAct 的重复 token 开销。5x token 效率。

LangGraph Tutorial · ReWOO Paper · Plan-and-Act 2025

Reflexion — 从失败中学习

传统 RL 用数值奖励+梯度更新。Reflexion 用自然语言反思 + 上下文学习（不改权重）。

Trial 1: Actor 尝试 → Evaluator: 失败 → Self-Reflection: "我犯了 X 错误，因为 Y" → 存入长期记忆 Trial 2: Actor 再试 (带反思记忆) → Evaluator: 失败 → Self-Reflection: "X 修好了但 Z 又错了" → 追加记忆 Trial 3: Actor 再试 (带所有反思) → Evaluator: 通过 → 返回结果

2025.12 MAR（Multi-Agent Reflexion）用不同 Agent 分别负责执行、评估、反思，打破单 Agent 的确认偏差。

Reflexion Paper (NeurIPS 2023) · MAR 2025

LATS — 蒙特卡洛树搜索

Language Agent Tree Search（ICML 2024）。将 MCTS 的 Selection → Expansion → Simulation → Backpropagation 应用于 LLM Agent 决策。

LATS vs ToT

	ToT	LATS
评估	一次性打分	MCTS 迭代统计
搜索	BFS/DFS	UCB1 引导
学习	无	反向传播更新节点值
反思	无	失败后生成反思
外部反馈	通常无	整合环境奖励

UCB1 公式

UCB1(node) = avg_reward(node) + C × √(ln(parent_visits) / node_visits) exploitation: 倾向高奖励节点 exploration: 倾向访问少的节点 C: 探索常数，平衡两者

LATS Paper (ICML 2024) · LangGraph LATS

记忆机制深度解析

从 context window 到自主遗忘，Agent 记忆的完整知识体系。

记忆架构总览

┌─────────────────────────────────────────────────────────────┐ │ Agent 记忆系统 │ │ │ │ ┌─────────────┐ ┌──────────────────────────────────┐ │ │ │ 短期记忆 │ │ 长期记忆 │ │ │ │ Context │ │ ┌──────────┐ ┌──────────┐ │ │ │ │ Window │ │ │ 语义记忆 │ │ 情景记忆 │ │ │ │ │ (4K-200K │ │ │ Semantic │ │ Episodic │ │ │ │ │ tokens) │ │ │ 知识/事实│ │ 经历/事件│ │ │ │ │ │ │ └──────────┘ └──────────┘ │ │ │ │ 会话结束消失 │ │ ┌──────────┐ │ │ │ └──────┬───────┘ │ │ 程序记忆 │ 向量 DB / 图 DB │ │ │ │ 提取 │ │Procedural│ 持久化存储 │ │ │ └───────────→│ │ 技能/流程│ │ │ │ │ └──────────┘ │ │ │ └──────────────────────────────────┘ │ │ │ │ ┌──────────────────────────────────────────────────────┐ │ │ │ 记忆管理层：生成 → 存储 → 检索 → 整合 → 更新 → 遗忘 │ │ │ └──────────────────────────────────────────────────────┘ │ └─────────────────────────────────────────────────────────────┘

短期记忆：Context Window

短期记忆 = LLM 的上下文窗口。模型通过 Self-Attention 机制访问窗口内的所有 token。

工作原理

每个 token 与窗口内所有其他 token 计算注意力权重
复杂度 O(n²)，限制了窗口大小
对话历史、系统提示、工具结果都占用 token 配额
窗口满了 → 早期内容被截断或压缩

上下文管理策略

滑动窗口：保留最近 N 轮对话
摘要压缩：用 LLM 将旧对话压缩为摘要
选择性保留：只保留重要信息（系统提示 + 最近轮 + 工具结果）
Compaction：接近上限时自动触发压缩，注入关键上下文恢复

长期记忆三类型

语义记忆 Semantic

是什么：通用知识和事实。"法国首都是巴黎"、"React 18 引入了并发模式"。

实现：向量嵌入 + RAG 检索。文档被切块、编码为向量、存入向量数据库。查询时通过余弦相似度找到最相关的块。

类比：百科全书。不记得何时何地学到的，但知道这个知识。

情景记忆 Episodic

是什么：具体经历和事件。"上周五用户调试时遇到了语法错误"、"上次部署失败是因为环境变量未设置"。

实现：时序数据库 / 带时间戳的存储。记录 (状态, 行动, 结果) 轨迹。查询时结合时间感知和语义相似度。

类比：日记。记得发生了什么、什么时候、结果如何。

程序记忆 Procedural

是什么：学到的技能和行为模式。"部署到生产环境的 5 步流程"、"处理 CORS 错误的标准方法"。

实现：技能库 / 示例库。Agent 从成功经验中提取可复用的操作序列。2025 LEGOMem：模块化程序记忆系统。

类比：肌肉记忆。不需要刻意思考就能执行的技能。

MLMastery · 3 Types · IBM · AI Agent Memory · Memory in the Age of AI Agents (Survey)

RAG 完整管线

文档

→

分块
Chunking

→

嵌入
Embedding

→

索引
VectorDB

→

检索
Retrieval

→

重排序
Reranking

→

生成
LLM

分块策略 (Chunking)

策略	方法	适用
固定大小	每 512 tokens 切一块，50-100 token 重叠	简单通用
递归字符	按 \n\n → \n → . → 空格层级切割	结构化文本
语义分块	按嵌入相似度断句，相似度骤降处切割	语义连贯性要求高
父子块	大块索引 + 小块检索，返回时用大块上下文	上下文丢失严重场景
Contextual（Anthropic）	用 LLM 为每块前置生成上下文说明	检索错误率降低 49%

检索与重排序

检索模式

Dense（向量）：语义相似度，擅长模糊匹配
Sparse（BM25）：关键词精确匹配
Hybrid：两者结合，倒数排名融合（RRF）
GraphRAG：知识图谱 + 向量搜索，精度可达 99%

重排序模型

Cross-Encoder（Cohere Rerank, BGE）：query+doc 联合编码，精度最高但慢
ColBERT（Late Interaction）：token 级 MaxSim 匹配，doc 可预计算，快
LLM Reranker（RankGPT）：用 LLM 做 listwise 排序

高级 RAG 技术

技术	原理	效果
Query Rewriting	用 LLM 改写用户查询，加入领域术语	提高召回率
HyDE	先生成假设答案，用假设答案的嵌入去检索	解决 query-doc 语义鸿沟
Multi-hop	RQ-RAG 分解为子查询，RAG-Fusion 合并多查询结果	复杂推理问题
Contextual Retrieval	Anthropic：为每块前置上下文 + Contextual BM25	检索错误率 -49%
Adaptive Retrieval	Agent 自主决定何时检索、检索什么（Agentic RAG）	减少无用检索

Anthropic Contextual Retrieval · kapa.ai RAG 2026

RAG 的四代演进

代	名称	特点	时间
v1	Naive RAG	嵌入 → 检索 → 拼接 → 生成	2023
v2	Advanced RAG	+ 查询改写、重排序、块优化	2024
v3	Agentic RAG	Agent 自主决定何时/如何检索 + 验证结果	2025
v4	Contextual Memory	超越检索：时序感知 + 状态追踪 + 多 Agent 共享	2026

记忆巩固与遗忘

MemoryBank 遗忘曲线

受艾宾浩斯遗忘曲线启发（R = e^-t/S），引入记忆衰减函数：

频繁访问的记忆 → 自动强化（S 增大）
未访问的记忆 → 自然衰减
低于阈值 → 被清除

系统形成反映实际效用的记忆画像，而非按时间堆积。

记忆管理 6 操作

生成 — 从对话中识别值得保存的信息
存储 — 编码并持久化（向量/图/关系型）
检索 — 语义搜索 + 时间权重
整合 — 新信息与已有记忆合并
更新 — 矛盾信息覆盖旧记忆
遗忘 — 衰减 + 阈值清除

生产级记忆实现

Mem0

智能记忆层，自动从对话中提取、存储、检索记忆。支持用户级/会话级/Agent级隔离。开源 + 云服务。

LangGraph + MongoDB

Checkpointer（短期）+ Store（长期）双层架构。TTL 自动遗忘。支持时间旅行和回滚。

AWS AgentCore Memory

全托管服务。提取 20-40s，检索 200ms。支持多策略并行处理。分层命名空间 + 加密存储。

Mem0 Paper · MongoDB + LangGraph · AWS AgentCore · A-Mem (arXiv)

2026 行业信号：VentureBeat 预测 "RAG is being surpassed by contextual memory for agentic AI"。传统 RAG 适合静态知识检索；Agent 场景需要具备时序感知、状态追踪、多 Agent 共享的记忆系统。

工具调用与通信协议

从 Function Calling 到 MCP/A2A — Agent 如何与世界交互。

Function Calling 机制

工作流程

Client 发送
messages + tools

→

LLM 返回
tool_calls [{name, args}]

→

Client 执行
真实 API/函数

→

Client 发送
tool results

→

LLM 生成
最终回答

tool_choice 控制

值	行为	场景
`"auto"`	模型自行决定是否调用工具	默认模式
`"required"`	必须调用至少一个工具	强制工具使用
`"none"`	禁止调用工具	纯推理
`{name: "X"}`	必须调用指定工具	定向路由

Parallel Tool Calls

模型可在单轮返回多个 tool_calls，Client 并行执行后一次性返回所有结果。设 parallel_tool_calls: false 可强制顺序执行。

MCP — Model Context Protocol

类比：MCP 是 Agent 世界的 USB-C。一个标准接口，连接任意工具和数据源。

架构

┌──────────┐ MCP Client ┌──────────────┐ │ LLM │◄──── (Host App) ────►│ MCP Server │ │ 应用 │ JSON-RPC 2.0 │ (工具提供者) │ └──────────┘ └──────────────┘ Transport: • stdio (本地进程) • Streamable HTTP (远程 + SSE 流式)

核心原语（Primitives）

Resources

数据暴露。文件、数据库记录、API 响应——通过 URI 标识。

Tools

可执行操作。JSON Schema 定义参数。支持 readOnly/destructive 注解。

Prompts

预定义提示模板。Server 可提供特定场景的提示词。

Sampling

Server 可请求 Client 做 LLM 推理。支持嵌套工具调用。

2025-11-25 规范更新

新特性	说明
Tasks（实验性）	持久状态机：working → input_required → completed/failed/cancelled。支持异步轮询。
Tool Annotations	工具可声明 readOnly / destructive 属性，UI 可据此做权限控制。
Structured Output	工具可定义 outputSchema，Server 自动校验返回值。
Sampling with Tools	MCP Server 可发起带工具定义的 sampling 请求，实现 server-side agent loops。
OAuth 2.1	标准化认证流程。

生态数据

2024.11 Anthropic 发布开放标准
2025.03 OpenAI 采用（Agents SDK, Responses API, ChatGPT Desktop）
2025.04 Google Gemini 支持
2025 GitHub 上 17,000+ MCP 服务器
2025.12 捐赠给 Linux 基金会 (AAIF)

MCP 规范 · 2025-11-25 更新解读 · A Year of MCP

A2A — Agent-to-Agent Protocol

类比：A2A 是 Agent 世界的 HTTP。不同 Agent 之间的标准通信语言。

核心概念

Agent Card：JSON 描述 Agent 能力（类似 API 文档）
Task：状态机 submitted → working → input_required → completed/failed
Message / Part：结构化消息，支持文本/文件/表单

基于 HTTP + JSON-RPC，支持多轮、有状态、流式交互。

协议对比

	MCP	A2A
方向	Agent ↔ 工具（纵向）	Agent ↔ Agent（横向）
发起者	Anthropic	Google
定位	工具集成标准	智能体协作标准
状态	事实标准	100+ 公司参与

ACP — Agent Communication Protocol

IBM Research 开源，RESTful + SSE。已与 A2A 合并（Linux 基金会），ACP 团队转入 A2A 贡献。关键特点：async-first、session continuity、结构化消息信封。

ACP 官网 · IBM · ACP · 四协议全景解析

Skill 系统 — 可组合的 Agent 能力

核心区别：Tool 是原子操作（读文件、调 API、执行命令），Skill 是编排流程（搜索 → 分析 → 生成 PPT）。
Tool 是螺丝刀，Skill 是"组装一把椅子的完整流程"。Agent 使用 Skill，Skill 编排 Tool。

三层架构：Agent → Skill → Tool

┌──────────────────────────────────────────────────────┐ │ Agent (决策者) │ │ 系统提示 + 推理循环 (ReAct) + 记忆 + 状态管理 │ │ │ │ ┌─────────────────────────────────────────────────┐ │ │ │ Skill (编排层) │ │ │ │ │ │ │ │ /commit = git diff → 生成 message → add → │ │ │ │ commit → verify status │ │ │ │ /ppt = web_search → outline → chart → │ │ │ │ layout → theme → export .pptx │ │ │ │ /review = fetch PR → 逐文件分析 → 批量评论 │ │ │ │ │ │ │ │ ┌───────────────────────────────────────────┐ │ │ │ │ │ Tool (原子操作) │ │ │ │ │ │ file_read · web_search · shell_exec │ │ │ │ │ │ git_diff · ppt_generate · api_call │ │ │ │ │ │ mermaid_export · image_gen · sql_query │ │ │ │ │ └───────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────┘ │ └──────────────┬────────────────────┬──────────────────┘ │ MCP Protocol │ ┌─────────▼──┐ ┌──────────▼──┐ ┌────────────┐ │ MCP Server │ │ MCP Server │ │ MCP Server │ │ GitHub │ │ Figma │ │ Slack │ └────────────┘ └─────────────┘ └────────────┘

Tool vs Skill vs Agent 对比

维度	Tool（工具）	Skill（技能）	Agent（智能体）
定义	可执行函数，有明确输入/输出/副作用	知识包 + 编排流程，告诉 Agent 怎么做	完整决策实体，有推理循环和记忆
粒度	原子操作（单步）	多步工作流（串联多个 Tool）	目标驱动的完整系统
格式	JSON Schema（MCP / Function Calling）	SKILL.md + YAML 前置元数据	应用程序（代码 + 配置 + 模型）
加载方式	MCP 协议自动发现	渐进式披露（3 级加载）	常驻运行
状态	无状态（每次调用独立）	无状态（但引导有状态流程）	有状态（维护上下文和记忆）
示例	`file_read()`, `web_search()`	`/commit`, `/ppt`, `/review-pr`	Claude Code, Devin, Cursor

Skill 渐进式披露（Progressive Disclosure）

Skill 不会一次性加载所有内容，而是按需逐级展开，避免 context window 膨胀：

Level 1 · 启动时加载 ─── 仅技能名 + 一行描述（轻量索引） → Agent 知道有哪些技能可用 Level 2 · 任务匹配时 ─── 加载完整 SKILL.md 指令（几百行） → Agent 获得该技能的详细操作指南 Level 3 · 深度执行时 ─── 拉取脚本、模板、参考文件 → Agent 获得执行所需的一切上下文

这意味着你可以注册几十甚至上百个 Skill，Agent 只在需要时才加载具体内容。

Skill 组合模式

顺序管线 Sequential

A → B → C，前一步输出作为后一步输入。

# /commit skill 的顺序管线 git_diff() → staged changes → llm_generate(changes → commit_msg) → git_add(files) → git_commit(msg) → git_status() → verify

并行分支 Parallel

多步同时执行，汇总结果。

# /research skill 的并行分支 ┌→ web_search("topic A") ──┐ ├→ web_search("topic B") ──┤ → merge └→ web_search("topic C") ──┘ → synthesize

条件路由 Conditional

根据中间结果选择不同路径。

# 根据置信度路由 result = analyze(input) if result.confidence < 0.7: → escalate_to_human() else: → auto_execute(result)

嵌套组合 Nested

Skill 内部调用其他 Skill。

# /deploy 调用子 skill /deploy: → /test() # 子 skill → /build() # 子 skill → /push(prod) # 子 skill → /notify(team) # 子 skill

Skill 学习与进化

Voyager ICML 2023

Minecraft 中的终身学习 Agent。自动生成可复用代码技能并存入技能库。成功的程序被向量化索引，遇到相似场景时检索复用。获取独特物品数量提高 3.3x，解锁速度快 15.3x。

Voyager 论文

LEGOMem 2025

模块化程序记忆。将成功执行的轨迹分解为可复用的记忆单元：全任务记忆（规划级）+ 子任务记忆（工具交互级）。小模型 + LEGOMem 可追平大模型无记忆的表现。

LEGOMem 论文

ReMe 2025.12

动态程序记忆框架。三大机制：多维蒸馏（成功模式 + 失败原因 + 对比洞察）、上下文自适应复用、效用驱动修剪。Qwen3-8B + ReMe 超过无记忆的 Qwen3-14B。

ReMe 论文

实际产品中的 Skill 系统

产品	Skill 示例	技术实现
Claude Code	/commit · /review-pr · /ppt · 自定义 Skill	SKILL.md + YAML 前置 + 渐进式披露。2026 已有 Skill 市场，25+ 注册中心。
Cursor	代码生成 · 子代理(subagents) · 图片生成	v2.4 (2026.01) 引入 Skills 和并行子代理。90%+ Salesforce 开发者使用。
Windsurf	Cascade 多步推理 · 规则手册(Rulebooks)	.windsurf/skills/ 目录。规划代理 + 执行模型分离。
Devin	端到端编码 · 迁移 · 修漏洞 · 写测试	自主 Agent，适合 4-8 小时的初级工程师任务。SWE-bench 13.86%（前 SOTA 1.96%）。
Aider	多文件编辑 · 架构模式 · 语音编程	自动 git commit + 代码地图 + 会话持久化。

MCP 生态系统与集成模式

MCP Server 生态规模

截至 2026 年 2 月，MCP 生态已有 17,000+ 公开 Server，SDK 月下载量 9700 万+。所有主要 AI 厂商（Anthropic、OpenAI、Google、Microsoft）均已采用。

Server 分类全景

类别	典型 Server	提供能力
文件系统	filesystem	安全的文件读写、目录操作，可配置访问权限
代码与版本控制	GitHub, GitLab	PR/Issue 操作、代码搜索、分支管理、CI/CD
数据库	PostgreSQL, SQLite, MariaDB	SQL 执行、Schema 发现、向量搜索
设计工具	Figma, Pencil	设计稿读取、组件提取、像素级还原
通信协作	Slack, Discord, Email	消息发送、频道管理、通知推送
搜索与爬虫	Exa, Firecrawl, Brave	网页搜索、内容抓取、结构化提取
云平台	Azure, AWS, Cloudflare	云资源管理、部署、监控
知识管理	Notion, Confluence, Memory	文档 CRUD、知识图谱、持久记忆
商业集成	Knit (10,000+ 连接器)	CRM、ERP、HRIS、支付、日历
向量数据库	Qdrant, Pinecone	语义搜索、RAG 检索、记忆存储

MCP Gateway 模式

┌──────────────┐ │ MCP Gateway │ 集中管理层 │ ┌──────────┐ │ Agent ──JSON-RPC──→ │ │ 认证授权 │ │ │ │ 速率限制 │ │ │ │ 使用监控 │ │ │ │ 路由分发 │ │ │ └──────────┘ │ └──┬──┬──┬──┬──┘ │ │ │ │ ┌────────┐ ┌─▼┐┌▼─┐┌─▼┐ ┌────────┐ │GitHub │ │DB││FS││API│ │Slack │ │Server │ │ ││ ││ │ │Server │ └────────┘ └──┘└──┘└───┘ └────────┘

MCP Gateway 是企业级部署的关键模式：Agent 不直接连几十个 Server，而是通过统一网关访问。网关负责认证、限流、审计和路由。

MCP 与 Skill 如何协同

MCP 提供原子能力

每个 MCP Server 暴露一组 Tool（如 GitHub Server 提供 create_pr、list_issues 等）。这些是 Agent 可调用的最小操作单元。

Skill 编排 MCP 工具

Skill 将多个 MCP Tool 编排成完整工作流。如 /review-pr Skill 调用 GitHub MCP 的 get_pr_files → 逐文件分析 → create_review_comment。

协议栈全景：四层互补

层级	协议	功能	类比
工具集成	MCP	Agent ↔ 系统：连接工具、数据库、API	USB-C 接口
能力编排	Skill	组合 Tool 为可复用工作流	应用程序
Agent 通信	A2A	Agent ↔ Agent：跨厂商企业协作	HTTP 协议
网络发现	ANP	互联网级去中心化 Agent 网络	DNS 系统

Arcade · Skills vs Tools · Claude Skills 文档 · DSd · Agent Skills · SKILL.md 规范 · Voyager · MCP Server 索引

多智能体系统深度解析

协作模式详解、通信机制、编排调度、框架代码实战、反模式。

6 种协作模式详解

1. Supervisor / Worker — 集中调度

最广泛的生产模式。一个主 Agent（Supervisor）负责任务分解、分派、质量审核；多个工作 Agent（Worker）负责专项执行。

┌──────────────┐ │ Supervisor │ 规划 · 分派 · 审核 │ (强模型) │ └──┬──┬──┬──┬─┘ │ │ │ │ ┌──────▼┐┌▼──▼┐┌▼──────┐ │Worker ││Work││Worker │ │搜索 ││分析││写作 │ │(弱模型)││ ││ │ └───┬───┘└─┬──┘└──┬────┘ │ │ │ └──────▼──────┘ 结果汇总给 Supervisor → 审核通过 → 返回用户 → 审核失败 → 重新分派

优势

清晰的权责分离，Supervisor 控制全局质量
Worker 可以使用更便宜/快速的模型
任务分派策略可灵活调整（轮询/能力匹配/负载均衡）
支持动态扩缩 Worker 数量

风险与缓解

单点故障 — Supervisor 挂掉全停 → 添加 Supervisor 健康检查 + 备用 Supervisor
瓶颈 — 所有结果经 Supervisor → 并行审核 / 自动批准低风险任务
Worker 失败 — 引入断路器模式（Circuit Breaker）：3 次失败后跳过该 Worker，降级处理

# LangGraph Supervisor 模式伪代码 from langgraph.graph import StateGraph def supervisor(state): # 决定下一步由哪个 Worker 处理 plan = llm.invoke("Decide which worker to call next", state) return {"next": plan.worker, "task": plan.subtask} def researcher(state): result = llm.invoke("Research: " + state["task"], tools=[web_search]) return {"research_result": result} def writer(state): result = llm.invoke("Write based on: " + state["research_result"]) return {"draft": result} graph = StateGraph(State) graph.add_node("supervisor", supervisor) graph.add_node("researcher", researcher) graph.add_node("writer", writer) graph.add_conditional_edges("supervisor", route_to_worker) graph.add_edge("researcher", "supervisor") # 结果返回 Supervisor graph.add_edge("writer", "supervisor")

LangGraph Supervisor Tutorial

2. Pipeline / Assembly Line — 流水线

Agent 按固定顺序串联，每个 Agent 的输出是下一个的输入。类似 Unix 管道或工厂流水线。

┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ Agent A │───→│ Agent B │───→│ Agent C │───→│ Agent D │ │ 产品经理 │ │ 架构师 │ │ 工程师 │ │ 测试 │ │ 需求文档 │ │ 架构设计│ │ 代码实现│ │ 测试+修复│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ PRD ──→ 系统设计 ──→ 代码 ──→ 测试报告

MetaGPT 是 Pipeline 模式的经典实现：PM → Architect → Engineer → QA，每个 Agent 输出标准化文档作为下一步输入。

优势

流程清晰、易于调试（每步独立可测试）
每个 Agent 高度专业化
适合有明确阶段的任务（ETL、内容创作、CI/CD）

风险

错误传播 — 上游错误放大到下游 → 每步添加质量门控
无法并行 — 前后有依赖 → 拆分为可并行的子流水线
反馈困难 — 下游发现上游错误需回退 → 添加反馈回路

# CrewAI Sequential 流水线 from crewai import Agent, Task, Crew, Process researcher = Agent(role="研究员", goal="收集最新数据", tools=[web_search], llm="gpt-4o-mini") analyst = Agent(role="分析师", goal="深度分析数据") writer = Agent(role="写手", goal="撰写报告") tasks = [ Task(description="搜索 AI Agent 最新趋势", agent=researcher), Task(description="分析趋势并提取洞察", agent=analyst), Task(description="写成 2000 字报告", agent=writer), ] crew = Crew(agents=[researcher, analyst, writer], tasks=tasks, process=Process.sequential) result = crew.kickoff()

3. Hierarchical — 多层级管理

多级 Supervisor 树状结构。每层处理不同抽象级别的任务。

┌───────────┐ │ CEO Agent │ 战略决策 └──┬─────┬──┘ ┌────────▼┐ ┌▼────────┐ │PM Agent │ │CTO Agent│ 部门级规划 └──┬───┬──┘ └──┬───┬──┘ ┌─────▼┐ ┌▼───┐ ┌──▼┐ ┌▼────┐ │设计 │ │文案│ │前端│ │后端 │ 执行 └──────┘ └────┘ └───┘ └─────┘

适用场景

复杂企业流程（多部门协作）
大型软件开发（需要架构→模块→函数多级分解）
内容工厂（策划→创作→审核→分发）

CrewAI Hierarchical

crew = Crew( agents=[researcher, analyst, writer], tasks=tasks, process=Process.hierarchical, manager_llm="gpt-4o" # 自动创建管理者 ) # manager 自动分派任务、审核结果

4. Debate / Adversarial — 辩论对抗

多个 Agent 针对同一问题提出不同立场，互相批评论证，最终由裁判（Agent 或人类）综合判断。

┌────────────┐ 论点A ┌───────────┐ 论点B ┌────────────┐ │ Proposer A │ ─────────→ │ Judge │ ←───────── │ Proposer B │ │ (正方) │ ←反驳B──── │ (裁判) │ ────反驳A→ │ (反方) │ └────────────┘ └─────┬─────┘ └────────────┘ │ 最终裁决 (综合两方论点) │ ┌─────▼─────┐ │ 输出 │ │ (质量更高) │ └───────────┘

为什么辩论有效

暴露单 Agent 的确认偏差（倾向验证自己的答案）
数学推理准确率提升 15-40%（Du et al. 2023）
异构 Agent（不同模型/提示）比同构效果更好
MAR（Multi-Agent Reflexion）用不同 Agent 分别负责执行、评估、反思

实际应用

事实核查 — Agent 提出断言，另一 Agent 质疑证据
代码审查 — 提交者 vs 审查者对抗
法律分析 — 正反方论证 + 法官裁决
需求分析 — 功能派 vs 安全派 vs 成本派

5. Blackboard — 共享黑板

源自 Hayes-Roth (1985)，2025 论文证明在 LLM 场景比主从模式高 13-57%。

Agent A (规划) Agent B (搜索) Agent C (推理) │ │ │ ▼ ▼ ▼ ╔════════════════════════════════════════════════╗ ║ BLACKBOARD (共享知识库) ║ ║ ┌──────────┐ ┌──────────┐ ┌──────────────┐ ║ ║ │ 公共空间 │ │ 中间结果 │ │ 约束 & 目标 │ ║ ║ │ 对话历史 │ │ 部分解 │ │ 当前状态 │ ║ ║ └──────────┘ └──────────┘ └──────────────┘ ║ ╚════════════════════════════════════════════════╝ ▲ ┌────┴────┐ │Control │ 选择下一个行动的 Agent │Unit │ 基于黑板状态决策 └─────────┘

核心特点

Agent 之间不直接通信，只读写黑板
松耦合 — 可随时添加/移除 Agent
异步协作 — Agent 在黑板状态匹配时自主触发
特别适合答案逐步积累的复杂问题

vs 消息传递

	Blackboard	消息传递
耦合	松耦合（不需要知道其他 Agent）	需知道通信对象
通信	间接（通过共享空间）	直接（DM / 广播）
控制	机会主义（状态驱动）	显式路由
瓶颈	黑板竞争	N^2 连接

Blackboard MAS 论文 2025 · LLM Blackboard System

6. Peer-to-Peer — 对等协作

无中心控制，所有 Agent 地位平等，直接互相沟通。适合探索性任务和创意发散。

优势

高容错 — 无单点故障
自然的涌现行为（Emergent Behavior）
适合开放式问题（没有预设正确答案）

风险

O(n²) 通信开销 → 限制团队规模
难以保证收敛 → 设定终止条件
可能出现"回声室"效应 → 引入异构 Agent

Agent Team — 生产级团队协作

学术界讲"Multi-Agent System"，工程界讲 Agent Team。Team 不只是多个 Agent 一起跑，而是一套完整的组建 → 分工 → 通信 → 协同 → 解散的管理体系。

Multi-Agent vs Agent Team: Multi-Agent 关注"怎么合作"（通信拓扑、编排策略）。Agent Team 关注"怎么管理"（团队组建、任务分派、生命周期、资源回收）。前者是计算机科学，后者是软件工程。

Agent Team 核心架构

┌──────────────────────────────┐ │ Team Config │ │ team_name · members · roles │ └──────────────┬───────────────┘ │ ┌───────────────────────┼────────────────────────┐ │ │ │ ┌────▼─────┐ ┌──────▼──────┐ ┌──────▼──────┐ │Team Lead │◄────────►│ Shared │◄────────►│ Message │ │(Orchestr)│ │ TaskList │ │ Bus (DM / │ │ │ │ │ │ Broadcast) │ └────┬─────┘ │ ┌─────────┐ │ └──────┬──────┘ │ │ │ Task #1 │ │ │ ┌────┼────┐ │ │ Task #2 │ │ ┌─────┼─────┐ │ │ │ │ │ Task #3 │ │ │ │ │ ┌─▼┐ ┌▼─┐ ┌▼─┐ │ └─────────┘ │ ┌─▼┐ ┌▼─┐ ┌▼─┐ │A │ │B │ │C │ └─────────────┘ │A │ │B │ │C │ │ │ │ │ │ │ Teammates │ │ │ │ │ │ └──┘ └──┘ └──┘ (idle ⇄ active) └──┘ └──┘ └──┘

Team 生命周期

创建团队 → 创建任务 → 生成 Teammates → 分派任务 → 协作执行 → 完成 → 解散 │ │ │ │ │ │ │ │ TeamCreate │ TaskCreate │ Task(spawn) │ TaskUpdate │ 送/收消息│ shutdown│ TeamDelete │ │ │ ↓ │ (owner) │ SendMsg │ request │ │ │ │ 每个 teammate│ │ │ → resp │ │ │ │ 独立进程/线程 │ │ │ │ ▼ ▼ ▼ ▼ ▼ ▼ ▼ team.json tasks/ config.json 认领 or DM 或广播标记完成清理资源 members[] 指派

OpenAI Swarm — Handoff 模式

OpenAI Swarm 提出了极简的 Agent Team 原语：Handoff（移交）。Agent 不"调用"另一个 Agent，而是将对话控制权整个移交过去。

# OpenAI Swarm: Agent 间通过 Handoff 传递控制权 from swarm import Swarm, Agent def transfer_to_refund(): """用户要求退款时，移交给退款 Agent""" return refund_agent triage_agent = Agent( name="Triage", instructions="判断用户意图，路由到合适的 Agent", functions=[transfer_to_refund, transfer_to_sales] ) refund_agent = Agent( name="Refund", instructions="处理退款请求", functions=[process_refund] ) client = Swarm() response = client.run(agent=triage_agent, messages=[{"role": "user", "content": "我要退款"}]) # triage_agent → 识别退款意图 → handoff → refund_agent 接管

核心思想：每个 Agent 只做自己擅长的事，不擅长的通过 Handoff 移交。不需要中央调度器，Agent 自己决定何时移交、移交给谁。

生产级 Team 示例

产品	Team 架构	通信方式	调度策略
Claude Code	Team Lead + Teammates（Task 工具生成子代理）	SendMessage DM/广播 + 共享 TaskList	Team Lead 分派 + Teammate 自主认领
Devin	Planner + Executor + Verifier	内部状态机 + 共享 Workspace	Planner 分解 → Executor 串行
Cursor Background	多个独立 Agent 并行处理不同文件	共享 git 仓库 + 冲突检测	并行独立任务，串行冲突文件
MetaGPT	PM → Architect → Engineer → QA	SOPs 标准化文档传递	固定流水线 + 文档驱动
ChatDev	CEO → CTO → Programmer → Reviewer → Tester	角色间对话	瀑布式 + 代码审查循环

Team 设计的 5 个关键决策

1. 团队规模

2-3 Agent：简单任务，通信开销低
4-6 Agent：复杂任务，需要专业分工
7+ Agent：需要层级管理，否则通信爆炸

经验法则：Agent 数 = 独立子任务数，不是越多越好。

2. 同构 vs 异构

同构：所有 Agent 相同模型/提示 → 适合并行加速（如并发搜索）
异构：不同模型/角色/温度 → 适合需要多样性的任务（如辩论、审查）
混合：强模型做 Lead + 弱模型做 Worker → 成本最优

3. Idle 管理

Teammate 完成当前任务后进入 idle 状态（等待下一个指令）。Idle ≠ 退出。Lead 需要区分"等待中"和"已完成"，及时分派新任务或发送 shutdown。

4. 失败处理

Teammate 失败 → 不标记完成，创建新 Task 描述阻塞原因。Lead 可以：重试、换 Agent、降级处理、上报用户。

5. 优雅关闭：所有任务完成后，Lead 逐一发送 shutdown_request，Teammate 确认后退出。最后 Lead 删除 Team 资源。永远不要直接 kill Teammate——可能丢失未保存的工作。

OpenAI Swarm · Claude Code Teams · MetaGPT · ChatDev · Devin

通信机制

多 Agent 之间如何传递信息，是系统架构的核心决策。

消息传递 Message Passing

直接消息 (DM)：A → B 一对一通信
广播 (Broadcast)：A → 全体
频道 (Pub/Sub)：Agent 订阅 topic，按兴趣接收

适用：明确的通信拓扑，需要精确控制消息流向

共享状态 Shared State

共享向量库：多 Agent 读写同一 VectorDB
共享知识图谱：GraphRAG 多 Agent 协作
任务看板：共享 TaskList + 认领机制

适用：信息逐步积累，Agent 需要全局视图

事件驱动 Event-Driven

Redis Streams：亚毫秒延迟，适合实时场景
Kafka：持久化、回放、高吞吐，适合企业级
SSE/WebSocket：Agent 实时推送状态变化

适用：大规模、持久化、需要回放和审计

多 Agent 记忆与状态管理

私有 vs 共享记忆

Agent A 私有记忆共享记忆 Agent B 私有记忆 ┌──────────────┐ ┌─────────────────┐ ┌──────────────┐ │ 搜索历史 │ │ 项目知识库 │ │ 分析模型 │ │ 个人偏好 │ │ 共享事实 │ │ 个人经验 │ │ 工作中间态 │ │ 团队决策 │ │ 草稿版本 │ └──────────────┘ │ 任务进度 │ └──────────────┘ └─────────────────┘

原则：Agent 特有的推理过程、中间状态 → 私有。跨 Agent 的事实、决策、进度 → 共享。

一致性问题

矛盾记忆 — Agent A 说"用户偏好 X"，Agent B 说"用户偏好 Y" → 需要冲突检测 + 时间戳优先
过期信息 — Agent 使用了已被其他 Agent 更新的旧数据 → 版本号 + 乐观锁
写入竞争 — 多 Agent 同时写同一记忆 → 原子操作 + 队列

编排与调度

静态编排

流程在运行前确定。Pipeline、Crew 的 Sequential 模式。简单可靠，但不灵活。

# 静态: 固定顺序 A → B → C → D (顺序不变)

动态编排

Supervisor 根据运行时状态决定下一步。LangGraph 的条件边、CrewAI 的 Hierarchical 模式。

# 动态: 运行时决策 A → if 需要搜索 → B → elif 需要分析 → C → else → D

DAG 调度 — 拓扑排序 + 并行

任务依赖图 (DAG): 调度执行: A ──→ C ──→ E 时刻 1: A, B 并行 B ──→ C 时刻 2: C (等 A,B 完成) B ──→ D ──→ E 时刻 3: D (等 B 完成) 时刻 4: E (等 C,D 完成) Kahn 拓扑排序: 找入度为 0 的节点 → 并行执行 → 移除 → 重复

DAG 调度的核心价值：自动发现可并行的任务，在保证依赖正确的前提下最大化并行度。

主流框架深度对比 (2026)

维度	LangGraph	CrewAI	AutoGen	Google ADK	OpenAI SDK
架构	有向图	角色团队	对话	事件驱动	极简原语
多 Agent	子图 + 层级	Crew 委派	GroupChat	层级 Agent	Handoffs
状态	Checkpointer 持久化	内置记忆	手动管理	SessionService	最小化
HITL	Interrupt 机制（一流支持）	基础	UserProxy	Via Tools	Guardrails
MCP	通过 Tool 适配	社区插件	社区插件	原生支持	原生支持
A2A	无	无	无	原生支持	无
Token 效率	~2,000/轮	~3,500/轮	~8,000/轮	中等	低
学习曲线	陡峭	平缓	中等	中等	最低

框架代码速览

AutoGen GroupChat

from autogen import AssistantAgent, GroupChat, GroupChatManager coder = AssistantAgent("coder", llm_config=llm_config, system_message="你是一个 Python 程序员") reviewer = AssistantAgent("reviewer", llm_config=llm_config, system_message="你是代码审查员") group_chat = GroupChat( agents=[coder, reviewer], messages=[], max_round=10) manager = GroupChatManager(groupchat=group_chat) coder.initiate_chat(manager, message="实现一个 LRU 缓存")

Google ADK 层级

from google.adk import LlmAgent, SequentialAgent researcher = LlmAgent(name="researcher", model="gemini-2.0-flash", instruction="搜索并总结信息", tools=[google_search]) writer = LlmAgent(name="writer", model="gemini-2.0-flash", instruction="基于搜索结果撰写文章") pipeline = SequentialAgent(name="pipeline", sub_agents=[researcher, writer])

选型建议：需要精细控制 → LangGraph；快速原型 → CrewAI；代码生成 → AutoGen；Google 生态 → ADK；最小依赖 → OpenAI SDK。许多成功系统混用框架。

反模式与失败陷阱

反模式	表现	后果	缓解
无限委派循环	Agent A 把任务给 B，B 又给 A	死循环，token 爆炸	委派深度上限 + 重复检测
上下文污染	Agent 之间传递过多内部推理细节	下游 Agent 被无关信息干扰	Agent 间只传结构化结果，不传思维链
单点瓶颈	Supervisor 处理所有通信和审核	延迟高、成本集中	分层 Supervisor / 自动审批低风险任务
Token 爆炸	多 Agent 对话历史指数增长	成本不可控，AutoGen 尤其严重	摘要压缩、限制轮数、结构化消息
同质化团队	所有 Agent 用相同模型和提示	辩论退化为自言自语	异构 Agent（不同模型/温度/角色）
过度并行	并发 Agent 太多超出 API 限制	Socket Hang Up / 429 限流	并发控制 + 退避重试 + 连接池

2026 框架对比 · Top Frameworks 2026 · Event-Driven MAS · Blackboard MAS · CrewAI Hierarchical · Google ADK

行业演进与趋势

关键里程碑时间线

2022.01

Chain-of-Thought 论文

Wei et al. 发现"让我们一步步想"即可大幅提升推理能力。

2022.10

ReAct 论文发表

Yao et al. 提出 Reasoning+Acting 范式，奠定 Agent 推理基础。

2023.03

AutoGPT / BabyAGI 爆红

自主 Agent 概念验证。Agent 元年开启。

2023.05

ToT / Reflexion 论文

树状搜索和语言强化学习，Agent 推理模式成型。

2024.03

Andrew Ng 四大设计模式

Reflection / Tool Use / Planning / Multi-Agent，形成行业共识。

2024.09

Anthropic Contextual Retrieval

RAG 检索错误率降低 49%，为 Advanced RAG 定调。

2024.10

LATS (ICML 2024)

蒙特卡洛树搜索用于 Agent，统一推理+行动+规划。

2024.11

Anthropic 发布 MCP

Model Context Protocol — Agent ↔ 工具的标准接口。

2025.04

Google 发布 A2A

Agent-to-Agent Protocol — Agent 间通信标准。100+ 公司参与。

2025.10

Google《Agentic Design Patterns》

Antonio Gulli 400 页实战指南，系统化 Agent 设计模式。

2025.11

MCP 2025-11-25 规范

异步 Tasks、OAuth 2.1、Tool Annotations、Structured Output。

2025.12

MCP 捐赠给 Linux 基金会

ACP 与 A2A 合并。协议标准化格局确立。

2026

Agent 商业化深水区

Gartner：40% 企业应用将嵌入 Agent。从实验到生产。

2026 七大趋势

1. 单 Agent → Agent 团队

像微服务取代单体。专业化 Agent 分工协作。

2. 协议标准化

MCP 成工具事实标准，A2A 成 Agent 间通信标准。互操作性成为基线。

3. RAG → Contextual Memory

从检索到记忆。Agent 需要时序感知、状态追踪、自主遗忘的记忆系统。

4. 成本分层

强模型规划 + 弱模型执行。Plan-and-Execute 可降低 ~90% 成本。

5. 安全与可观测性

Agent 行为需可审计、可回滚、有权限控制。Tool Annotations 等机制普及。

6. 人在回路 (HITL)

关键决策人类审批，Agent 执行具体工作。信任逐步建立。

7. Agent 原生应用

不再是"加 AI"，而是从零以 Agent 为核心设计产品。

MLMastery · 7 Trends 2026 · arXiv · Agentic AI Survey 2026 · VentureBeat Predictions

全部参考来源索引

学术论文

论文	作者	年份	链接
Chain-of-Thought Prompting	Wei et al.	2022	arXiv
Self-Consistency Improves CoT	Wang et al.	2022	arXiv
ReAct: Synergizing Reasoning and Acting	Yao et al.	2022	arXiv
Reflexion	Shinn et al.	2023	arXiv
Tree of Thoughts	Yao et al.	2023	arXiv
ReWOO	Xu et al.	2023	arXiv
Voyager: Open-Ended Embodied Agent	Wang et al.	2023	arXiv
Communicative Agents for Software Dev (ChatDev)	Qian et al.	2023	arXiv
MetaGPT: Multi-Agent Collaborative Framework	Hong et al.	2023	arXiv
MemoryBank (AAAI)	Zhong et al.	2024	AAAI
LATS (ICML)	Zhou et al.	2024	arXiv
A-Mem: Agentic Memory	Xu et al.	2025	arXiv
Plan-and-Act	多作者	2025	arXiv
Blackboard Multi-Agent Systems	多作者	2025	arXiv
LEGOMem: Modular Procedural Memory	多作者	2025	arXiv
ReMe: Retrieval-Enhanced Procedural Memory	多作者	2025	arXiv
Memory in the Age of AI Agents	Liu et al.	2025	arXiv
MAR: Multi-Agent Reflexion	多作者	2025	arXiv
Agentic AI: Architectures & Taxonomies	多作者	2026	arXiv

规范与官方文档

来源	链接
MCP 官方规范 (2025-11-25)	modelcontextprotocol.io
A2A 协议指南	完整指南
ACP 官方	agentcommunicationprotocol.dev
LangGraph Tutorials	LangGraph
Andrew Ng · Agentic AI 课程	DeepLearning.AI
Prompt Engineering Guide	promptingguide.ai
OpenAI Swarm	GitHub
MetaGPT	GitHub
ChatDev	GitHub

行业文章

标题	来源	链接
Six Levels of Agentic Behavior	Vellum	link
Agentic AI Maturity Model 2025	DextraLabs	link
7 Agentic AI Trends 2026	MLMastery	link
6 Data Predictions for 2026	VentureBeat	link
Contextual Retrieval	Anthropic	link
A Year of MCP	Pento	link
LangGraph vs CrewAI vs AutoGen 2026	DEV Community	link
3 Types of Long-term Memory	MLMastery	link
AI Agent Memory	IBM	link

Agent 能力成熟度模型 L1 → L7

L1 — LLM：纯文本/多模态理解

业务场景

典型操作

技术要点

L2 — Tools：环境交互

业务场景

典型操作

关键技术

L3 — State：跨轮次状态追踪

业务场景

典型操作

关键技术

L4 — Planning：先规划再执行

业务场景

典型操作

关键技术

L5 — Composition：可复用组合能力

业务场景

典型操作

关键技术

L6 — Collaboration：多代理并行

业务场景

典型操作

关键技术

L7 — Ecosystem：组织级协调 + 外部集成

业务场景

典型操作

关键技术

推理与规划框架

框架全景：复杂度阶梯

Chain-of-Thought (CoT) — 思维链

CoT 的三种形态

Zero-Shot CoT

Few-Shot CoT

Self-Consistency

CoT 效果数据

Tree of Thoughts (ToT) — 思维树

四个模块

BFS vs DFS

剪枝策略

ReAct — 推理 + 行动

核心循环

Prompt 模板

实现伪代码

ReAct 的 5 种失败模式

Plan-and-Execute — 规划执行分离

成本优化

ReWOO 变体

Reflexion — 从失败中学习

LATS — 蒙特卡洛树搜索

LATS vs ToT

UCB1 公式

记忆机制深度解析

记忆架构总览

短期记忆：Context Window

工作原理

上下文管理策略

长期记忆三类型

语义记忆 Semantic

情景记忆 Episodic

程序记忆 Procedural

RAG 完整管线

分块策略 (Chunking)

检索与重排序

检索模式

重排序模型

高级 RAG 技术

RAG 的四代演进

记忆巩固与遗忘

MemoryBank 遗忘曲线

记忆管理 6 操作

生产级记忆实现

Mem0

LangGraph + MongoDB

AWS AgentCore Memory

工具调用与通信协议

Function Calling 机制

工作流程

tool_choice 控制