AI Agent 架构详解：范式、记忆、规划与工具系统

从 LLM 到 Agent

大语言模型本质上是"函数"：输入文本，输出文本。它不会主动做事——不会上网搜索、不会读写文件、不会执行代码。人们发现，只要给 LLM 配上工具、记忆和规划能力，它就能像人类一样完成复杂任务。

这就是 AI Agent（智能体）。

2023 年以来，AutoGPT、LangChain Agent、Claude Code、Cursor Agent 等项目将 Agent 从学术概念推向工程实践。当下最先进的 AI 编程工具，本质都是 Agent 架构的产物。

什么是 Agent

一个完整的 Agent 系统包含四个核心模块：

1
2
3
4
5
6
7
8
9


┌──────────────────────┐
│     规划模块          │  决定做什么、先做什么
├──────────────────────┤
│     记忆系统          │  记住做过什么、知道什么
├──────────────────────┤
│     工具系统          │  能执行什么操作
├──────────────────────┤
│     执行引擎          │  按范式串联上述模块
└──────────────────────┘

用一句话概括：Agent = LLM + 规划 + 记忆 + 工具。

Agent 核心范式

范式（Paradigm）决定了 Agent 的"思考方式"。不同范式在推理深度、执行效率、可靠性上有不同权衡。

ReAct（Reason + Act）

最经典的 Agent 范式，由 Google DeepMind 在 2022 年提出。核心循环：

1

Thought → Action → Observation → Thought → Action → ... → Final Answer

每一步：

Thought（思考）：分析当前状态，决定下一步做什么
Action（行动）：调用工具执行操作
Observation（观察）：获取工具返回结果，进入下一轮思考

以"查询北京天气并给我穿衣建议"为例：

1
2
3
4
5
6


Thought: 需要查询天气，先用天气API
Action: get_weather("北京")
Observation: {"temp": 5, "weather": "阴转小雨", "wind": "4级"}

Thought: 温度5度有小雨和风，应该建议穿厚外套、带伞
Final Answer: 北京今天5°C，阴转小雨，风力4级。建议穿羽绒服或厚大衣，携带雨伞。

ReAct 的优势是推理过程可解释、可追踪。缺点是每一步都需 LLM 推理，复杂任务 token 消耗大、延迟高。

Plan-Act（规划-执行）

先制定完整计划，再逐步执行。适合步骤明确、不需要动态调整的任务。

1

用户需求 → LLM 生成计划（步骤列表） → 逐步执行 → 完成

比如"为我创建一个博客项目"：

1
2
3
4
5
6
7
8


Plan:
1. 创建项目目录结构
2. 初始化 package.json
3. 安装依赖
4. 创建首页组件
5. 添加样式
6. 配置路由
Execute: step 1 → step 2 → ... → step 6

优点是一次性规划降低 LLM 调用次数。缺点是如果中间步骤结果与预期不符，计划可能需要动态调整。

Plan-Execute-Replan（规划-执行-重规划）

对 Plan-Act 的改进——每执行一步后评估是否需要调整剩余计划。

1

Plan → Execute Step 1 → Evaluate → 需要调整？→ Replan → Execute Step 2 → ...

适合"结果不确定"的任务。比如代码生成中某个 API 调用失败，需要换方案继续。

Reason-Observe-Act（推理-观察-行动）

更细粒度的循环，强调推理和观察的分离。典型代表是 Anthropic 的 Claude Agent 模式：

1

User Request → Reason（多步推理） → Observe（检查环境状态） → Act（执行） → 循环

多 Agent 协作范式

复杂任务由多个专门 Agent 分工协作：

1
2
3
4
5


Manager Agent（任务分配）
  ├── Research Agent（信息收集）
  ├── Code Agent（编写代码）
  ├── Review Agent（代码审查）
  └── Test Agent（运行测试）

这是 AutoGen、CrewAI 等项目采用的多 Agent 架构。优势是各 Agent 独立 prompt、独立工具集，协作效率高；挑战是通信开销、一致性问题。

范式对比

