> ## Documentation Index
> Fetch the complete documentation index at: https://cndoc-langchain.site/llms.txt
> Use this file to discover all available pages before exploring further.

# 多智能体

多智能体系统协调专门的组件来处理复杂的工作流程。然而，并非每个复杂任务都需要这种方法——一个配备了合适（有时是动态的）工具和提示的单一智能体通常也能达到类似的效果。

## 为什么需要多智能体？

当开发者说他们需要“多智能体”时，他们通常是在寻找以下一种或多种能力：

* <Icon icon="brain" /> **上下文管理**：提供专门的知识，而不会使模型的上下文窗口不堪重负。如果上下文是无限的且延迟为零，你可以将所有知识倾倒到一个提示中——但既然不是，你就需要模式来有选择地呈现相关信息。
* <Icon icon="users" /> **分布式开发**：允许不同的团队独立开发和维护功能，将它们组合成一个具有清晰边界的大系统。
* <Icon icon="git-branch" /> **并行化**：为子任务生成专门的工作者并并发执行它们，以获得更快的结果。

当单一智能体拥有太多[工具](/oss/javascript/langchain/tools)并且在使用哪些工具上做出糟糕的决策时，当任务需要具有广泛上下文（长提示和特定领域的工具）的专门知识时，或者当你需要强制执行顺序约束，只有在满足某些条件后才能解锁功能时，多智能体模式尤其有价值。

<Tip>
  多智能体设计的核心是\*\*[上下文工程](/oss/javascript/langchain/context-engineering)\*\*——决定每个智能体看到什么信息。你系统的质量取决于确保每个智能体都能访问其任务所需的正确数据。
</Tip>

## 模式

以下是构建多智能体系统的主要模式，每种模式都适用于不同的用例：

| 模式                                                                  | 工作原理                                                                                           |
| ------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| [**子智能体**](/oss/javascript/langchain/multi-agent/subagents)         | 一个主智能体将子智能体作为工具进行协调。所有路由都通过主智能体，它决定何时以及如何调用每个子智能体。                                             |
| [**交接**](/oss/javascript/langchain/multi-agent/handoffs)            | 行为根据状态动态变化。工具调用更新一个状态变量，该变量触发路由或配置更改，切换智能体或调整当前智能体的工具和提示。                                      |
| [**技能**](/oss/javascript/langchain/multi-agent/skills)              | 按需加载的专门提示和知识。单个智能体保持控制权，同时根据需要从技能加载上下文。                                                        |
| [**路由器**](/oss/javascript/langchain/multi-agent/router)             | 一个路由步骤对输入进行分类，并将其定向到一个或多个专门的智能体。结果被合成为一个组合响应。                                                  |
| [**自定义工作流**](/oss/javascript/langchain/multi-agent/custom-workflow) | 使用 [LangGraph](/oss/javascript/langgraph/overview) 构建定制的执行流程，混合确定性逻辑和智能体行为。将其他模式作为节点嵌入到你的工作流中。 |

### 选择模式

使用此表将你的需求与正确的模式匹配：

<div className="compact-first-col">
  | 模式                                                          | 分布式开发 |  并行化  |   多跳  | 直接用户交互 |
  | ----------------------------------------------------------- | :---: | :---: | :---: | :----: |
  | [**子智能体**](/oss/javascript/langchain/multi-agent/subagents) | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |    ⭐   |
  | [**交接**](/oss/javascript/langchain/multi-agent/handoffs)    |   -   |   -   | ⭐⭐⭐⭐⭐ |  ⭐⭐⭐⭐⭐ |
  | [**技能**](/oss/javascript/langchain/multi-agent/skills)      | ⭐⭐⭐⭐⭐ |  ⭐⭐⭐  | ⭐⭐⭐⭐⭐ |  ⭐⭐⭐⭐⭐ |
  | [**路由器**](/oss/javascript/langchain/multi-agent/router)     |  ⭐⭐⭐  | ⭐⭐⭐⭐⭐ |   -   |   ⭐⭐⭐  |
