第19章多智能体架构模式 —— 从单 Agent 到 Agent 团队

2026-05-23 约 2700 字预计阅读 13 分钟

上一篇我们了解了 Agent-Harness 协作模式。本章我们看多智能体架构——从单 Agent 到 Agent 团队。

多智能体架构是什么

一句话定义：多个 Agent 协作完成复杂任务——主 Agent + 子 Agent + 专用 Agent。

Multi-Agent Architecture = Agent 团队协作定位：Harness 的扩展层高级模式，处理复杂任务

图表代码

graph TB
    Main[主 Agent
协调指挥] --> Sub1[子 Agent 1
代码审查]
    Main --> Sub2[子 Agent 2
测试执行]
    Main --> Sub3[子 Agent 3
文档生成]
    
    Sub1 -->|返回结果| Main
    Sub2 -->|返回结果| Main
    Sub3 -->|返回结果| Main
    
    Main[团队指挥官]
    Sub1/Sub2/Sub3[专业队员]graph TB
    Main[主 Agent
协调指挥] --> Sub1[子 Agent 1
代码审查]
    Main --> Sub2[子 Agent 2
测试执行]
    Main --> Sub3[子 Agent 3
文档生成]
    
    Sub1 -->|返回结果| Main
    Sub2 -->|返回结果| Main
    Sub3 -->|返回结果| Main
    
    Main[团队指挥官]
    Sub1/Sub2/Sub3[专业队员]graph TB
    Main[主 Agent
协调指挥] --> Sub1[子 Agent 1
代码审查]
    Main --> Sub2[子 Agent 2
测试执行]
    Main --> Sub3[子 Agent 3
文档生成]
    
    Sub1 -->|返回结果| Main
    Sub2 -->|返回结果| Main
    Sub3 -->|返回结果| Main
    
    Main[团队指挥官]
    Sub1/Sub2/Sub3[专业队员]

graph TB
    Main[主 Agent<br/>协调指挥] --> Sub1[子 Agent 1<br/>代码审查]
    Main --> Sub2[子 Agent 2<br/>测试执行]
    Main --> Sub3[子 Agent 3<br/>文档生成]
    
    Sub1 -->|返回结果| Main
    Sub2 -->|返回结果| Main
    Sub3 -->|返回结果| Main
    
    Main[团队指挥官]
    Sub1/Sub2/Sub3[专业队员]

核心机制：

主 Agent：协调指挥，派发任务，收集结果
子 Agent：独立执行，专业分工，结果返回
协作模式：派发→执行→反馈→整合
隔离保护：子 Agent 上下文独立，不污染主 Agent

为什么需要多智能体

单 Agent 的局限

图表代码

graph TB
    subgraph SingleAgentLimit["单 Agent 局限"]
        L1[复杂任务难以处理
单Agent能力有限]
        L2[上下文快速溢出
历史累积爆炸]
        L3[专业知识不足
通用Agent缺领域知识]
        L4[并发效率低
串行执行慢]
    end
    
    style SingleAgentLimit fill:#FFE0E0graph TB
    subgraph SingleAgentLimit["单 Agent 局限"]
        L1[复杂任务难以处理
单Agent能力有限]
        L2[上下文快速溢出
历史累积爆炸]
        L3[专业知识不足
通用Agent缺领域知识]
        L4[并发效率低
串行执行慢]
    end
    
    style SingleAgentLimit fill:#FFE0E0graph TB
    subgraph SingleAgentLimit["单 Agent 局限"]
        L1[复杂任务难以处理
单Agent能力有限]
        L2[上下文快速溢出
历史累积爆炸]
        L3[专业知识不足
通用Agent缺领域知识]
        L4[并发效率低
串行执行慢]
    end
    
    style SingleAgentLimit fill:#FFE0E0

graph TB
    subgraph SingleAgentLimit["单 Agent 局限"]
        L1[复杂任务难以处理<br/>单Agent能力有限]
        L2[上下文快速溢出<br/>历史累积爆炸]
        L3[专业知识不足<br/>通用Agent缺领域知识]
        L4[并发效率低<br/>串行执行慢]
    end
    
    style SingleAgentLimit fill:#FFE0E0

局限	说明	示例
复杂任务难以处理	单 Agent 面对复杂任务能力有限	大型项目重构需多个专业 Agent
上下文快速溢出	历史累积导致上下文爆炸	10 次循环后 messages 数组过大
专业知识不足	通用 Agent 缺乏领域专业知识	安全审查需要专业安全 Agent
并发效率低	串行执行效率低	多个独立任务可并发执行

多智能体的优势

图表代码

graph TB
    subgraph MultiAgentAdv["多智能体优势"]
        A1[复杂任务拆解
专业化分工]
        A2[上下文隔离
不污染主Agent]
        A3[专业知识注入
专用Agent有领域知识]
        A4[并发执行
提升效率]
    end
    
    style MultiAgentAdv fill:#E0FFE0graph TB
    subgraph MultiAgentAdv["多智能体优势"]
        A1[复杂任务拆解
专业化分工]
        A2[上下文隔离
不污染主Agent]
        A3[专业知识注入
专用Agent有领域知识]
        A4[并发执行
提升效率]
    end
    
    style MultiAgentAdv fill:#E0FFE0graph TB
    subgraph MultiAgentAdv["多智能体优势"]
        A1[复杂任务拆解
专业化分工]
        A2[上下文隔离
不污染主Agent]
        A3[专业知识注入
专用Agent有领域知识]
        A4[并发执行
提升效率]
    end
    
    style MultiAgentAdv fill:#E0FFE0