范式	特点	适用场景
ReAct	思考-行动循环，灵活可解释	需要动态决策的任务
Plan-Act	先规划再执行	步骤明确的任务
Plan-Execute-Replan	执行中动态调整计划	结果不确定的任务
多 Agent	多个专业 Agent 协作	跨领域的复杂任务

Agent 记忆系统

记忆是 Agent 区别于单次 LLM 调用的关键。没有记忆，Agent 每次对话都是"新手"。

三层记忆架构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


┌──────────────────────────────────────┐
│           工作记忆                    │  当前任务上下文，对话历史
│           (Working Memory)           │  类似人脑的"短期注意力"
├──────────────────────────────────────┤
│           短期记忆                    │  当前会话的历史操作和结果
│           (Short-term Memory)        │  类似"今天做了什么事"
├──────────────────────────────────────┤
│           长期记忆                    │  跨会话持久化的知识和经验
│           (Long-term Memory)         │  类似"学到的技能和经验"
└──────────────────────────────────────┘

工作记忆（Working Memory）

最直接的一层，就是 LLM 的上下文窗口：

当前用户输入
本轮的 thought/action/observation 历史
从长期记忆中检索出的相关信息

工作记忆受限于 LLM 上下文窗口大小。超出窗口后，需做压缩或淘汰。

短期记忆（Short-term Memory）

当前会话中已完成的操作序列，采用滑动窗口管理：

1
2


[Task 1 完成] → [Task 2 完成] → [Task 3 进行中] → ...
                                          ↑ 当前在窗口内

超出窗口的旧任务记录可归档到长期记忆或直接丢弃。

长期记忆（Long-term Memory）

跨会话持久化存储，通常用向量数据库 + RAG 实现：

1
2


存储：记忆内容 → 向量化 → 存入向量库
检索：当前任务 → 向量化 → 相似度搜索 → 返回相关记忆

长期记忆的内容类型：

类型	内容	示例
用户偏好	用户的使用习惯和配置	“用户是 Go 开发者，习惯 Linux 风格”
项目知识	项目结构、框架约定	“项目的鉴权中间件在 auth/ 下”
经验教训	过去的错误和改进	“上次修改这个接口导致测试失败”
操作记录	历史操作摘要	“上个月完成了数据库迁移”

记忆管理的挑战

压缩：如何将冗长的操作历史压缩成精简摘要
遗忘：什么该记住，什么该丢弃
更新：用户偏好变化时如何更新旧记忆
检索精度：在大量记忆中准确找到相关条目

Agent 规划模块

规划模块赋予 Agent"分解问题"和"自我纠错"的能力。

任务分解

将复杂目标拆解为可执行的子任务。常用策略：

链式分解（Chain Decomposition）：

1
2
3
4
5


"部署一个博客网站"

拆解为：
1. 检查服务器环境 → 2. 安装依赖 → 3. 拉取代码 →
4. 构建静态文件 → 5. 配置 Nginx → 6. 启动服务

树状分解（Tree Decomposition）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


"重构用户系统"
├── 需求分析
│   ├── 梳理现有功能
│   └── 确定新需求
├── 设计
│   ├── 数据模型设计
│   └── API 接口设计
└── 实现
    ├── 迁移脚本
    ├── 核心逻辑
    └── 测试

反思与自修正

Agent 在产生结果后，对自己的输出进行检查和修正：

1

生成答案 → 自我审视（Reflection） → 发现不足 → 修正 → 输出最终答案

Reflexion 论文（Shinn et al., 2023）提出：Agent 可以将失败经验总结为长期记忆，下次遇到类似任务时自动规避。

思维链增强

规划模块可利用 LLM 的 Chain-of-Thought 能力：

Zero-shot CoT：在 prompt 中加入"Let’s think step by step"
Few-shot CoT：在 prompt 中提供推理示例
Tree-of-Thoughts：同时探索多条推理路径，选择最优

执行评估

每一步执行后评估结果：

1
2
3


预期：执行 "npm install" 后依赖安装成功
实际：返回错误 "node-gyp rebuild failed"
评估：缺少 C++ 编译工具 → Replan：先安装 build-essential