</div>

* **分布式开发**：不同的团队能否独立维护组件？
* **并行化**：多个智能体能否并发执行？
* **多跳**：该模式是否支持串联调用多个子智能体？
* **直接用户交互**：子智能体能否直接与用户对话？

<Tip>
  你可以混合使用模式！例如，一个**子智能体**架构可以调用调用自定义工作流或路由器智能体的工具。子智能体甚至可以使用**技能**模式按需加载上下文。可能性是无限的！
</Tip>

### 可视化概述

<Tabs>
  <Tab title="子智能体">
    一个主智能体将子智能体作为工具进行协调。所有路由都通过主智能体。

    <Frame>
      <img src="https://mintcdn.com/other-405835d4/CQyxcamAdEQxfPs-/oss/langchain/multi-agent/images/pattern-subagents.png?fit=max&auto=format&n=CQyxcamAdEQxfPs-&q=85&s=00fc01245aa81af3486a9a968e7935ca" alt="子智能体模式：主智能体将子智能体作为工具进行协调" width="1020" height="734" data-path="oss/langchain/multi-agent/images/pattern-subagents.png" />
    </Frame>
  </Tab>

  <Tab title="交接">
    智能体通过工具调用相互传递控制权。每个智能体可以交接给其他智能体或直接响应用户。

    <Frame>
      <img src="https://mintcdn.com/other-405835d4/CQyxcamAdEQxfPs-/oss/langchain/multi-agent/images/pattern-handoffs.png?fit=max&auto=format&n=CQyxcamAdEQxfPs-&q=85&s=3e6f9b7fdd3614e49742ba9c3ebf0377" alt="交接模式：智能体通过工具调用传递控制权" width="1568" height="464" data-path="oss/langchain/multi-agent/images/pattern-handoffs.png" />
    </Frame>
  </Tab>

  <Tab title="技能">
    单个智能体按需加载专门的提示和知识，同时保持控制权。

    <Frame>
      <img src="https://mintcdn.com/other-405835d4/CQyxcamAdEQxfPs-/oss/langchain/multi-agent/images/pattern-skills.png?fit=max&auto=format&n=CQyxcamAdEQxfPs-&q=85&s=6040742c03a0bb3cfd0dafe7a366f018" alt="技能模式：单个智能体按需加载专门的上下文" width="874" height="734" data-path="oss/langchain/multi-agent/images/pattern-skills.png" />
    </Frame>
  </Tab>

  <Tab title="路由器">
    一个路由步骤对输入进行分类，并将其定向到专门的智能体。结果被合成。

    <Frame>
      <img src="https://mintcdn.com/other-405835d4/CQyxcamAdEQxfPs-/oss/langchain/multi-agent/images/pattern-router.png?fit=max&auto=format&n=CQyxcamAdEQxfPs-&q=85&s=c52aefbd575f718745f9c951701f8374" alt="路由器模式：路由步骤将输入分类到专门的智能体" width="1560" height="556" data-path="oss/langchain/multi-agent/images/pattern-router.png" />
    </Frame>
  </Tab>
</Tabs>

## 性能比较

不同的模式具有不同的性能特征。理解这些权衡有助于你根据延迟和成本要求选择正确的模式。

**关键指标：**

* **模型调用次数**：LLM 调用的次数。调用次数越多 = 延迟越高（尤其是顺序执行时）以及每个请求的 API 成本越高。
* **处理的令牌数**：所有调用中使用的总[上下文窗口](/oss/javascript/langchain/context-engineering)。令牌越多 = 处理成本越高以及潜在的上下文限制。

### 单次请求

> **用户：** “买咖啡”

一个专门的咖啡智能体/技能可以调用 `buy_coffee` 工具。