graph TB
    subgraph MultiAgentAdv["多智能体优势"]
        A1[复杂任务拆解<br/>专业化分工]
        A2[上下文隔离<br/>不污染主Agent]
        A3[专业知识注入<br/>专用Agent有领域知识]
        A4[并发执行<br/>提升效率]
    end
    
    style MultiAgentAdv fill:#E0FFE0

优势	说明	示例
复杂任务拆解	拆解任务，专业化分工	重构→代码审查Agent + 测试Agent
上下文隔离	子 Agent 独立上下文，不污染主 Agent	子 Agent 上下文不泄露
专业知识注入	专用 Agent 有领域知识	安全Agent有安全专业知识
并发执行	多个任务并发执行	代码审查和测试并发执行

多智能体架构模式

三种核心模式

图表代码

graph TB
    subgraph Patterns["三种架构模式"]
        P1[层级模式
主Agent → 子Agent]
        P2[并行模式
主Agent → 多个子Agent并发]
        P3[协作模式
多个Agent平等协作]
    end
    
    P1 --> P2 --> P3graph TB
    subgraph Patterns["三种架构模式"]
        P1[层级模式
主Agent → 子Agent]
        P2[并行模式
主Agent → 多个子Agent并发]
        P3[协作模式
多个Agent平等协作]
    end
    
    P1 --> P2 --> P3graph TB
    subgraph Patterns["三种架构模式"]
        P1[层级模式
主Agent → 子Agent]
        P2[并行模式
主Agent → 多个子Agent并发]
        P3[协作模式
多个Agent平等协作]
    end
    
    P1 --> P2 --> P3

graph TB
    subgraph Patterns["三种架构模式"]
        P1[层级模式<br/>主Agent → 子Agent]
        P2[并行模式<br/>主Agent → 多个子Agent并发]
        P3[协作模式<br/>多个Agent平等协作]
    end
    
    P1 --> P2 --> P3

模式 1：层级模式（Hierarchical）

一句话定义：主 Agent 指挥，子 Agent 执行——明确的主从关系。

图表代码

graph TB
    Main[主 Agent
协调指挥] --> Plan[规划任务]
    Plan --> Dispatch1[派发子 Agent 1]
    Plan --> Dispatch2[派发子 Agent 2]
    
    Dispatch1 --> Sub1[子 Agent 1
执行任务A]
    Dispatch2 --> Sub2[子 Agent 2
执行任务B]
    
    Sub1 -->|返回结果| Collect[收集结果]
    Sub2 -->|返回结果| Collect
    
    Collect --> Integrate[整合结果]
    Integrate --> MainResult[返回最终结果]graph TB
    Main[主 Agent
协调指挥] --> Plan[规划任务]
    Plan --> Dispatch1[派发子 Agent 1]
    Plan --> Dispatch2[派发子 Agent 2]
    
    Dispatch1 --> Sub1[子 Agent 1
执行任务A]
    Dispatch2 --> Sub2[子 Agent 2
执行任务B]
    
    Sub1 -->|返回结果| Collect[收集结果]
    Sub2 -->|返回结果| Collect
    
    Collect --> Integrate[整合结果]
    Integrate --> MainResult[返回最终结果]graph TB
    Main[主 Agent
协调指挥] --> Plan[规划任务]
    Plan --> Dispatch1[派发子 Agent 1]
    Plan --> Dispatch2[派发子 Agent 2]
    
    Dispatch1 --> Sub1[子 Agent 1
执行任务A]
    Dispatch2 --> Sub2[子 Agent 2
执行任务B]
    
    Sub1 -->|返回结果| Collect[收集结果]
    Sub2 -->|返回结果| Collect
    
    Collect --> Integrate[整合结果]
    Integrate --> MainResult[返回最终结果]

graph TB
    Main[主 Agent<br/>协调指挥] --> Plan[规划任务]
    Plan --> Dispatch1[派发子 Agent 1]
    Plan --> Dispatch2[派发子 Agent 2]
    
    Dispatch1 --> Sub1[子 Agent 1<br/>执行任务A]
    Dispatch2 --> Sub2[子 Agent 2<br/>执行任务B]
    
    Sub1 -->|返回结果| Collect[收集结果]
    Sub2 -->|返回结果| Collect
    
    Collect --> Integrate[整合结果]
    Integrate --> MainResult[返回最终结果]

特点：

特点	说明	适用场景
主从关系	主 Agent 指挥，子 Agent 执行	需要协调的复杂任务
任务派发	主 Agent 拆解任务并派发	大型任务拆解
结果整合	主 Agent 整合子 Agent 结果	多个子任务结果汇总
上下文隔离	子 Agent 独立上下文	防止上下文污染

实现方式：

# 层级模式实现
def hierarchical_mode(main_agent, task):
    # 1. 主 Agent 规划
    plan = main_agent.plan(task)
    
    # 2. 拆解任务
    sub_tasks = split_task(plan)
    
    # 3. 派发子 Agent
    results = []
    for sub_task in sub_tasks:
        # 启动子 Agent（独立上下文）
        sub_agent = spawn_subagent(sub_task["type"])
        result = sub_agent.execute(sub_task)
        results.append(result)
    
    # 4. 整合结果
    final_result = main_agent.integrate(results)
    
    return final_result

模式 2：并行模式（Parallel）

一句话定义：多个子 Agent 并发执行——提升效率。

图表代码