Agent 工具系统

工具是 Agent 的"手"，让它能与外部世界交互。

工具定义

每个工具需要清晰描述其功能、参数和返回值。当前主流方式是通过 function calling 机制：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


{
  "name": "read_file",
  "description": "读取指定路径的文件内容",
  "parameters": {
    "file_path": {
      "type": "string",
      "description": "文件的绝对路径"
    },
    "offset": {
      "type": "integer",
      "description": "起始行号"
    }
  }
}

LLM 根据工具描述判断何时调用哪个工具、传递什么参数。

工具分类

类别	工具举例	用途
文件系统	read/write/edit/glob/grep	读写代码、搜索文件
网络	web_search/web_fetch	获取实时信息
Shell	bash/exec	执行命令、运行测试
数据库	query/execute	读写数据库
外部API	github/jira/slack	与外部平台交互
浏览器	click/type/screenshot	Web 自动化测试

工具调用流程

1
2
3
4


1. LLM 输出 tool_call 指令（包括工具名和参数）
2. Agent 运行时解析指令，执行工具
3. 工具返回结果，注入回 LLM 上下文
4. LLM 根据结果决定下一步

关键设计点：

错误处理：工具执行失败时，将错误信息返回 LLM，由 LLM 决定重试或换方案
超时控制：防止工具长时间阻塞
权限管控：危险操作（如 rm -rf）需用户确认
并行调用：无依赖的工具调用应并发执行，减少等待时间

工具编排模式

单步调用：一次 LLM 推理 → 一个工具调用 → 结果返回

链式调用：

1

Tool A 的输出 → Tool B 的输入 → Tool C 的输入 → 最终结果

并行调用（Claude Code 的签名能力之一）：

1

LLM 推理 → [Tool A, Tool B, Tool C] 同时调用 → 聚合结果

条件调用：

1
2
3
4


if Tool A 失败:
    调用 Tool B 作为降级方案
else:
    继续调用 Tool C

Agent 的实际架构：以 Claude Code 为例

Claude Code 是当前最成熟的编程 Agent 之一，它的架构体现了上述所有概念：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


用户输入
  │
  ▼
┌──────────┐    ┌──────────────┐
│  系统提示  │    │  对话历史压缩 │
│  (范式)   │    │  (短期记忆)   │
└────┬─────┘    └──────┬───────┘
     │                 │
     ▼                 ▼
┌─────────────────────────────┐
│        LLM 推理              │
│  ┌───────┐  ┌───────────┐   │
│  │ 规划   │  │ 思维链推理  │   │
│  └───────┘  └───────────┘   │
└──────────┬──────────────────┘
           │
           ▼
    ┌──────────────┐
    │  工具选择与调用 │
    │  Read  Edit   │
    │  Bash  Grep   │
    │  Write Glob   │
    └──────┬───────┘
           │
           ▼
    ┌──────────────┐
    │  工具结果注入   │
    │  (Observation)│
    └──────┬───────┘
           │
           ▼ 循环回到 LLM 推理

工具系统一目了然：Read、Edit、Bash、Grep、Write、Glob 等，覆盖文件操作、命令执行、代码搜索。并行调用时，Claude 可同时读取多个文件、执行多个不相关操作，大幅减少等待时间。

记忆方面：

工作记忆：当前对话上下文
短期记忆：压缩后的历史对话摘要
长期记忆：文件系统持久化的 memory 目录（用户偏好、项目约定、操作反馈）

小结

Agent 是 LLM 从"聊天工具"进化为"数字劳动者"的关键一步：

范式决定 Agent 如何思考：ReAct 灵活可解释，Plan-Act 高效直接，多 Agent 协作适合复杂场景
记忆让 Agent 跨越单次对话：三层记忆架构处理不同时效的信息
规划赋予 Agent 处理复杂任务的能力：任务分解 + 反思纠错
工具是 Agent 与世界的接口：定义清晰、错误容忍、权限可控、并行高效

理解这四个模块，就能系统性地设计和改进 Agent 系统，而不仅仅是"给 LLM 加一些工具然后祈祷它能跑通"。