| 模式                                                          | 模型调用次数 | 最适合 |
| ----------------------------------------------------------- | :----: | :-: |
| [**子智能体**](/oss/javascript/langchain/multi-agent/subagents) |    4   |     |
| [**交接**](/oss/javascript/langchain/multi-agent/handoffs)    |    3   |  ✅  |
| [**技能**](/oss/javascript/langchain/multi-agent/skills)      |    3   |  ✅  |
| [**路由器**](/oss/javascript/langchain/multi-agent/router)     |    3   |  ✅  |

<Tabs>
  <Tab title="子智能体">
    **4 次模型调用：**

    <Frame>
      <img src="https://mintcdn.com/other-405835d4/CQyxcamAdEQxfPs-/oss/langchain/multi-agent/images/oneshot-subagents.png?fit=max&auto=format&n=CQyxcamAdEQxfPs-&q=85&s=0110809f394b3d8d54c31bbaca151d8e" alt="子智能体单次请求：买咖啡请求的 4 次模型调用" width="1568" height="1124" data-path="oss/langchain/multi-agent/images/oneshot-subagents.png" />
    </Frame>
  </Tab>

  <Tab title="交接">
    **3 次模型调用：**

    <Frame>
      <img src="https://mintcdn.com/other-405835d4/CQyxcamAdEQxfPs-/oss/langchain/multi-agent/images/oneshot-handoffs.png?fit=max&auto=format&n=CQyxcamAdEQxfPs-&q=85&s=2ba8684aa604359884289c541e1d7188" alt="交接单次请求：买咖啡请求的 3 次模型调用" width="1568" height="948" data-path="oss/langchain/multi-agent/images/oneshot-handoffs.png" />
    </Frame>
  </Tab>

  <Tab title="技能">
    **3 次模型调用：**

    <Frame>
      <img src="https://mintcdn.com/other-405835d4/CQyxcamAdEQxfPs-/oss/langchain/multi-agent/images/oneshot-skills.png?fit=max&auto=format&n=CQyxcamAdEQxfPs-&q=85&s=dcc8ae28c1fdf4bffad0ae0bd69f2f44" alt="技能单次请求：买咖啡请求的 3 次模型调用" width="1568" height="1036" data-path="oss/langchain/multi-agent/images/oneshot-skills.png" />
    </Frame>
  </Tab>

  <Tab title="路由器">
    **3 次模型调用：**

    <Frame>
      <img src="https://mintcdn.com/other-405835d4/CQyxcamAdEQxfPs-/oss/langchain/multi-agent/images/oneshot-router.png?fit=max&auto=format&n=CQyxcamAdEQxfPs-&q=85&s=d154c65be632307d38b2dbbaf0090988" alt="路由器单次请求：买咖啡请求的 3 次模型调用" width="1568" height="994" data-path="oss/langchain/multi-agent/images/oneshot-router.png" />
    </Frame>
  </Tab>
</Tabs>

**关键洞察：** 对于单次任务，交接、技能和路由器最有效（各 3 次调用）。子智能体增加了一次额外调用，因为结果需要流回主智能体——这种开销提供了集中控制。

### 重复请求

> **第 1 轮：** “买咖啡”
> **第 2 轮：** “再买一次咖啡”

用户在同一对话中重复相同的请求。

<div className="compact-first-col">
  | 模式                                                          | 第 2 轮调用次数 | 总计（两轮） | 最适合 |
  | ----------------------------------------------------------- | :-------: | :----: | :-: |
  | [**子智能体**](/oss/javascript/langchain/multi-agent/subagents) |     4     |    8   |     |
  | [**交接**](/oss/javascript/langchain/multi-agent/handoffs)    |     2     |    5   |  ✅  |
  | [**技能**](/oss/javascript/langchain/multi-agent/skills)      |     2     |    5   |  ✅  |
  | [**路由器**](/oss/javascript/langchain/multi-agent/router)     |     3     |    6   |     |
</div>