graph TB
    Main[主 Agent] --> Plan[规划任务]
    Plan --> Split[拆解为独立子任务]
    
    Split --> Parallel{并行派发}
    
    Parallel -->|并发| Sub1[子 Agent 1
执行任务A]
    Parallel -->|并发| Sub2[子 Agent 2
执行任务B]
    Parallel -->|并发| Sub3[子 Agent 3
执行任务C]
    
    Sub1 -->|返回| Collect[收集结果]
    Sub2 -->|返回| Collect
    Sub3 -->|返回| Collect
    
    Collect --> Integrate[整合结果]graph TB
    Main[主 Agent] --> Plan[规划任务]
    Plan --> Split[拆解为独立子任务]
    
    Split --> Parallel{并行派发}
    
    Parallel -->|并发| Sub1[子 Agent 1
执行任务A]
    Parallel -->|并发| Sub2[子 Agent 2
执行任务B]
    Parallel -->|并发| Sub3[子 Agent 3
执行任务C]
    
    Sub1 -->|返回| Collect[收集结果]
    Sub2 -->|返回| Collect
    Sub3 -->|返回| Collect
    
    Collect --> Integrate[整合结果]graph TB
    Main[主 Agent] --> Plan[规划任务]
    Plan --> Split[拆解为独立子任务]
    
    Split --> Parallel{并行派发}
    
    Parallel -->|并发| Sub1[子 Agent 1
执行任务A]
    Parallel -->|并发| Sub2[子 Agent 2
执行任务B]
    Parallel -->|并发| Sub3[子 Agent 3
执行任务C]
    
    Sub1 -->|返回| Collect[收集结果]
    Sub2 -->|返回| Collect
    Sub3 -->|返回| Collect
    
    Collect --> Integrate[整合结果]

graph TB
    Main[主 Agent] --> Plan[规划任务]
    Plan --> Split[拆解为独立子任务]
    
    Split --> Parallel{并行派发}
    
    Parallel -->|并发| Sub1[子 Agent 1<br/>执行任务A]
    Parallel -->|并发| Sub2[子 Agent 2<br/>执行任务B]
    Parallel -->|并发| Sub3[子 Agent 3<br/>执行任务C]
    
    Sub1 -->|返回| Collect[收集结果]
    Sub2 -->|返回| Collect
    Sub3 -->|返回| Collect
    
    Collect --> Integrate[整合结果]

特点：

特点	说明	适用场景
并发执行	多个子 Agent 同时执行	多个独立任务
效率提升	并发执行节省时间	大量相似任务
独立任务	子任务相互独立	代码审查 + 测试 + 文档
结果汇总	主 Agent 汇总所有结果	整合多个专业结果

实现方式：

# 并行模式实现
def parallel_mode(main_agent, task):
    # 1. 主 Agent 规划
    sub_tasks = main_agent.split_parallel(task)
    
    # 2. 并发派发子 Agent
    import concurrent.futures
    
    results = []
    with concurrent.futures.ThreadPoolExecutor() as executor:
        futures = []
        for sub_task in sub_tasks:
            sub_agent = spawn_subagent(sub_task["type"])
            future = executor.submit(sub_agent.execute, sub_task)
            futures.append(future)
        
        # 3. 等待所有结果
        for future in concurrent.futures.as_completed(futures):
            results.append(future.result())
    
    # 4. 整合结果
    final_result = main_agent.integrate(results)
    
    return final_result

模式 3：协作模式（Collaborative）

一句话定义：多个 Agent 平等协作——无明确主从关系。

图表代码

graph TB
    Agents[多个 Agent
平等协作] -->|共享状态| SharedState[共享状态
messages/tasks]
    
    Agent1[Agent 1
代码专家] <-->|协作| Agent2[Agent 2
测试专家]
    Agent1 <-->|协作| Agent3[Agent 3
文档专家]
    Agent2 <-->|协作| Agent3
    
    Agent1 -->|贡献| SharedState
    Agent2 -->|贡献| SharedState
    Agent3 -->|贡献| SharedState
    
    SharedState -->|读取| Agentsgraph TB
    Agents[多个 Agent
平等协作] -->|共享状态| SharedState[共享状态
messages/tasks]
    
    Agent1[Agent 1
代码专家] <-->|协作| Agent2[Agent 2
测试专家]
    Agent1 <-->|协作| Agent3[Agent 3
文档专家]
    Agent2 <-->|协作| Agent3
    
    Agent1 -->|贡献| SharedState
    Agent2 -->|贡献| SharedState
    Agent3 -->|贡献| SharedState
    
    SharedState -->|读取| Agentsgraph TB
    Agents[多个 Agent
平等协作] -->|共享状态| SharedState[共享状态
messages/tasks]
    
    Agent1[Agent 1
代码专家] <-->|协作| Agent2[Agent 2
测试专家]
    Agent1 <-->|协作| Agent3[Agent 3
文档专家]
    Agent2 <-->|协作| Agent3
    
    Agent1 -->|贡献| SharedState
    Agent2 -->|贡献| SharedState
    Agent3 -->|贡献| SharedState
    
    SharedState -->|读取| Agents

graph TB
    Agents[多个 Agent<br/>平等协作] -->|共享状态| SharedState[共享状态<br/>messages/tasks]
    
    Agent1[Agent 1<br/>代码专家] <-->|协作| Agent2[Agent 2<br/>测试专家]
    Agent1 <-->|协作| Agent3[Agent 3<br/>文档专家]
    Agent2 <-->|协作| Agent3
    
    Agent1 -->|贡献| SharedState
    Agent2 -->|贡献| SharedState
    Agent3 -->|贡献| SharedState
    
    SharedState -->|读取| Agents

特点：

特点	说明	适用场景
平等协作	无明确主从关系	专家团队协作
共享状态	共享 messages/tasks	需要实时信息共享
专业分工	每个 Agent 有专业领域	多专业协作
动态协作	协作关系动态调整	复杂问题协作解决

实现方式：

# 协作模式实现
def collaborative_mode(agents, task):
    # 1. 初始化共享状态
    shared_state = {
        "messages": [],
        "tasks": [],
        "context": {}
    }
    
    # 2. 每个 Agent 贡献
    results = []
    for agent in agents:
        # Agent 读取共享状态
        agent.observe(shared_state)
        
        # Agent 执行任务
        result = agent.execute(task)
        
        # Agent 贡献结果
        shared_state["messages"].append(result)
        results.append(result)
    
    # 3. 整合结果
    final_result = integrate_collaborative(results)
    
    return final_result

