第20章 子代理隔离与上下文管理 —— 防止污染的核心机制
目录
上一篇我们了解了多智能体架构模式。本章我们深入子代理隔离机制——防止上下文污染的核心。
子代理隔离是什么
一句话定义：子 Agent 使用独立上下文，执行完成后只返回结果，不泄露历史。
Sub-Agent Isolation = 独立上下文 + 结果返回 定位：多智能体架构的核心机制，防止上下文污染
图表
代码
graph TB
Main[主 Agent
messagesA] -->|派发
不泄露历史| Sub[子 Agent
messagesB（独立）]
Sub -->|执行
独立上下文| Task[完成任务]
Task -->|返回
只返回结果| Result[返回结果]
Result -->|追加
不泄露messagesB| Main
Main[干净的主上下文]
Sub[隔离的子上下文]graph TB
Main[主 Agent
messagesA] -->|派发
不泄露历史| Sub[子 Agent
messagesB（独立）]
Sub -->|执行
独立上下文| Task[完成任务]
Task -->|返回
只返回结果| Result[返回结果]
Result -->|追加
不泄露messagesB| Main
Main[干净的主上下文]
Sub[隔离的子上下文]graph TB
Main[主 Agent
messagesA] -->|派发
不泄露历史| Sub[子 Agent
messagesB（独立）]
Sub -->|执行
独立上下文| Task[完成任务]
Task -->|返回
只返回结果| Result[返回结果]
Result -->|追加
不泄露messagesB| Main
Main[干净的主上下文]
Sub[隔离的子上下文]graph TB
Main[主 Agent<br/>messagesA] -->|派发<br/>不泄露历史| Sub[子 Agent<br/>messagesB（独立）]
Sub -->|执行<br/>独立上下文| Task[完成任务]
Task -->|返回<br/>只返回结果| Result[返回结果]
Result -->|追加<br/>不泄露messagesB| Main
Main[干净的主上下文]
Sub[隔离的子上下文]核心机制：
- 独立 messages 数组：子 Agent 使用独立 messages，不共享主 Agent
- 不泄露历史：子 Agent 执行过程不泄露到主 Agent
- 只返回结果：子 Agent 只返回最终结果，不返回整个历史
- 防止污染：主 Agent 上下文保持干净，不受子 Agent 影响
为什么需要隔离
不隔离的问题
图表
代码
graph TB
subgraph NoIsolationProblem["不隔离的问题"]
P1[上下文污染
子Agent历史泄露]
P2[主Agent上下文爆炸
messages数组溢出]
P3[性能下降
上下文过大响应慢]
P4[成本增加
Token消耗大幅增加]
end
style NoIsolationProblem fill:#FFE0E0graph TB
subgraph NoIsolationProblem["不隔离的问题"]
P1[上下文污染
子Agent历史泄露]
P2[主Agent上下文爆炸
messages数组溢出]
P3[性能下降
上下文过大响应慢]
P4[成本增加
Token消耗大幅增加]
end
style NoIsolationProblem fill:#FFE0E0graph TB
subgraph NoIsolationProblem["不隔离的问题"]
P1[上下文污染
子Agent历史泄露]
P2[主Agent上下文爆炸
messages数组溢出]
P3[性能下降
上下文过大响应慢]
P4[成本增加
Token消耗大幅增加]
end
style NoIsolationProblem fill:#FFE0E0graph TB
subgraph NoIsolationProblem["不隔离的问题"]
P1[上下文污染<br/>子Agent历史泄露]
P2[主Agent上下文爆炸<br/>messages数组溢出]
P3[性能下降<br/>上下文过大响应慢]
P4[成本增加<br/>Token消耗大幅增加]
end
style NoIsolationProblem fill:#FFE0E0| 问题 | 说明 | 影响 |
|---|---|---|
| 上下文污染 | 子 Agent 历史泄露到主 Agent | 主 Agent 上下文混乱 |
| 上下文爆炸 | messages 数组快速溢出 | 上下文窗口超出限制 |
| 性能下降 | 上下文过大导致 Model 响应慢 | 执行效率降低 |
| 成本增加 | Token 消耗大幅增加 | API 成本增加 |
示例计算：
不隔离情况下的 messages 增长：
主 Agent messagesA：
- 初始：10K tokens
- 子 Agent 1 执行：增加 15K tokens（泄露）
- 子 Agent 2 执行：增加 20K tokens（泄露）
- 总计：10K + 15K + 20K = 45K tokens
隔离情况下：
主 Agent messagesA：
- 初始：10K tokens
- 子 Agent 1 执行：增加 1K tokens（只返回结果）
- 子 Agent 2 执行：增加 1K tokens（只返回结果）
- 总计：10K + 1K + 1K = 12K tokens
节省：45K - 12K = 33K tokens（节省 73%）隔离的好处
图表
代码
graph TB
subgraph IsolationBenefits["隔离的好处"]
B1[防止污染
主Agent保持干净]
B2[节省空间
子Agent历史不占用]
B3[提升性能
上下文小响应快]
B4[降低成本
Token消耗减少]
B5[专业专注
子Agent专注任务]
end
style IsolationBenefits fill:#E0FFE0graph TB
subgraph IsolationBenefits["隔离的好处"]
B1[防止污染
主Agent保持干净]
B2[节省空间
子Agent历史不占用]
B3[提升性能
上下文小响应快]
B4[降低成本
Token消耗减少]
B5[专业专注
子Agent专注任务]
end
style IsolationBenefits fill:#E0FFE0graph TB
subgraph IsolationBenefits["隔离的好处"]
B1[防止污染
主Agent保持干净]
B2[节省空间
子Agent历史不占用]
B3[提升性能
上下文小响应快]
B4[降低成本
Token消耗减少]
B5[专业专注
子Agent专注任务]
end
style IsolationBenefits fill:#E0FFE0graph TB
subgraph IsolationBenefits["隔离的好处"]
B1[防止污染<br/>主Agent保持干净]
B2[节省空间<br/>子Agent历史不占用]
B3[提升性能<br/>上下文小响应快]
B4[降低成本<br/>Token消耗减少]
B5[专业专注<br/>子Agent专注任务]
end
style IsolationBenefits fill:#E0FFE0| 好处 | 说明 | 价值 |
|---|---|---|
| 防止污染 | 主 Agent 上下文保持干净 | 主 Agent 可继续工作 |
| 节省空间 | 子 Agent 历史不占用主上下文 | 防止溢出 |
| 提升性能 | 上下文小，Model 响应快 | 执行效率高 |
| 降低成本 | Token 消耗减少 | 成本降低 |
| 专业专注 | 子 Agent 专注专业任务 | 任务质量高 |
隔离机制的实现
障壁隔离模式
一句话定义：子 Agent 使用全新 messages 数组，完全独立。
图表
代码
graph TB
subgraph BarrierIsolation["障壁隔离"]
Main[主 Agent
messagesA
历史A]
Sub1[子 Agent 1
messagesB
全新历史]
Sub2[子 Agent 2
messagesC
全新历史]
Main -->|派发
不泄露messagesA| Sub1
Main -->|派发
不泄露messagesA| Sub2
Sub1 -->|返回
结果1
不泄露messagesB| Main
Sub2 -->|返回
结果2
不泄露messagesC| Main
end
style Main fill:#E0FFE0
style Sub1 fill:#FFE0E0
style Sub2 fill:#FFE0E0graph TB
subgraph BarrierIsolation["障壁隔离"]
Main[主 Agent
messagesA
历史A]
Sub1[子 Agent 1
messagesB
全新历史]
Sub2[子 Agent 2
messagesC
全新历史]
Main -->|派发
不泄露messagesA| Sub1
Main -->|派发
不泄露messagesA| Sub2
Sub1 -->|返回
结果1
不泄露messagesB| Main
Sub2 -->|返回
结果2
不泄露messagesC| Main
end
style Main fill:#E0FFE0
style Sub1 fill:#FFE0E0
style Sub2 fill:#FFE0E0graph TB
subgraph BarrierIsolation["障壁隔离"]
Main[主 Agent
messagesA
历史A]
Sub1[子 Agent 1
messagesB
全新历史]
Sub2[子 Agent 2
messagesC
全新历史]
Main -->|派发
不泄露messagesA| Sub1
Main -->|派发
不泄露messagesA| Sub2
Sub1 -->|返回
结果1
不泄露messagesB| Main
Sub2 -->|返回
结果2
不泄露messagesC| Main
end
style Main fill:#E0FFE0
style Sub1 fill:#FFE0E0
style Sub2 fill:#FFE0E0graph TB
subgraph BarrierIsolation["障壁隔离"]
Main[主 Agent<br/>messagesA<br/>历史A]
Sub1[子 Agent 1<br/>messagesB<br/>全新历史]
Sub2[子 Agent 2<br/>messagesC<br/>全新历史]
Main -->|派发<br/>不泄露messagesA| Sub1
Main -->|派发<br/>不泄露messagesA| Sub2
Sub1 -->|返回<br/>结果1<br/>不泄露messagesB| Main
Sub2 -->|返回<br/>结果2<br/>不泄露messagesC| Main
end
style Main fill:#E0FFE0
style Sub1 fill:#FFE0E0
style Sub2 fill:#FFE0E0实现方式：
# 障壁隔离实现
def barrier_isolation(main_agent, subagent_type, task):
# 1. 创建子 Agent 全新 messages
sub_messages = [
{"role": "system", "content": get_subagent_system_prompt(subagent_type)},
{"role": "user", "content": task} # 只接收任务描述
]
# 2. 子 Agent 执行（独立 Loop）
sub_result = run_agent_loop(sub_messages)
# 3. 只返回结果（不泄露历史）
result_only = {
"role": "user",
"content": f"[{subagent_type}] {sub_result.content}"
}
# 4. 追加到主 Agent（只追加结果）
main_agent.messages.append(result_only)
return result_only特点：
| 特点 | 说明 | 适用场景 |
|---|---|---|
| 全新 messages | 子 Agent 从零开始 | 完全独立任务 |
| 不共享历史 | 不共享主 Agent 历史 | 需要完全隔离 |
| 只返回结果 | 只返回最终结果 | 结果整合 |
| Token 节省最多 | 节省大量 Token | 大量子 Agent |
传递隔离模式
一句话定义：子 Agent 接收必要上下文摘要，但执行过程独立。
图表
代码
graph TB
subgraph TransferIsolation["传递隔离"]
Main[主 Agent
messagesA
历史A]
Summary[上下文摘要
必要信息]
Sub[子 Agent
messagesB
摘要 + 任务]
Main -->|提取摘要| Summary
Summary -->|传递必要信息| Sub
Sub -->|执行独立上下文| Task[完成任务]
Task -->|返回结果
不泄露messagesB| Main
end
style Main fill:#E0FFE0
style Sub fill:#FFE0E0graph TB
subgraph TransferIsolation["传递隔离"]
Main[主 Agent
messagesA
历史A]
Summary[上下文摘要
必要信息]
Sub[子 Agent
messagesB
摘要 + 任务]
Main -->|提取摘要| Summary
Summary -->|传递必要信息| Sub
Sub -->|执行独立上下文| Task[完成任务]
Task -->|返回结果
不泄露messagesB| Main
end
style Main fill:#E0FFE0
style Sub fill:#FFE0E0graph TB
subgraph TransferIsolation["传递隔离"]
Main[主 Agent
messagesA
历史A]
Summary[上下文摘要
必要信息]
Sub[子 Agent
messagesB
摘要 + 任务]
Main -->|提取摘要| Summary
Summary -->|传递必要信息| Sub
Sub -->|执行独立上下文| Task[完成任务]
Task -->|返回结果
不泄露messagesB| Main
end
style Main fill:#E0FFE0
style Sub fill:#FFE0E0graph TB
subgraph TransferIsolation["传递隔离"]
Main[主 Agent<br/>messagesA<br/>历史A]
Summary[上下文摘要<br/>必要信息]
Sub[子 Agent<br/>messagesB<br/>摘要 + 任务]
Main -->|提取摘要| Summary
Summary -->|传递必要信息| Sub
Sub -->|执行独立上下文| Task[完成任务]
Task -->|返回结果<br/>不泄露messagesB| Main
end
style Main fill:#E0FFE0
style Sub fill:#FFE0E0实现方式：
# 传递隔离实现
def transfer_isolation(main_agent, subagent_type, task):
# 1. 提取主 Agent 上下文摘要
summary = summarize_context(main_agent.messages)
# 2. 创建子 Agent messages（摘要 + 任务）
sub_messages = [
{"role": "system", "content": get_subagent_system_prompt(subagent_type)},
{"role": "user", "content": f"上下文摘要:\n{summary}\n\n任务:\n{task}"}
]
# 3. 子 Agent 执行（独立 Loop）
sub_result = run_agent_loop(sub_messages)
# 4. 只返回结果（不泄露历史）
result_only = {
"role": "user",
"content": f"[{subagent_type}] {sub_result.content}"
}
# 5. 追加到主 Agent（只追加结果）
main_agent.messages.append(result_only)
return result_only特点：
| 特点 | 说明 | 适用场景 |
|---|---|---|
| 传递摘要 | 子 Agent 接收必要摘要 | 需要上下文信息的任务 |
| 执行独立 | 执行过程独立，不泄露 | 保持隔离 |
| Token 节省 | 比不隔离节省，比障壁多 | 适度节省 |
| 信息传递 | 传递必要信息 | 需要主 Agent 上下文 |
两种模式对比
| 维度 | 障壁隔离 | 传递隔离 |
|---|---|---|
| 上下文共享 | ❌ 不共享 | ⚠️ 共享摘要 |
| Token 节省 | ✅ 最多 | ⚠️ 中等 |
| 信息传递 | ❌ 无传递 | ✅ 传递必要信息 |
| 适用场景 | 完全独立任务 | 需要上下文的任务 |
| 实现复杂度 | ✅ 简单 | ⚠️ 需摘要逻辑 |
图表
代码
graph TB
subgraph Compare["两种隔离对比"]
Barrier[障壁隔离
不共享
Token节省最多
完全独立任务]
Transfer[传递隔离
共享摘要
Token节省中等
需要上下文任务]
end
Barrier -->|选择| Decision{任务需要
主Agent上下文?}
Decision -->|不需要| BarrierChoose[选择障壁隔离]
Decision -->|需要| TransferChoose[选择传递隔离]graph TB
subgraph Compare["两种隔离对比"]
Barrier[障壁隔离
不共享
Token节省最多
完全独立任务]
Transfer[传递隔离
共享摘要
Token节省中等
需要上下文任务]
end
Barrier -->|选择| Decision{任务需要
主Agent上下文?}
Decision -->|不需要| BarrierChoose[选择障壁隔离]
Decision -->|需要| TransferChoose[选择传递隔离]graph TB
subgraph Compare["两种隔离对比"]
Barrier[障壁隔离
不共享
Token节省最多
完全独立任务]
Transfer[传递隔离
共享摘要
Token节省中等
需要上下文任务]
end
Barrier -->|选择| Decision{任务需要
主Agent上下文?}
Decision -->|不需要| BarrierChoose[选择障壁隔离]
Decision -->|需要| TransferChoose[选择传递隔离]graph TB
subgraph Compare["两种隔离对比"]
Barrier[障壁隔离<br/>不共享<br/>Token节省最多<br/>完全独立任务]
Transfer[传递隔离<br/>共享摘要<br/>Token节省中等<br/>需要上下文任务]
end
Barrier -->|选择| Decision{任务需要<br/>主Agent上下文?}
Decision -->|不需要| BarrierChoose[选择障壁隔离]
Decision -->|需要| TransferChoose[选择传递隔离]上下文传递策略
传递什么信息
传递内容：
| 传递内容 | 说明 | 示例 |
|---|---|---|
| 任务描述 | 子任务的具体描述 | “审查 app.ts 文件” |
| 关键文件 | 相关文件路径 | “/src/app.ts” |
| 关键决策 | 主 Agent 的关键决策 | “决定重构 validate 函数” |
| 当前状态 | 主 Agent 当前状态 | “已读取 app.ts，准备修改” |
不传递内容：
| 不传递内容 | 说明 | 原因 |
|---|---|---|
| 完整历史 | 主 Agent 的完整 messages | Token 过大 |
| 工具输出 | 所有工具输出细节 | 不必要 |
| 中间推理 | 主 Agent 的中间推理过程 | 不必要 |
摘要生成策略
图表
代码
graph LR
MainMessages[主 Agent messages] --> Extract[提取关键信息]
Extract --> Summarize[生成摘要]
Summarize --> SubMessages[子 Agent messages]
Extract[提取：文件路径 + 关键决策 + 当前状态]
Summarize[摘要：压缩为 500-1000 tokens]graph LR
MainMessages[主 Agent messages] --> Extract[提取关键信息]
Extract --> Summarize[生成摘要]
Summarize --> SubMessages[子 Agent messages]
Extract[提取：文件路径 + 关键决策 + 当前状态]
Summarize[摘要：压缩为 500-1000 tokens]graph LR
MainMessages[主 Agent messages] --> Extract[提取关键信息]
Extract --> Summarize[生成摘要]
Summarize --> SubMessages[子 Agent messages]
Extract[提取：文件路径 + 关键决策 + 当前状态]
Summarize[摘要：压缩为 500-1000 tokens]graph LR
MainMessages[主 Agent messages] --> Extract[提取关键信息]
Extract --> Summarize[生成摘要]
Summarize --> SubMessages[子 Agent messages]
Extract[提取：文件路径 + 关键决策 + 当前状态]
Summarize[摘要：压缩为 500-1000 tokens]摘要示例：
## 上下文摘要
### 任务背景
用户请求重构 app.ts 模块，提升代码质量。
### 当前进展
- 已读取文件：/src/app.ts（100行 TypeScript）
- 已分析结构：发现 validate 函数需要重构
- 已决定：重构 validate 函数，提取为独立模块
### 关键决策
1. 使用 Extract 工具提取 validate 函数
2. 新建 /src/validate.ts 文件
3. 更新 app.ts 引用
### 当前状态
准备执行 Extract 操作，需要子 Agent 审查代码质量。
---
子任务：审查 /src/app.ts 的 validate 函数，评估重构方案。摘要 Token 控制：
| 摘要长度 | Token 数量 | 适用场景 |
|---|---|---|
| 简短摘要 | 200-500 tokens | 简单任务 |
| 中等摘要 | 500-1000 tokens | 中等任务 |
| 详细摘要 | 1000-2000 tokens | 复杂任务（谨慎使用） |
子 Agent 的上下文管理
子 Agent 的 messages 生命周期
图表
代码
stateDiagram-v2
[*] --> Create: 主 Agent 派发
Create --> Init: 初始化 messages
Init --> Execute: 子 Agent 执行 Loop
Execute --> Complete: 任务完成
Complete --> Return: 返回结果
Return --> Destroy: 销毁 messages
Destroy --> [*]
note right of Create: 创建独立 messages
note right of Execute: 独立 Loop 执行
note right of Return: 只返回结果
note right of Destroy: 不保留历史stateDiagram-v2
[*] --> Create: 主 Agent 派发
Create --> Init: 初始化 messages
Init --> Execute: 子 Agent 执行 Loop
Execute --> Complete: 任务完成
Complete --> Return: 返回结果
Return --> Destroy: 销毁 messages
Destroy --> [*]
note right of Create: 创建独立 messages
note right of Execute: 独立 Loop 执行
note right of Return: 只返回结果
note right of Destroy: 不保留历史stateDiagram-v2
[*] --> Create: 主 Agent 派发
Create --> Init: 初始化 messages
Init --> Execute: 子 Agent 执行 Loop
Execute --> Complete: 任务完成
Complete --> Return: 返回结果
Return --> Destroy: 销毁 messages
Destroy --> [*]
note right of Create: 创建独立 messages
note right of Execute: 独立 Loop 执行
note right of Return: 只返回结果
note right of Destroy: 不保留历史stateDiagram-v2
[*] --> Create: 主 Agent 派发
Create --> Init: 初始化 messages
Init --> Execute: 子 Agent 执行 Loop
Execute --> Complete: 任务完成
Complete --> Return: 返回结果
Return --> Destroy: 销毁 messages
Destroy --> [*]
note right of Create: 创建独立 messages
note right of Execute: 独立 Loop 执行
note right of Return: 只返回结果
note right of Destroy: 不保留历史生命周期阶段：
| 阶段 | 说明 | 动作 |
|---|---|---|
| Create | 主 Agent 派发子 Agent | 创建子 Agent 实例 |
| Init | 初始化独立 messages | 创建 messages 数组 |
| Execute | 子 Agent 执行 Loop | 独立 Loop 循环 |
| Complete | 任务完成 | 生成最终结果 |
| Return | 返回结果给主 Agent | 只返回结果内容 |
| Destroy | 销毁 messages | 不保留历史，释放资源 |
子 Agent 的上下文限制
子 Agent 上下文窗口：
| 子 Agent 类型 | 上下文窗口 | 说明 |
|---|---|---|
| 障壁隔离 | 新建 messages（从零开始） | 200K tokens 可用 |
| 传递隔离 | 摘要 + 任务（约 1K tokens） | 199K tokens 可用 |
子 Agent 执行时间限制：
| 限制 | 说明 | 原因 |
|---|---|---|
| Loop 循环限制 | 子 Agent 最多 20-50 次循环 | 防止无限循环 |
| 工具调用限制 | 最多 15-40 次工具调用 | 防止过度调用 |
| 执行时间限制 | 最多 5-10 分钟 | 防止长时间执行 |
隔离机制的设计格言
格言
“大任务拆小, 每个小任务干净的上下文” —— 子 Agent 自己干活，只把结果带回来
设计要点
图表
代码
graph TB
subgraph DesignPoints["设计要点"]
D1[独立上下文
子Agent独立messages]
D2[不泄露历史
只返回结果]
D3[必要摘要
传递必要信息]
D4[销毁历史
执行完成销毁messages]
D5[防止污染
主Agent保持干净]
endgraph TB
subgraph DesignPoints["设计要点"]
D1[独立上下文
子Agent独立messages]
D2[不泄露历史
只返回结果]
D3[必要摘要
传递必要信息]
D4[销毁历史
执行完成销毁messages]
D5[防止污染
主Agent保持干净]
endgraph TB
subgraph DesignPoints["设计要点"]
D1[独立上下文
子Agent独立messages]
D2[不泄露历史
只返回结果]
D3[必要摘要
传递必要信息]
D4[销毁历史
执行完成销毁messages]
D5[防止污染
主Agent保持干净]
endgraph TB
subgraph DesignPoints["设计要点"]
D1[独立上下文<br/>子Agent独立messages]
D2[不泄露历史<br/>只返回结果]
D3[必要摘要<br/>传递必要信息]
D4[销毁历史<br/>执行完成销毁messages]
D5[防止污染<br/>主Agent保持干净]
end| 要点 | 说明 | 实现方式 |
|---|---|---|
| 独立上下文 | 子 Agent 使用独立 messages | 创建新 messages 数组 |
| 不泄露历史 | 只返回结果，不返回历史 | 返回 result_only |
| 必要摘要 | 传递必要信息，不传递完整历史 | 生成摘要 |
| 销毁历史 | 执行完成后销毁 messages | 不保留子 Agent 历史 |
| 防止污染 | 主 Agent 保持干净 | 隔离机制保护 |
隔离机制的典型应用
应用 1：代码审查
图表
代码
sequenceDiagram
participant Main as 主 Agent
participant Reviewer as code-reviewer Agent
Main->>Main: 完成代码修改
Main->>Reviewer: 派发审查任务（障壁隔离）
Note over Reviewer: 独立 messagesB
System Prompt + 任务
Reviewer->>Reviewer: Read 修改后的文件
Reviewer->>Reviewer: Grep 搜索代码模式
Reviewer->>Reviewer: 分析代码质量
Reviewer-->>Main: 返回审查报告（不泄露历史）
Main->>Main: 根据报告调整代码
Note over Reviewer: 销毁 messagesBsequenceDiagram
participant Main as 主 Agent
participant Reviewer as code-reviewer Agent
Main->>Main: 完成代码修改
Main->>Reviewer: 派发审查任务（障壁隔离）
Note over Reviewer: 独立 messagesB
System Prompt + 任务
Reviewer->>Reviewer: Read 修改后的文件
Reviewer->>Reviewer: Grep 搜索代码模式
Reviewer->>Reviewer: 分析代码质量
Reviewer-->>Main: 返回审查报告（不泄露历史）
Main->>Main: 根据报告调整代码
Note over Reviewer: 销毁 messagesBsequenceDiagram
participant Main as 主 Agent
participant Reviewer as code-reviewer Agent
Main->>Main: 完成代码修改
Main->>Reviewer: 派发审查任务（障壁隔离）
Note over Reviewer: 独立 messagesB
System Prompt + 任务
Reviewer->>Reviewer: Read 修改后的文件
Reviewer->>Reviewer: Grep 搜索代码模式
Reviewer->>Reviewer: 分析代码质量
Reviewer-->>Main: 返回审查报告（不泄露历史）
Main->>Main: 根据报告调整代码
Note over Reviewer: 销毁 messagesBsequenceDiagram
participant Main as 主 Agent
participant Reviewer as code-reviewer Agent
Main->>Main: 完成代码修改
Main->>Reviewer: 派发审查任务（障壁隔离）
Note over Reviewer: 独立 messagesB<br/>System Prompt + 任务
Reviewer->>Reviewer: Read 修改后的文件
Reviewer->>Reviewer: Grep 搜索代码模式
Reviewer->>Reviewer: 分析代码质量
Reviewer-->>Main: 返回审查报告（不泄露历史）
Main->>Main: 根据报告调整代码
Note over Reviewer: 销毁 messagesB隔离效果：
| 维度 | 主 Agent | code-reviewer Agent |
|---|---|---|
| messages | messagesA（保持干净） | messagesB（独立） |
| Token 消耗 | +1K（审查报告） | +15K（审查过程，不泄露） |
| 历史泄露 | ❌ 不泄露 | ❌ 销毁 |
应用 2：测试编写
图表
代码
sequenceDiagram
participant Main as 主 Agent
participant TDD as tdd-guide Agent
Main->>Main: 完成功能实现
Main->>TDD: 派发编写测试（传递隔离）
Note over TDD: 独立 messagesC
摘要 + 任务
TDD->>TDD: Read 代码文件
TDD->>TDD: Write 测试文件
TDD->>TDD: Bash 运行测试
TDD-->>Main: 返回测试结果（不泄露历史）
Main->>Main: 根据结果调整
Note over TDD: 销毁 messagesCsequenceDiagram
participant Main as 主 Agent
participant TDD as tdd-guide Agent
Main->>Main: 完成功能实现
Main->>TDD: 派发编写测试（传递隔离）
Note over TDD: 独立 messagesC
摘要 + 任务
TDD->>TDD: Read 代码文件
TDD->>TDD: Write 测试文件
TDD->>TDD: Bash 运行测试
TDD-->>Main: 返回测试结果（不泄露历史）
Main->>Main: 根据结果调整
Note over TDD: 销毁 messagesCsequenceDiagram
participant Main as 主 Agent
participant TDD as tdd-guide Agent
Main->>Main: 完成功能实现
Main->>TDD: 派发编写测试（传递隔离）
Note over TDD: 独立 messagesC
摘要 + 任务
TDD->>TDD: Read 代码文件
TDD->>TDD: Write 测试文件
TDD->>TDD: Bash 运行测试
TDD-->>Main: 返回测试结果（不泄露历史）
Main->>Main: 根据结果调整
Note over TDD: 销毁 messagesCsequenceDiagram
participant Main as 主 Agent
participant TDD as tdd-guide Agent
Main->>Main: 完成功能实现
Main->>TDD: 派发编写测试（传递隔离）
Note over TDD: 独立 messagesC<br/>摘要 + 任务
TDD->>TDD: Read 代码文件
TDD->>TDD: Write 测试文件
TDD->>TDD: Bash 运行测试
TDD-->>Main: 返回测试结果（不泄露历史）
Main->>Main: 根据结果调整
Note over TDD: 销毁 messagesC隔离效果：
| 维度 | 主 Agent | tdd-guide Agent |
|---|---|---|
| messages | messagesA（保持干净） | messagesC（独立） |
| Token 消耗 | +1K（测试结果） | +20K（测试过程，不泄露） |
| 历史泄露 | ❌ 不泄露 | ❌ 销毁 |
| 摘要传递 | 传递代码摘要 | 接收摘要 |
隔离机制 vs 不隔离对比
对比
| 维度 | 隔离机制 | 不隔离 |
|---|---|---|
| 上下文污染 | ❌ 不污染 | ✅ 污染 |
| Token 消耗 | ✅ 低（只返回结果） | ❌ 高（泄露历史） |
| 性能 | ✅ 高（上下文小） | ❌ 低（上下文大） |
| 成本 | ✅ 低（Token 省） | ❌ 高（Token 多） |
| 实现复杂度 | ⚠️ 需隔离机制 | ✅ 简单（直接共享） |
图表
代码
graph TB
subgraph Isolation["隔离机制"]
I1[不污染]
I2[Token低]
I3[性能高]
I4[成本低]
end
subgraph NoIsolation["不隔离"]
N1[污染严重]
N2[Token高]
N3[性能低]
N4[成本高]
end
style Isolation fill:#E0FFE0
style NoIsolation fill:#FFE0E0graph TB
subgraph Isolation["隔离机制"]
I1[不污染]
I2[Token低]
I3[性能高]
I4[成本低]
end
subgraph NoIsolation["不隔离"]
N1[污染严重]
N2[Token高]
N3[性能低]
N4[成本高]
end
style Isolation fill:#E0FFE0
style NoIsolation fill:#FFE0E0graph TB
subgraph Isolation["隔离机制"]
I1[不污染]
I2[Token低]
I3[性能高]
I4[成本低]
end
subgraph NoIsolation["不隔离"]
N1[污染严重]
N2[Token高]
N3[性能低]
N4[成本高]
end
style Isolation fill:#E0FFE0
style NoIsolation fill:#FFE0E0graph TB
subgraph Isolation["隔离机制"]
I1[不污染]
I2[Token低]
I3[性能高]
I4[成本低]
end
subgraph NoIsolation["不隔离"]
N1[污染严重]
N2[Token高]
N3[性能低]
N4[成本高]
end
style Isolation fill:#E0FFE0
style NoIsolation fill:#FFE0E0本章小结
- 隔离定义：子 Agent 独立上下文，只返回结果，不泄露历史
- 不隔离问题：上下文污染、爆炸、性能下降、成本增加
- 隔离好处：防止污染、节省空间、提升性能、降低成本、专业专注
- 两种模式：障壁隔离（全新 messages）、传递隔离（摘要 + 任务）
- 障壁隔离：不共享、Token 节省最多、完全独立任务
- 传递隔离：共享摘要、Token 节省中等、需要上下文任务
- 传递策略：传递任务描述、关键文件、关键决策、当前状态
- 摘要生成：压缩为 500-1000 tokens，传递必要信息
- 子 Agent 生命周期：Create → Init → Execute → Complete → Return → Destroy
- 设计格言：大任务拆小，每个小任务干净上下文
- 典型应用：代码审查、测试编写
预告：下一篇我们深入 Agent 间通信协议。
相关内容
- 第01章 Agent 的 70 年简史 —— 从符号推理到深度学习
- 第02章 LLM 时代的 Agent 革命 —— 2023-2026 爆发期
- 第03章 Harness 概念溯源 —— "模型是大脑，Harness是身体"
- 第04章 Harness 核心架构 —— 四层模型详解
- 第05章 Harness vs Agent vs Model —— 三者关系辨析
如果这篇文章对你有帮助，欢迎请我喝杯咖啡 ☕
支付宝
微信