<Tabs>
  <Tab title="子智能体">
    **再次 4 次调用 → 总计 8 次**

    * 子智能体**设计上是无状态的**——每次调用都遵循相同的流程
    * 主智能体维护对话上下文，但子智能体每次都是全新开始
    * 这提供了强大的上下文隔离，但重复了完整的流程
  </Tab>

  <Tab title="交接">
    **2 次调用 → 总计 5 次**

    * 咖啡智能体从第 1 轮**仍然处于活动状态**（状态持续）
    * 无需交接——智能体直接调用 `buy_coffee` 工具（调用 1）
    * 智能体响应用户（调用 2）
    * **通过跳过交接节省了 1 次调用**
  </Tab>

  <Tab title="技能">
    **2 次调用 → 总计 5 次**

    * 技能上下文**已经加载**在对话历史中
    * 无需重新加载——智能体直接调用 `buy_coffee` 工具（调用 1）
    * 智能体响应用户（调用 2）
    * **通过重用已加载的技能节省了 1 次调用**
  </Tab>

  <Tab title="路由器">
    **再次 3 次调用 → 总计 6 次**

    * 路由器是**无状态的**——每个请求都需要一次 LLM 路由调用
    * 第 2 轮：路由器 LLM 调用 (1) → 牛奶智能体调用 buy\_coffee (2) → 牛奶智能体响应 (3)
    * 可以通过将其包装为有状态智能体中的工具来优化
  </Tab>
</Tabs>

**关键洞察：** 有状态模式（交接、技能）在重复请求上节省了 40-50% 的调用。子智能体保持每次请求的成本一致——这种无状态设计提供了强大的上下文隔离，但代价是重复的模型调用。

### 多领域

> **用户：** “比较 Python、JavaScript 和 Rust 在 Web 开发中的应用”

每个语言智能体/技能包含约 2000 个令牌的文档。所有模式都可以进行并行工具调用。

| 模式                                                          | 模型调用次数 |  总令牌数  | 最适合 |
| ----------------------------------------------------------- | :----: | :----: | :-: |
| [**子智能体**](/oss/javascript/langchain/multi-agent/subagents) |    5   |  \~9K  |  ✅  |
| [**交接**](/oss/javascript/langchain/multi-agent/handoffs)    |   7+   | \~14K+ |     |
| [**技能**](/oss/javascript/langchain/multi-agent/skills)      |    3   |  \~15K |     |
| [**路由器**](/oss/javascript/langchain/multi-agent/router)     |    5   |  \~9K  |  ✅  |

<Tabs>
  <Tab title="子智能体">
    **5 次调用，\~9K 令牌**

    <Frame>
      <img src="https://mintcdn.com/other-405835d4/CQyxcamAdEQxfPs-/oss/langchain/multi-agent/images/multidomain-subagents.png?fit=max&auto=format&n=CQyxcamAdEQxfPs-&q=85&s=5a39d28babe130007d7c8f96ab1feb66" alt="子智能体多领域：5 次调用，并行执行" width="1568" height="1232" data-path="oss/langchain/multi-agent/images/multidomain-subagents.png" />
    </Frame>

    每个子智能体在**隔离环境**中工作，仅包含其相关上下文。总计：**9K 令牌**。
  </Tab>

  <Tab title="交接">
    **7+ 次调用，\~14K+ 令牌**

    <Frame>
      <img src="https://mintcdn.com/other-405835d4/CQyxcamAdEQxfPs-/oss/langchain/multi-agent/images/multidomain-handoffs.png?fit=max&auto=format&n=CQyxcamAdEQxfPs-&q=85&s=2b3842dd908565f786251f2d14ef1375" alt="交接多领域：7+ 次顺序调用" width="1568" height="834" data-path="oss/langchain/multi-agent/images/multidomain-handoffs.png" />
    </Frame>

    交接**顺序执行**——无法并行研究所有三种语言。不断增长的对话历史增加了开销。总计：**\~14K+ 令牌**。
  </Tab>

  <Tab title="技能">
    **3 次调用，\~15K 令牌**

    <Frame>
      <img src="https://mintcdn.com/other-405835d4/CQyxcamAdEQxfPs-/oss/langchain/multi-agent/images/multidomain-skills.png?fit=max&auto=format&n=CQyxcamAdEQxfPs-&q=85&s=66fc0ba399e85d2c7e35d46ff7247700" alt="技能多领域：3 次调用，累积上下文" width="1560" height="988" data-path="oss/langchain/multi-agent/images/multidomain-skills.png" />
    </Frame>

    加载后，**每次后续调用都会处理所有 6K 令牌的技能文档**。由于上下文隔离，子智能体总共处理的令牌减少了 67%。总计：**15K 令牌**。
  </Tab>

  <Tab title="路由器">
    **5 次调用，\~9K 令牌**

    <Frame>
      <img src="https://mintcdn.com/other-405835d4/CQyxcamAdEQxfPs-/oss/langchain/multi-agent/images/multidomain-router.png?fit=max&auto=format&n=CQyxcamAdEQxfPs-&q=85&s=6dc5f5bbb664ea9c4f68a8c108874d19" alt="路由器多领域：5 次调用，并行执行" width="1568" height="1052" data-path="oss/langchain/multi-agent/images/multidomain-router.png" />
    </Frame>

    路由器使用 **LLM 进行路由**，然后并行调用智能体。类似于子智能体，但有明确的路由步骤。总计：**9K 令牌**。
  </Tab>