主 Agent 与子 Agent

主 Agent 的职责

图表代码

graph TB
    subgraph MainAgentRole["主 Agent 职责"]
        M1[任务接收
接收用户任务]
        M2[任务规划
拆解任务为子任务]
        M3[Agent 选择
选择合适的子 Agent]
        M4[任务派发
派发任务给子 Agent]
        M5[结果收集
收集子 Agent 结果]
        M6[结果整合
整合所有子 Agent 结果]
        M7[最终输出
返回最终结果给用户]
    end
    
    M1 --> M2 --> M3 --> M4 --> M5 --> M6 --> M7graph TB
    subgraph MainAgentRole["主 Agent 职责"]
        M1[任务接收
接收用户任务]
        M2[任务规划
拆解任务为子任务]
        M3[Agent 选择
选择合适的子 Agent]
        M4[任务派发
派发任务给子 Agent]
        M5[结果收集
收集子 Agent 结果]
        M6[结果整合
整合所有子 Agent 结果]
        M7[最终输出
返回最终结果给用户]
    end
    
    M1 --> M2 --> M3 --> M4 --> M5 --> M6 --> M7graph TB
    subgraph MainAgentRole["主 Agent 职责"]
        M1[任务接收
接收用户任务]
        M2[任务规划
拆解任务为子任务]
        M3[Agent 选择
选择合适的子 Agent]
        M4[任务派发
派发任务给子 Agent]
        M5[结果收集
收集子 Agent 结果]
        M6[结果整合
整合所有子 Agent 结果]
        M7[最终输出
返回最终结果给用户]
    end
    
    M1 --> M2 --> M3 --> M4 --> M5 --> M6 --> M7

graph TB
    subgraph MainAgentRole["主 Agent 职责"]
        M1[任务接收<br/>接收用户任务]
        M2[任务规划<br/>拆解任务为子任务]
        M3[Agent 选择<br/>选择合适的子 Agent]
        M4[任务派发<br/>派发任务给子 Agent]
        M5[结果收集<br/>收集子 Agent 结果]
        M6[结果整合<br/>整合所有子 Agent 结果]
        M7[最终输出<br/>返回最终结果给用户]
    end
    
    M1 --> M2 --> M3 --> M4 --> M5 --> M6 --> M7

职责详解：

职责	说明	示例
任务接收	接收用户的复杂任务	“重构这个模块并生成文档”
任务规划	拆解任务为多个子任务	拆解为：代码重构 + 测试 + 文档
Agent 选择	选择合适的子 Agent 类型	选择 code-reviewer、tdd-guide、doc-updater
任务派发	派发任务给子 Agent	派发代码审查给 code-reviewer Agent
结果收集	收集所有子 Agent 的结果	收集审查报告、测试结果、文档
结果整合	整合结果，形成最终输出	整合为完整的重构报告
最终输出	返回最终结果给用户	返回完整的重构结果和文档

子 Agent 的职责

图表代码

graph TB
    subgraph SubAgentRole["子 Agent 职责"]
        S1[任务接收
接收主 Agent 派发]
        S2[独立推理
独立上下文推理]
        S3[工具调用
调用工具执行任务]
        S4[结果生成
生成专业结果]
        S5[结果返回
返回结果给主 Agent]
    end
    
    S1 --> S2 --> S3 --> S4 --> S5graph TB
    subgraph SubAgentRole["子 Agent 职责"]
        S1[任务接收
接收主 Agent 派发]
        S2[独立推理
独立上下文推理]
        S3[工具调用
调用工具执行任务]
        S4[结果生成
生成专业结果]
        S5[结果返回
返回结果给主 Agent]
    end
    
    S1 --> S2 --> S3 --> S4 --> S5graph TB
    subgraph SubAgentRole["子 Agent 职责"]
        S1[任务接收
接收主 Agent 派发]
        S2[独立推理
独立上下文推理]
        S3[工具调用
调用工具执行任务]
        S4[结果生成
生成专业结果]
        S5[结果返回
返回结果给主 Agent]
    end
    
    S1 --> S2 --> S3 --> S4 --> S5

graph TB
    subgraph SubAgentRole["子 Agent 职责"]
        S1[任务接收<br/>接收主 Agent 派发]
        S2[独立推理<br/>独立上下文推理]
        S3[工具调用<br/>调用工具执行任务]
        S4[结果生成<br/>生成专业结果]
        S5[结果返回<br/>返回结果给主 Agent]
    end
    
    S1 --> S2 --> S3 --> S4 --> S5

职责详解：

职责	说明	示例
任务接收	接收主 Agent 派发的任务	接收"审查 app.ts 文件"任务
独立推理	使用独立上下文推理	子 Agent 自己的 messages 数组
工具调用	调用工具执行具体任务	调用 Read、Grep 工具审查代码
结果生成	生成专业领域结果	生成代码审查报告
结果返回	返回结果给主 Agent（不泄露历史）	只返回审查报告，不泄露上下文

子 Agent 类型

常见子 Agent 类型：

Agent 类型	专用领域	典型任务	提供的工具
code-reviewer	代码审查	审查代码质量	Read、Grep、Glob
security-reviewer	安全审查	安全漏洞检查	Read、Grep、Bash
tdd-guide	测试驱动开发	编写测试	Write、Edit、Bash
doc-updater	文档生成	生成文档	Write、Read
planner	规划	制定实现计划	Read、Glob
build-error-resolver	构建错误	解决构建问题	Bash、Read、Edit

