一、Agent 的整体架构
AI Agent 并不是一个单独的大模型,而是由模型、运行时、工具、记忆、状态管理和执行控制等组件组成的智能任务执行系统。
从系统架构角度,可以将 Agent 划分为六个核心层次:
- 交互层:接收用户目标,返回任务结果。
- 决策层:理解目标、分析上下文、制定计划。
- 推理层:调用大模型完成推理和决策。
- 执行层:调度工具,执行外部操作。
- 状态与记忆层:维护任务状态和历史信息。
- 控制与治理层:处理权限、安全、异常、超时和资源限制。
1. 整体架构图
flowchart TB
U["用户 / 外部系统"] --> API["Agent API"]
API --> R["Agent Runtime"]
subgraph Decision["决策与推理层"]
G["Goal Manager"]
P["Planner"]
L["LLM Engine"]
D["Decision Engine"]
G --> P
P --> L
L --> D
end
subgraph Execution["工具执行层"]
TR["Tool Registry"]
TE["Tool Executor"]
EX["External Systems"]
TR --> TE
TE --> EX
end
subgraph Memory["状态与记忆层"]
S["State Manager"]
M["Memory Manager"]
C["Context Manager"]
S --> C
M --> C
end
subgraph Governance["控制与治理层"]
POL["Policy Engine"]
OBS["Observability"]
ERR["Error Handler"]
end
R --> G
D --> TR
EX --> S
C --> L
POL --> R
TE --> OBS
ERR --> R
R --> OUT["Result Validator"]
OUT --> RESP["最终结果"]
style U fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style API fill:#EAF3EC,stroke:#83A995,color:#315D49
style R fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style P fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style TR fill:#EAF3EC,stroke:#83A995,color:#315D49
style TE fill:#EAF3EC,stroke:#83A995,color:#315D49
style EX fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style S fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style M fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style POL fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style OBS fill:#EAF3EC,stroke:#83A995,color:#315D49
style ERR fill:#F7EAE7,stroke:#C98D7C,color:#754438
style OUT fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style RESP fill:#DCEFE5,stroke:#4F8B70,color:#24563F
图中展示的是逻辑架构,不代表所有组件必须独立部署。小型 Agent 可以将多个模块放在同一个进程中,复杂系统则可以拆分为独立服务。
2. Agent 的核心组件
| 组件 | 核心职责 | 关键问题 |
|---|---|---|
| Agent Runtime | 管理 Agent 生命周期和执行循环 | 如何驱动任务持续运行 |
| Goal Manager | 解析目标和约束 | 如何判断任务要完成什么 |
| Planner | 任务拆解和路径规划 | 下一步应该做什么 |
| LLM Engine | 推理、决策和内容生成 | 如何获得合理决策 |
| Tool Registry | 管理工具定义 | 有哪些工具可以使用 |
| Tool Executor | 执行外部操作 | 如何安全执行工具 |
| Memory Manager | 管理长期记忆 | 哪些信息需要保留 |
| State Manager | 管理当前任务状态 | 任务执行到了哪里 |
| Context Manager | 组织模型输入上下文 | 模型当前应该看到什么 |
| Policy Engine | 权限和安全控制 | 哪些操作允许执行 |
| Error Handler | 处理异常和恢复 | 失败后如何继续 |
| Observability | 记录运行过程 | 如何定位问题和评估效果 |
需要特别区分三个容易混淆的概念:
- Runtime:负责驱动 Agent 执行。
- LLM:负责提供推理和生成能力。
- Orchestrator:负责组织多个执行组件或 Agent 之间的协作。
不同框架对 Runtime 和 Orchestrator 的职责划分可能不同,但工程上必须明确谁负责调度、谁负责执行、谁负责维护状态。
二、Agent Runtime:整个系统的运行核心
Agent Runtime 是 Agent 的执行引擎,负责将模型决策转化为实际操作,并持续驱动任务直到满足终止条件。
它并不等同于大模型,也不应该把所有业务逻辑都塞进 Prompt。
1. Runtime 的主要职责
任务生命周期管理
- 创建任务。
- 初始化执行上下文。
- 启动执行循环。
- 维护任务状态。
- 处理中断和恢复。
- 结束任务并返回结果。
模型调用管理
- 构造模型输入。
- 选择模型和参数。
- 调用模型接口。
- 解析模型输出。
- 处理模型调用异常。
工具执行管理
- 解析工具调用请求。
- 校验工具名称和参数。
- 检查执行权限。
- 调用工具执行器。
- 收集执行结果。
执行控制
- 限制最大执行步数。
- 限制模型调用次数。
- 控制任务超时。
- 管理并发和资源。
- 判断是否需要人工介入。
2. Runtime 的执行流程
flowchart TD
A["创建 Agent Task"] --> B["初始化 Runtime"]
B --> C["加载任务状态"]
C --> D["构建模型上下文"]
D --> E["调用 LLM"]
E --> F["解析模型决策"]
F --> G{"决策类型"}
G -->|"工具调用"| H["执行工具"]
G -->|"继续推理"| I["更新上下文"]
G -->|"最终回答"| J["验证任务结果"]
H --> K["收集工具结果"]
K --> I
I --> L{"是否达到执行限制"}
L -->|"否"| D
L -->|"是"| M["终止或请求人工介入"]
J --> N{"是否满足成功条件"}
N -->|"是"| O["完成任务"]
N -->|"否"| M
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style H fill:#EAF3EC,stroke:#83A995,color:#315D49
style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style J fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style K fill:#EAF3EC,stroke:#83A995,color:#315D49
style L fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style M fill:#F7EAE7,stroke:#C98D7C,color:#754438
style N fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style O fill:#DCEFE5,stroke:#4F8B70,color:#24563F
3. 为什么需要独立的 Runtime?
假设只使用大模型完成 Agent 任务:
- 模型生成工具调用。
- 模型自行描述执行结果。
- 模型自行判断是否完成。
- 模型自行决定是否继续。
这会导致一个严重问题:模型输出的内容可能被误认为已经执行的事实。
例如,模型生成:
{
"tool": "delete_file",
"arguments": {
"path": "/tmp/test.txt"
},
"status": "success"
}
这段内容只是模型生成的数据,并不能证明文件已经删除。
真正的执行必须由 Runtime 调用工具,并获取工具的实际返回结果。
因此:
模型负责提出行动建议,Runtime 负责控制和落实行动。
三、Goal Manager:目标理解与任务约束
Agent 的执行起点不是工具,而是目标。
用户往往以自然语言描述需求,而 Runtime 需要将其转换为可管理的任务定义。
1. 目标解析
例如:
分析项目中的代码质量,找出严重问题,修复能够自动修复的部分,并运行测试。
Goal Manager 需要提取:
| 维度 | 内容 |
|---|---|
| 目标 | 提高项目代码质量 |
| 分析范围 | 当前项目代码 |
| 任务要求 | 找出严重问题 |
| 执行动作 | 自动修复可修复问题 |
| 验证条件 | 运行测试 |
| 结果要求 | 输出问题和修复报告 |
| 执行约束 | 不允许未经授权删除文件 |
2. 目标结构化
可以将目标转换为结构化对象:
{
"goal_id": "goal_001",
"description": "分析并修复项目代码问题",
"constraints": {
"scope": "current_project",
"allow_file_edit": true,
"allow_file_delete": false,
"require_test": true
},
"success_criteria": [
"完成代码检查",
"严重问题得到处理",
"完成测试验证",
"生成执行报告"
],
"status": "pending"
}
结构化目标有几个重要作用:
- 让任务具备明确边界。
- 让 Planner 有可靠的规划依据。
- 让 Policy Engine 能够检查操作权限。
- 让 Result Validator 能够判断完成条件。
3. 目标与计划的区别
目标描述最终想要达到的状态,计划描述达到目标需要执行的步骤。
例如:
- 目标:修复项目中的严重 Bug。
- 计划:读取代码、分析问题、修改文件、运行测试、验证结果。
目标不应该与具体执行步骤混为一谈。
否则,当某个步骤失败时,Agent 很难重新规划。
四、Planner:任务拆解与执行规划
Planner 负责把复杂任务拆解为可执行的子任务,并确定任务之间的依赖关系。
1. 任务拆解
一个复杂任务可以表示为任务树:
项目代码质量分析
├── 1. 项目扫描
│ ├── 读取目录结构
│ ├── 识别语言和框架
│ └── 分析依赖关系
├── 2. 代码分析
│ ├── 静态代码检查
│ ├── 安全风险检查
│ └── 逻辑问题分析
├── 3. 问题处理
│ ├── 问题分类
│ ├── 生成修复方案
│ └── 修改代码
└── 4. 结果验证
├── 运行测试
├── 分析测试结果
└── 生成报告
2. 常见规划方式
| 规划模式 | 特点 | 适用场景 |
|---|---|---|
| Sequential | 按顺序执行 | 有明确前后依赖的任务 |
| Parallel | 并行执行 | 相互独立的任务 |
| Conditional | 根据条件分支 | 需要根据结果选择路径 |
| Iterative | 多轮迭代 | 需要反复优化的任务 |
| Hierarchical | 分层拆解 | 复杂的多级目标 |
3. 顺序规划
前一个任务的结果是后一个任务的输入。
flowchart TD
A["读取项目"] --> B["分析代码"]
B --> C["定位问题"]
C --> D["修改代码"]
D --> E["运行测试"]
E --> F["生成报告"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
4. 并行规划
当多个任务没有数据依赖时,可以同时执行。
flowchart TD
A["项目分析"] --> B["安全检查"]
A --> C["性能检查"]
A --> D["代码规范检查"]
B --> E["汇总分析结果"]
C --> E
D --> E
E --> F["生成问题清单"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
并行执行需要特别关注: - 任务之间是否存在数据依赖。 - 是否会同时修改相同文件。 - 是否存在资源竞争。 - 是否需要结果合并。 - 单个子任务失败时如何处理。
5. 条件规划
根据中间执行结果选择后续路径。
flowchart TD
A["执行代码检查"] --> B["分析检查结果"]
B --> C{"是否发现严重问题"}
C -->|"是"| D["生成修复方案"]
C -->|"否"| E["生成检查报告"]
D --> F["执行修复"]
F --> G["运行测试"]
G --> H{"测试是否通过"}
H -->|"是"| E
H -->|"否"| I["记录失败并请求处理"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#EAF3EC,stroke:#83A995,color:#315D49
style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style I fill:#F7EAE7,stroke:#C98D7C,color:#754438
6. 规划结果的结构化表示
Planner 不应该只返回一段自然语言计划。工程系统通常需要将计划转化为结构化任务对象。
{
"plan_id": "plan_001",
"tasks": [
{
"id": "task_1",
"name": "scan_project",
"dependencies": [],
"status": "pending"
},
{
"id": "task_2",
"name": "analyze_code",
"dependencies": ["task_1"],
"status": "pending"
},
{
"id": "task_3",
"name": "fix_issues",
"dependencies": ["task_2"],
"status": "pending"
},
{
"id": "task_4",
"name": "run_tests",
"dependencies": ["task_3"],
"status": "pending"
}
]
}
这样 Runtime 才能对任务进行调度、重试、恢复和追踪。
五、LLM Engine:Agent 的推理引擎
LLM 是 Agent 的核心推理组件,负责理解上下文、判断任务进度、生成计划以及决定下一步行动。
1. LLM 在 Agent 中的职责
主要包括:
- 意图理解:理解用户目标。
- 上下文分析:理解历史对话和工具结果。
- 任务规划:生成或调整执行计划。
- 工具选择:选择合适的工具。
- 参数生成:生成工具调用参数。
- 结果分析:解释工具执行结果。
- 决策生成:决定继续执行还是结束任务。
2. 模型调用的输入
Agent 并不是简单地将用户问题直接发送给模型。
一次典型的模型请求可能包含:
{
"system_prompt": "你是一个代码分析 Agent",
"user_goal": "检查项目并修复严重问题",
"conversation_history": [],
"task_state": {
"current_step": "analyze_code",
"completed_steps": ["scan_project"]
},
"memory_context": [],
"available_tools": [
{
"name": "read_file",
"description": "读取指定文件"
},
{
"name": "run_tests",
"description": "运行项目测试"
}
],
"constraints": {
"max_steps": 20,
"allow_file_delete": false
}
}
这些信息经过 Context Manager 整理后,才会真正进入模型上下文。
3. 模型输出的决策类型
Agent 通常需要将模型输出约束为有限的决策类型。
| 决策类型 | 含义 |
|---|---|
| TOOL_CALL | 调用某个工具 |
| CONTINUE | 继续推理或规划 |
| FINAL | 返回最终结果 |
| ASK_USER | 请求用户补充信息或确认 |
| HANDOFF | 转交其他 Agent 或人工处理 |
| ABORT | 终止任务 |
一种简化的结构化决策:
{
"action": "TOOL_CALL",
"tool_name": "read_file",
"arguments": {
"path": "src/main.py"
},
"reason": "需要检查程序入口逻辑"
}
需要强调:模型输出的决策必须经过 Runtime 校验,不能直接作为可信执行指令。
六、Tool Registry 与 Tool Executor:工具管理与执行
工具是 Agent 与外部世界交互的接口。
但工具定义、工具选择和工具执行是三个不同的环节。
1. Tool Registry
Tool Registry 是工具注册中心,负责管理 Agent 可以使用的工具。
一个工具通常需要包含:
| 字段 | 说明 |
|---|---|
| name | 工具名称 |
| description | 工具用途描述 |
| parameters | 参数 Schema |
| permissions | 所需权限 |
| timeout | 最大执行时间 |
| retry_policy | 重试策略 |
| side_effects | 是否存在副作用 |
| version | 工具版本 |
例如:
{
"name": "read_file",
"description": "读取指定路径的文件内容",
"parameters": {
"type": "object",
"properties": {
"path": {
"type": "string",
"description": "文件路径"
}
},
"required": ["path"]
},
"permissions": ["filesystem.read"],
"timeout": 10,
"side_effects": false
}
工具定义通常会提供给模型,使模型知道有哪些工具可用、每个工具如何调用。
2. Tool Executor
Tool Executor 负责将模型生成的工具调用请求转换为真实执行操作。
其核心职责包括:
- 解析工具名称。
- 查找工具注册信息。
- 校验参数格式。
- 检查用户和任务权限。
- 检查资源限制。
- 执行具体工具。
- 捕获异常和超时。
- 规范化返回结果。
执行流程:
flowchart TD
A["接收工具调用请求"] --> B["解析工具名称"]
B --> C{"工具是否存在"}
C -->|"否"| X["返回工具不存在错误"]
C -->|"是"| D["校验参数 Schema"]
D --> E{"参数是否合法"}
E -->|"否"| Y["返回参数错误"]
E -->|"是"| F["检查权限与策略"]
F --> G{"是否允许执行"}
G -->|"否"| Z["拒绝执行"]
G -->|"是"| H["执行工具"]
H --> I{"执行是否成功"}
I -->|"是"| J["规范化结果"]
I -->|"否"| K["异常处理"]
J --> L["返回工具结果"]
K --> M["分类错误并决定重试"]
M --> L
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style H fill:#EAF3EC,stroke:#83A995,color:#315D49
style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style K fill:#F7EAE7,stroke:#C98D7C,color:#754438
style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style M fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style X fill:#F7EAE7,stroke:#C98D7C,color:#754438
style Y fill:#F7EAE7,stroke:#C98D7C,color:#754438
style Z fill:#F7EAE7,stroke:#C98D7C,color:#754438
3. 工具执行与模型决策的边界
这是 Agent 工程中非常重要的边界:
- 模型可以提出调用工具的请求。
- Runtime 决定请求是否进入执行阶段。
- Policy Engine 决定操作是否被允许。
- Tool Executor 执行具体操作。
- 外部工具返回真实执行结果。
不能因为模型输出了 success,就认为工具已经执行成功。
4. 工具执行结果
工具返回结果最好使用统一结构:
{
"tool_call_id": "call_001",
"tool_name": "read_file",
"status": "success",
"data": {
"content": "print('hello')"
},
"error": null,
"duration_ms": 25
}
统一结果结构可以让 Runtime 以一致的方式处理不同工具。
七、Memory、State 与 Context:三个最容易混淆的组件
Memory、State 和 Context 都与信息管理有关,但三者承担不同职责。
1. Memory:记忆系统
Memory 用于保存后续任务可能需要的信息。
常见分类:
| 类型 | 内容 | 生命周期 |
|---|---|---|
| 工作记忆 | 当前任务需要的临时信息 | 任务期间 |
| 短期记忆 | 当前会话的历史信息 | 会话期间 |
| 长期记忆 | 用户偏好、稳定知识和历史经验 | 跨会话 |
| 情景记忆 | 过去发生的任务和执行经历 | 按策略保存 |
| 语义记忆 | 已整理的事实和知识 | 按策略保存 |
Memory 的关键不是保存所有对话,而是判断哪些信息未来值得复用。
典型记忆处理过程:
flowchart TD
A["产生新信息"] --> B["判断信息价值"]
B --> C{"是否值得记忆"}
C -->|"否"| D["不保存"]
C -->|"是"| E["提取关键内容"]
E --> F["整理和规范化"]
F --> G["分类与打标签"]
G --> H["写入记忆存储"]
H --> I["建立索引"]
I --> J["后续任务检索"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#EAF3EC,stroke:#83A995,color:#315D49
style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F
2. State:任务状态
State 用于记录当前任务的执行状态。
例如:
{
"task_id": "task_001",
"status": "running",
"current_node": "run_tests",
"completed_nodes": [
"scan_project",
"analyze_code",
"fix_code"
],
"retry_count": 1,
"started_at": "2026-11-20T10:00:00Z"
}
State 关注的是:
- 当前执行到哪里。
- 哪些步骤已经完成。
- 哪些步骤等待执行。
- 当前任务是否失败。
- 是否允许继续或恢复。
State 通常需要具备明确的数据结构、版本和持久化机制。
3. Context:模型上下文
Context 是当前模型调用能够看到的信息集合。
通常包括:
- System Prompt。
- 用户目标。
- 历史消息。
- 当前任务状态摘要。
- 相关记忆。
- 工具定义。
- 工具执行结果。
- 当前执行约束。
Context Manager 负责将这些信息整理为模型可以理解的输入。
4. 三者的核心区别
| 对比维度 | Memory | State | Context |
|---|---|---|---|
| 核心目的 | 保存可复用信息 | 记录任务进度 | 提供模型推理输入 |
| 关注重点 | 记住什么 | 当前发生什么 | 模型需要知道什么 |
| 生命周期 | 可跨任务 | 通常绑定任务 | 绑定一次模型调用 |
| 存储方式 | 数据库、向量库等 | 状态存储、数据库 | Prompt 和消息结构 |
| 是否直接提供给模型 | 按需检索 | 按需摘要 | 直接提供 |
| 是否要求完整持久化 | 视记忆策略 | 通常需要 | 通常不需要 |
三者之间的关系:
flowchart TD
A["任务执行"] --> B["产生状态变化"]
A --> C["产生可复用信息"]
B --> D["State Manager"]
C --> E["Memory Manager"]
D --> F["Context Manager"]
E --> G["记忆检索"]
G --> F
F --> H["构建模型输入"]
H --> I["LLM 推理"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
工程上,不能把 Memory、State 和 Context 简单合并成一段对话历史。它们的数据结构、更新时机和持久化要求都不同。
八、Context Manager:上下文构建与管理
Context Manager 决定每一次模型调用应该提供哪些信息。
这对 Agent 尤其重要,因为 Agent 可能运行几十轮甚至数百轮。
1. 为什么需要 Context Manager?
假设一个 Agent 执行复杂任务:
- 读取了 100 个文件。
- 调用了 30 次工具。
- 产生了大量中间结果。
- 进行了多轮计划调整。
如果每次模型调用都把所有历史信息完整传入,就会遇到:
- Token 消耗快速增长。
- 模型上下文窗口不足。
- 重要信息被大量无关信息淹没。
- 推理成本和延迟增加。
2. 上下文管理策略
| 策略 | 作用 |
|---|---|
| Sliding Window | 只保留最近一部分历史 |
| Summarization | 将旧消息压缩成摘要 |
| Retrieval | 按需检索相关记忆 |
| Truncation | 删除低价值内容 |
| Context Partitioning | 将不同类型信息分区管理 |
| Structured State | 使用结构化状态代替冗长对话 |
| Tool Result Filtering | 过滤工具返回中的无关内容 |
3. Context 构建过程
flowchart TD
A["准备模型调用"] --> B["加载系统指令"]
B --> C["加载当前目标和约束"]
C --> D["加载任务状态"]
D --> E["检索相关记忆"]
E --> F["筛选历史消息"]
F --> G["整理工具定义与结果"]
G --> H["计算 Token 预算"]
H --> I{"是否超过上下文限制"}
I -->|"是"| J["压缩或裁剪内容"]
J --> H
I -->|"否"| K["生成最终 Context"]
K --> L["发送模型请求"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style J fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style K fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F
4. Context 预算
Context Manager 需要为不同内容分配 Token 预算。
例如:
| 内容 | 预算占比示例 |
|---|---|
| 系统指令和约束 | 15% |
| 用户目标 | 10% |
| 当前任务状态 | 15% |
| 历史摘要 | 15% |
| 工具定义 | 15% |
| 当前任务相关资料 | 25% |
| 预留空间 | 5% |
这只是示例分配,不是固定比例。实际预算需要根据模型上下文窗口、工具数量和任务类型动态调整。
九、Agent Loop:核心运行机制
Agent Loop 是 Agent 最核心的执行机制。
它将模型推理、工具执行和环境反馈组织成一个持续循环。
1. 标准 Agent Loop
通常可以抽象为五个阶段:
| 阶段 | 英文 | 核心职责 |
|---|---|---|
| 感知 | Observe | 获取当前环境信息 |
| 思考 | Think | 分析目标和当前状态 |
| 规划 | Plan | 决定下一步行动 |
| 行动 | Act | 调用工具执行操作 |
| 评估 | Evaluate | 判断执行结果是否满足目标 |
完整执行流程:
flowchart TD
A["Observe:获取环境信息"] --> B["Think:分析当前状态"]
B --> C["Plan:制定行动计划"]
C --> D["Act:执行工具操作"]
D --> E["Evaluate:评估执行结果"]
E --> F{"目标是否完成"}
F -->|"否"| A
F -->|"是"| G["返回最终结果"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
2. Observe:感知环境
Observe 负责获取当前任务相关信息。
信息来源包括:
- 用户输入。
- 历史对话。
- 当前任务状态。
- 工具执行结果。
- 外部 API 响应。
- 文件和数据库数据。
- 环境运行日志。
Observe 的核心问题是:Agent 当前掌握了哪些事实?
要特别注意,外部环境返回的信息不一定可信。网页、邮件、文档等内容需要作为不可信数据处理,不能直接覆盖系统指令和安全策略。
3. Think:分析当前状态
Think 阶段使用 LLM 对当前上下文进行分析。
主要判断:
- 用户真正想完成什么。
- 当前任务处于什么状态。
- 已经获得哪些信息。
- 当前还缺少什么。
- 是否存在执行风险。
- 下一步是否需要调用工具。
Think 的重点不是生成长篇解释,而是形成可用于决策的判断。
4. Plan:制定行动计划
Plan 阶段决定接下来执行什么操作。
可能的结果包括:
- 调用某个工具。
- 拆分新的子任务。
- 调整已有计划。
- 请求用户补充信息。
- 等待外部任务完成。
- 结束当前任务。
简单任务可以直接生成下一步行动;复杂任务则需要维护显式任务计划。
5. Act:执行行动
Act 阶段由 Runtime 和 Tool Executor 完成。
可能执行: - 查询数据库。 - 读取文件。 - 修改文件。 - 调用 API。 - 执行代码。 - 发送消息。 - 调用其他 Agent。
Act 不是模型生成一段文本,而是系统真正执行外部操作。
6. Evaluate:评估结果
Evaluate 阶段需要判断行动是否有效。
例如:
- 工具是否执行成功?
- 是否获取到预期数据?
- 是否满足当前子任务的完成条件?
- 是否需要重新规划?
- 整体目标是否已经完成?
评估可以结合: - 规则校验。 - 单元测试。 - 数据一致性检查。 - 独立模型评估。 - 人工审核。
对于重要任务,应尽可能采用确定性验证方式,而不是完全依赖 LLM 自我判断。
十、完整运行机制:从用户请求到任务完成
将前面的组件组合起来,可以得到一个相对完整的 Agent 执行过程。
以自动代码修复 Agent 为例。
1. 任务启动
用户提交任务:
检查项目中的代码问题,修复严重 Bug,并确保测试通过。
Runtime 创建任务,并初始化: - Task ID。 - 用户目标。 - 执行约束。 - 初始状态。 - 工具权限。 - 最大执行预算。
2. 目标解析与规划
Goal Manager 解析目标。
Planner 将任务拆解为:
- 扫描项目。
- 分析代码。
- 定位问题。
- 制定修复方案。
- 修改代码。
- 执行测试。
- 验证结果。
- 输出报告。
3. 上下文构建
Context Manager 加载: - 系统指令。 - 用户目标。 - 当前任务计划。 - 当前状态。 - 相关历史信息。 - 可用工具定义。
然后构建模型请求。
4. 模型决策
LLM 判断当前需要读取项目文件,并返回工具调用请求。
Runtime 解析请求,交给 Tool Executor。
5. 工具执行
Tool Executor 检查工具、参数和权限,执行文件读取操作,并返回结果。
6. 状态更新
State Manager 更新当前任务状态,保存已完成步骤和工具执行结果。
7. 反馈与重新决策
Runtime 将工具结果加入上下文,再次调用模型。
模型根据新信息决定继续分析、修改代码或执行测试。
8. 结果验证与结束
Result Validator 检查测试结果和任务完成条件。
如果符合要求,任务结束;如果未达到目标,则继续处理或进入失败恢复流程。