</Tabs>

**关键洞察：** 对于多领域任务，具有并行执行能力的模式（子智能体、路由器）最有效。技能调用次数较少，但由于上下文累积，令牌使用量很高。交接在这里效率低下——它必须顺序执行，无法利用并行工具调用来同时咨询多个领域。

### 总结

以下是所有三种场景下模式的比较：

<div className="compact-first-col">
  | 模式                                                          |  单次请求 |     重复请求    |       多领域      |
  | ----------------------------------------------------------- | :---: | :---------: | :------------: |
  | [**子智能体**](/oss/javascript/langchain/multi-agent/subagents) | 4 次调用 | 8 次调用 (4+4) |   5 次调用，9K 令牌  |
  | [**交接**](/oss/javascript/langchain/multi-agent/handoffs)    | 3 次调用 | 5 次调用 (3+2) | 7+ 次调用，14K+ 令牌 |
  | [**技能**](/oss/javascript/langchain/multi-agent/skills)      | 3 次调用 | 5 次调用 (3+2) |  3 次调用，15K 令牌  |
  | [**路由器**](/oss/javascript/langchain/multi-agent/router)     | 3 次调用 | 6 次调用 (3+3) |   5 次调用，9K 令牌  |
</div>

**选择模式：**

<div className="compact-first-col">
  | 优化目标     | [子智能体](/oss/javascript/langchain/multi-agent/subagents) | [交接](/oss/javascript/langchain/multi-agent/handoffs) | [技能](/oss/javascript/langchain/multi-agent/skills) | [路由器](/oss/javascript/langchain/multi-agent/router) |
  | -------- | :-----------------------------------------------------: | :--------------------------------------------------: | :------------------------------------------------: | :-------------------------------------------------: |
  | 单次请求     |                                                         |                           ✅                          |                          ✅                         |                          ✅                          |
  | 重复请求     |                                                         |                           ✅                          |                          ✅                         |                                                     |
  | 并行执行     |                            ✅                            |                                                      |                                                    |                          ✅                          |
  | 大上下文领域   |                            ✅                            |                                                      |                                                    |                          ✅                          |
  | 简单、专注的任务 |                                                         |                                                      |                          ✅                         |                                                     |
</div>

***

<div className="source-links">
  <Callout icon="terminal-2">
    [将这些文档](/use-these-docs)通过 MCP 连接到 Claude、VSCode 等，以获取实时答案。
  </Callout>

  <Callout icon="edit">
    [在 GitHub 上编辑此页面](https://github.com/langchain-ai/docs/edit/main/src/oss/langchain/multi-agent/index.mdx) 或 [提交问题](https://github.com/langchain-ai/docs/issues/new/choose)。
  </Callout>
</div>