图表代码

graph TB
    subgraph SubAgentTypes["子 Agent 类型"]
        T1[code-reviewer
代码审查]
        T2[security-reviewer
安全审查]
        T3[tdd-guide
测试开发]
        T4[doc-updater
文档生成]
        T5[planner
规划]
        T6[build-error-resolver
构建错误]
    end
    
    Main[主 Agent] -->|派发| T1
    Main -->|派发| T2
    Main -->|派发| T3
    Main -->|派发| T4
    Main -->|派发| T5
    Main -->|派发| T6graph TB
    subgraph SubAgentTypes["子 Agent 类型"]
        T1[code-reviewer
代码审查]
        T2[security-reviewer
安全审查]
        T3[tdd-guide
测试开发]
        T4[doc-updater
文档生成]
        T5[planner
规划]
        T6[build-error-resolver
构建错误]
    end
    
    Main[主 Agent] -->|派发| T1
    Main -->|派发| T2
    Main -->|派发| T3
    Main -->|派发| T4
    Main -->|派发| T5
    Main -->|派发| T6graph TB
    subgraph SubAgentTypes["子 Agent 类型"]
        T1[code-reviewer
代码审查]
        T2[security-reviewer
安全审查]
        T3[tdd-guide
测试开发]
        T4[doc-updater
文档生成]
        T5[planner
规划]
        T6[build-error-resolver
构建错误]
    end
    
    Main[主 Agent] -->|派发| T1
    Main -->|派发| T2
    Main -->|派发| T3
    Main -->|派发| T4
    Main -->|派发| T5
    Main -->|派发| T6

graph TB
    subgraph SubAgentTypes["子 Agent 类型"]
        T1[code-reviewer<br/>代码审查]
        T2[security-reviewer<br/>安全审查]
        T3[tdd-guide<br/>测试开发]
        T4[doc-updater<br/>文档生成]
        T5[planner<br/>规划]
        T6[build-error-resolver<br/>构建错误]
    end
    
    Main[主 Agent] -->|派发| T1
    Main -->|派发| T2
    Main -->|派发| T3
    Main -->|派发| T4
    Main -->|派发| T5
    Main -->|派发| T6

子 Agent 派发机制

派发流程

图表代码

sequenceDiagram
    participant Main as 主 Agent
    participant AgentTool as Agent 工具
    participant Sub as 子 Agent
    participant Harness as Harness
    
    Main->>Main: 规划任务，拆解子任务
    
    Main->>AgentTool: 调用 Agent 工具
    
    AgentTool->>Harness: 请求启动子 Agent
    
    Harness->>Sub: 创建子 Agent（独立上下文）
    
    Sub->>Sub: 接收任务，独立推理
    
    Sub->>Harness: 调用工具执行任务
    
    Harness-->>Sub: 返回工具结果
    
    Sub->>Sub: 继续推理直到完成
    
    Sub-->>Harness: 返回最终结果
    
    Harness-->>AgentTool: 返回子 Agent 结果
    
    AgentTool-->>Main: 返回结果（不泄露历史）
    
    Main->>Main: 整合结果sequenceDiagram
    participant Main as 主 Agent
    participant AgentTool as Agent 工具
    participant Sub as 子 Agent
    participant Harness as Harness
    
    Main->>Main: 规划任务，拆解子任务
    
    Main->>AgentTool: 调用 Agent 工具
    
    AgentTool->>Harness: 请求启动子 Agent
    
    Harness->>Sub: 创建子 Agent（独立上下文）
    
    Sub->>Sub: 接收任务，独立推理
    
    Sub->>Harness: 调用工具执行任务
    
    Harness-->>Sub: 返回工具结果
    
    Sub->>Sub: 继续推理直到完成
    
    Sub-->>Harness: 返回最终结果
    
    Harness-->>AgentTool: 返回子 Agent 结果
    
    AgentTool-->>Main: 返回结果（不泄露历史）
    
    Main->>Main: 整合结果sequenceDiagram
    participant Main as 主 Agent
    participant AgentTool as Agent 工具
    participant Sub as 子 Agent
    participant Harness as Harness
    
    Main->>Main: 规划任务，拆解子任务
    
    Main->>AgentTool: 调用 Agent 工具
    
    AgentTool->>Harness: 请求启动子 Agent
    
    Harness->>Sub: 创建子 Agent（独立上下文）
    
    Sub->>Sub: 接收任务，独立推理
    
    Sub->>Harness: 调用工具执行任务
    
    Harness-->>Sub: 返回工具结果
    
    Sub->>Sub: 继续推理直到完成
    
    Sub-->>Harness: 返回最终结果
    
    Harness-->>AgentTool: 返回子 Agent 结果
    
    AgentTool-->>Main: 返回结果（不泄露历史）
    
    Main->>Main: 整合结果

sequenceDiagram
    participant Main as 主 Agent
    participant AgentTool as Agent 工具
    participant Sub as 子 Agent
    participant Harness as Harness
    
    Main->>Main: 规划任务，拆解子任务
    
    Main->>AgentTool: 调用 Agent 工具
    
    AgentTool->>Harness: 请求启动子 Agent
    
    Harness->>Sub: 创建子 Agent（独立上下文）
    
    Sub->>Sub: 接收任务，独立推理
    
    Sub->>Harness: 调用工具执行任务
    
    Harness-->>Sub: 返回工具结果
    
    Sub->>Sub: 继续推理直到完成
    
    Sub-->>Harness: 返回最终结果
    
    Harness-->>AgentTool: 返回子 Agent 结果
    
    AgentTool-->>Main: 返回结果（不泄露历史）
    
    Main->>Main: 整合结果

派发实现

Agent 工具调用：

# 主 Agent 派发子 Agent
def dispatch_subagent(main_agent, subagent_type, task):
    # 调用 Agent 工具
    tool_use = {
        "name": "Agent",
        "parameters": {
            "subagent_type": subagent_type,  # 如 "code-reviewer"
            "prompt": task  # 子任务描述
        }
    }
    
    # Harness 启动子 Agent
    sub_agent_result = harness.execute_agent_tool(tool_use)
    
    # 返回结果（只返回结果，不泄露历史）
    return sub_agent_result

子 Agent 独立执行：

# Harness 启动子 Agent
def execute_agent_tool(tool_params):
    subagent_type = tool_params["subagent_type"]
    prompt = tool_params["prompt"]
    
    # 1. 创建子 Agent（独立上下文）
    sub_messages = [
        {"role": "system", "content": get_subagent_system_prompt(subagent_type)},
        {"role": "user", "content": prompt}
    ]
    
    # 2. 子 Agent 执行（独立 Loop）
    sub_result = run_agent_loop(sub_messages)
    
    # 3. 只返回结果（不泄露历史）
    return sub_result.content  # 只返回最终内容

子 Agent 上下文隔离

隔离机制

图表代码

graph TB
    subgraph MainContext["主 Agent 上下文"]
        M1[messagesA
主对话历史]
        M2[tasksA
主任务系统]
    end
    
    subgraph SubContext["子 Agent 上下文（独立）"]
        S1[messagesB
子对话历史]
        S2[tasksB
子任务系统]
    end
    
    Main[主 Agent] -->|派发
不泄露messagesA| Sub[子 Agent]
    
    Sub -->|执行
独立messagesB| Task[完成任务]
    
    Task -->|返回
只返回结果
不泄露messagesB| Result[返回主 Agent]
    
    Result -->|追加| Main
    
    style MainContext fill:#E0FFE0
    style SubContext fill:#FFE0E0graph TB
    subgraph MainContext["主 Agent 上下文"]
        M1[messagesA
主对话历史]
        M2[tasksA
主任务系统]
    end
    
    subgraph SubContext["子 Agent 上下文（独立）"]
        S1[messagesB
子对话历史]
        S2[tasksB
子任务系统]
    end
    
    Main[主 Agent] -->|派发
不泄露messagesA| Sub[子 Agent]
    
    Sub -->|执行
独立messagesB| Task[完成任务]
    
    Task -->|返回
只返回结果
不泄露messagesB| Result[返回主 Agent]
    
    Result -->|追加| Main
    
    style MainContext fill:#E0FFE0
    style SubContext fill:#FFE0E0graph TB
    subgraph MainContext["主 Agent 上下文"]
        M1[messagesA
主对话历史]
        M2[tasksA
主任务系统]
    end
    
    subgraph SubContext["子 Agent 上下文（独立）"]
        S1[messagesB
子对话历史]
        S2[tasksB
子任务系统]
    end
    
    Main[主 Agent] -->|派发
不泄露messagesA| Sub[子 Agent]
    
    Sub -->|执行
独立messagesB| Task[完成任务]
    
    Task -->|返回
只返回结果
不泄露messagesB| Result[返回主 Agent]
    
    Result -->|追加| Main
    
    style MainContext fill:#E0FFE0
    style SubContext fill:#FFE0E0

graph TB
    subgraph MainContext["主 Agent 上下文"]
        M1[messagesA<br/>主对话历史]
        M2[tasksA<br/>主任务系统]
    end
    
    subgraph SubContext["子 Agent 上下文（独立）"]
        S1[messagesB<br/>子对话历史]
        S2[tasksB<br/>子任务系统]
    end
    
    Main[主 Agent] -->|派发<br/>不泄露messagesA| Sub[子 Agent]
    
    Sub -->|执行<br/>独立messagesB| Task[完成任务]
    
    Task -->|返回<br/>只返回结果<br/>不泄露messagesB| Result[返回主 Agent]
    
    Result -->|追加| Main
    
    style MainContext fill:#E0FFE0
    style SubContext fill:#FFE0E0

隔离规则：

隔离维度	主 Agent	子 Agent	说明
messages 数组	messagesA	messagesB（独立）	子 Agent 独立历史
任务系统	tasksA	tasksB（可选独立）	子 Agent 独立任务
上下文共享	❌ 不共享	❌ 不共享	完全隔离
历史泄露	❌ 不泄露	❌ 不泄露	只返回结果

隔离的好处

图表代码

graph TB
    subgraph IsolationBenefits["隔离好处"]
        B1[防止污染
子Agent不污染主Agent]
        B2[保持干净
主Agent上下文不受影响]
        B3[节省空间
子Agent历史不占用主上下文]
        B4[专业专注
子Agent专注专业任务]
    end
    
    style IsolationBenefits fill:#E0FFE0graph TB
    subgraph IsolationBenefits["隔离好处"]
        B1[防止污染
子Agent不污染主Agent]
        B2[保持干净
主Agent上下文不受影响]
        B3[节省空间
子Agent历史不占用主上下文]
        B4[专业专注
子Agent专注专业任务]
    end
    
    style IsolationBenefits fill:#E0FFE0graph TB
    subgraph IsolationBenefits["隔离好处"]
        B1[防止污染
子Agent不污染主Agent]
        B2[保持干净
主Agent上下文不受影响]
        B3[节省空间
子Agent历史不占用主上下文]
        B4[专业专注
子Agent专注专业任务]
    end
    
    style IsolationBenefits fill:#E0FFE0

graph TB
    subgraph IsolationBenefits["隔离好处"]
        B1[防止污染<br/>子Agent不污染主Agent]
        B2[保持干净<br/>主Agent上下文不受影响]
        B3[节省空间<br/>子Agent历史不占用主上下文]
        B4[专业专注<br/>子Agent专注专业任务]
    end
    
    style IsolationBenefits fill:#E0FFE0

好处	说明	价值
防止污染	子 Agent 上下文不泄露到主 Agent	主 Agent 保持干净
保持干净	主 Agent 上下文不受子 Agent 影响	主 Agent 可继续工作
节省空间	子 Agent 历史不占用主上下文	防止上下文溢出
专业专注	子 Agent 专注专业任务	提升专业能力

多 Agent 协作场景

场景 1：完整重构流程

图表代码

sequenceDiagram
    participant User as 用户
    participant Main as 主 Agent
    participant Planner as planner Agent
    participant Reviewer as code-reviewer Agent
    participant TDD as tdd-guide Agent
    participant Doc as doc-updater Agent
    
    User->>Main: 重构 app.ts 并生成文档
    
    Main->>Planner: 派发规划任务
    Planner-->>Main: 返回实现计划
    
    Main->>Main: 根据计划拆解
    
    Main->>Reviewer: 派发代码审查
    Reviewer-->>Main: 返回审查报告
    
    Main->>Main: 根据报告修改代码
    
    Main->>TDD: 派发编写测试
    TDD-->>Main: 返回测试结果
    
    Main->>Doc: 派发生成文档
    Doc-->>Main: 返回文档
    
    Main->>Main: 整合所有结果
    Main-->>User: 返回完整重构结果sequenceDiagram
    participant User as 用户
    participant Main as 主 Agent
    participant Planner as planner Agent
    participant Reviewer as code-reviewer Agent
    participant TDD as tdd-guide Agent
    participant Doc as doc-updater Agent
    
    User->>Main: 重构 app.ts 并生成文档
    
    Main->>Planner: 派发规划任务
    Planner-->>Main: 返回实现计划
    
    Main->>Main: 根据计划拆解
    
    Main->>Reviewer: 派发代码审查
    Reviewer-->>Main: 返回审查报告
    
    Main->>Main: 根据报告修改代码
    
    Main->>TDD: 派发编写测试
    TDD-->>Main: 返回测试结果
    
    Main->>Doc: 派发生成文档
    Doc-->>Main: 返回文档
    
    Main->>Main: 整合所有结果
    Main-->>User: 返回完整重构结果sequenceDiagram
    participant User as 用户
    participant Main as 主 Agent
    participant Planner as planner Agent
    participant Reviewer as code-reviewer Agent
    participant TDD as tdd-guide Agent
    participant Doc as doc-updater Agent
    
    User->>Main: 重构 app.ts 并生成文档
    
    Main->>Planner: 派发规划任务
    Planner-->>Main: 返回实现计划
    
    Main->>Main: 根据计划拆解
    
    Main->>Reviewer: 派发代码审查
    Reviewer-->>Main: 返回审查报告
    
    Main->>Main: 根据报告修改代码
    
    Main->>TDD: 派发编写测试
    TDD-->>Main: 返回测试结果
    
    Main->>Doc: 派发生成文档
    Doc-->>Main: 返回文档
    
    Main->>Main: 整合所有结果
    Main-->>User: 返回完整重构结果

sequenceDiagram
    participant User as 用户
    participant Main as 主 Agent
    participant Planner as planner Agent
    participant Reviewer as code-reviewer Agent
    participant TDD as tdd-guide Agent
    participant Doc as doc-updater Agent
    
    User->>Main: 重构 app.ts 并生成文档
    
    Main->>Planner: 派发规划任务
    Planner-->>Main: 返回实现计划
    
    Main->>Main: 根据计划拆解
    
    Main->>Reviewer: 派发代码审查
    Reviewer-->>Main: 返回审查报告
    
    Main->>Main: 根据报告修改代码
    
    Main->>TDD: 派发编写测试
    TDD-->>Main: 返回测试结果
    
    Main->>Doc: 派发生成文档
    Doc-->>Main: 返回文档
    
    Main->>Main: 整合所有结果
    Main-->>User: 返回完整重构结果

协作步骤：

步骤	主 Agent	子 Agent
1	接收任务	-
2	派发规划	planner Agent 规划
3	拆解任务	-
4	派发审查	code-reviewer Agent 审查
5	修改代码	-
6	派发测试	tdd-guide Agent 测试
7	派发文档	doc-updater Agent 文档
8	整合结果	-

场景 2：安全审查流程

图表代码

sequenceDiagram
    participant Main as 主 Agent
    participant Security as security-reviewer Agent
    participant Fix as fix Agent
    
    Main->>Security: 派发安全审查
    Security->>Security: 审查代码
    Security-->>Main: 返回安全问题列表
    
    Main->>Main: 分析安全问题
    
    Main->>Fix: 派发修复问题
    Fix->>Fix: 修复安全问题
    Fix-->>Main: 返回修复结果
    
    Main->>Security: 派发复查
    Security-->>Main: 返回复查结果
    
    Main->>Main: 整合审查报告
    Main-->>User: 返回最终报告sequenceDiagram
    participant Main as 主 Agent
    participant Security as security-reviewer Agent
    participant Fix as fix Agent
    
    Main->>Security: 派发安全审查
    Security->>Security: 审查代码
    Security-->>Main: 返回安全问题列表
    
    Main->>Main: 分析安全问题
    
    Main->>Fix: 派发修复问题
    Fix->>Fix: 修复安全问题
    Fix-->>Main: 返回修复结果
    
    Main->>Security: 派发复查
    Security-->>Main: 返回复查结果
    
    Main->>Main: 整合审查报告
    Main-->>User: 返回最终报告sequenceDiagram
    participant Main as 主 Agent
    participant Security as security-reviewer Agent
    participant Fix as fix Agent
    
    Main->>Security: 派发安全审查
    Security->>Security: 审查代码
    Security-->>Main: 返回安全问题列表
    
    Main->>Main: 分析安全问题
    
    Main->>Fix: 派发修复问题
    Fix->>Fix: 修复安全问题
    Fix-->>Main: 返回修复结果
    
    Main->>Security: 派发复查
    Security-->>Main: 返回复查结果
    
    Main->>Main: 整合审查报告
    Main-->>User: 返回最终报告

sequenceDiagram
    participant Main as 主 Agent
    participant Security as security-reviewer Agent
    participant Fix as fix Agent
    
    Main->>Security: 派发安全审查
    Security->>Security: 审查代码
    Security-->>Main: 返回安全问题列表
    
    Main->>Main: 分析安全问题
    
    Main->>Fix: 派发修复问题
    Fix->>Fix: 修复安全问题
    Fix-->>Main: 返回修复结果
    
    Main->>Security: 派发复查
    Security-->>Main: 返回复查结果
    
    Main->>Main: 整合审查报告
    Main-->>User: 返回最终报告

协作步骤：

步骤	主 Agent	子 Agent
1	派发安全审查	security-reviewer Agent 审查
2	分析问题	-
3	派发修复	fix Agent 修复
4	派发复查	security-reviewer Agent 复查
5	整合报告	-

多智能体架构设计原则

设计原则

图表代码

graph TB
    subgraph DesignPrinciples["设计原则"]
        D1[任务拆解
大任务拆小任务]
        D2[专业分工
每个子Agent有专业]
        D3[上下文隔离
子Agent独立上下文]
        D4[结果整合
主Agent整合结果]
        D5[并行优先
独立任务并行执行]
    endgraph TB
    subgraph DesignPrinciples["设计原则"]
        D1[任务拆解
大任务拆小任务]
        D2[专业分工
每个子Agent有专业]
        D3[上下文隔离
子Agent独立上下文]
        D4[结果整合
主Agent整合结果]
        D5[并行优先
独立任务并行执行]
    endgraph TB
    subgraph DesignPrinciples["设计原则"]
        D1[任务拆解
大任务拆小任务]
        D2[专业分工
每个子Agent有专业]
        D3[上下文隔离
子Agent独立上下文]
        D4[结果整合
主Agent整合结果]
        D5[并行优先
独立任务并行执行]
    end

graph TB
    subgraph DesignPrinciples["设计原则"]
        D1[任务拆解<br/>大任务拆小任务]
        D2[专业分工<br/>每个子Agent有专业]
        D3[上下文隔离<br/>子Agent独立上下文]
        D4[结果整合<br/>主Agent整合结果]
        D5[并行优先<br/>独立任务并行执行]
    end

原则	说明	实现方式
任务拆解	大任务拆解为小任务	主 Agent 规划拆解
专业分工	每个子 Agent 有专业领域	选择合适子 Agent 类型
上下文隔离	子 Agent 独立上下文，不污染主 Agent	Agent 工具隔离机制
结果整合	主 Agent 整合所有子 Agent 结果	主 Agent 整合逻辑
并行优先	独立任务优先并行执行	并行模式派发

本章小结

多智能体定义：多个 Agent 协作完成复杂任务——主 Agent + 子 Agent + 专用 Agent
单 Agent 局限：复杂任务难处理、上下文溢出、专业知识不足、并发效率低
多智能体优势：复杂任务拆解、上下文隔离、专业知识注入、并发执行
三种模式：层级模式（主从）、并行模式（并发）、协作模式（平等）
主 Agent 职责：任务接收、规划、派发、收集、整合、输出
子 Agent 职责：任务接收、独立推理、工具调用、结果生成、结果返回
子 Agent 类型：code-reviewer、security-reviewer、tdd-guide、doc-updater、planner、build-error-resolver
派发机制：Agent 工具调用 → Harness 启动 → 子 Agent 执行 → 返回结果
上下文隔离：子 Agent 独立 messages，不污染主 Agent
设计原则：任务拆解、专业分工、上下文隔离、结果整合、并行优先

预告：下一篇我们深入子代理隔离与上下文管理机制。

☕ 如果这篇文章对你有帮助

欢迎请我喝杯咖啡，你的支持是我持续创作的动力 ❤️

捐赠支持 GitHub Sponsors

第19章多智能体架构模式 —— 从单 Agent 到 Agent 团队

多智能体架构是什么

为什么需要多智能体

单 Agent 的局限

多智能体的优势

多智能体架构模式

三种核心模式

模式 1：层级模式（Hierarchical）

模式 2：并行模式（Parallel）

模式 3：协作模式（Collaborative）

主 Agent 与子 Agent

主 Agent 的职责

子 Agent 的职责

子 Agent 类型

子 Agent 派发机制

派发流程

派发实现

子 Agent 上下文隔离

隔离机制

隔离的好处

多 Agent 协作场景

场景 1：完整重构流程

场景 2：安全审查流程

多智能体架构设计原则

设计原则

本章小结

相关内容

目录

第19章 多智能体架构模式 —— 从单 Agent 到 Agent 团队

多智能体架构是什么

为什么需要多智能体

单 Agent 的局限

多智能体的优势

多智能体架构模式

三种核心模式

模式 1：层级模式（Hierarchical）

模式 2：并行模式（Parallel）

模式 3：协作模式（Collaborative）

主 Agent 与子 Agent

主 Agent 的职责

子 Agent 的职责

子 Agent 类型

子 Agent 派发机制

派发流程

派发实现

子 Agent 上下文隔离

隔离机制

隔离的好处

多 Agent 协作场景

场景 1：完整重构流程

场景 2：安全审查流程

多智能体架构设计原则

设计原则

本章小结

相关内容

第19章多智能体架构模式 —— 从单 Agent 到 Agent 团队