别再死磕单 Agent 了！多智能体架构 + LangGraph 实战，一篇全讲透

如果你给 Agent 挂上几十个工具，这个 AI 产品就会变笨。问题不是模型不够聪明，你要他干了一个公司的活。本文会讲清三件事：多智能体的核心机制 Handoff（交接）、Supervisor（主管）与 Swarm（蜂群）两大架构，还有subAgent中间件，最后用 LangGraph 搭出一个可运行的旅行规划多智能体，代码完整可复制。

1 一个 Agent 的局限性

你想象下你给一个 AI Agent 挂上 20 个工具：查订单、改地址、退款、发邮件、算运费......初衷是"一个 Agent 全搞定所有事情"。

结果你的AI产品迷糊了：你说查订单，他去看退款信息，你的提示语明明写的很详细，可是他就是不听话。为什么？

其实原因很简单：不是模型有问题，而是你没有按照tool的功能明确给模型指派工作。

就像在现实中，公司不会要程序员去做前台和财务的工作一样，ai 也一样，你不能既要他干这个又要他干那个。

如果你的ai既要干这个又要干那个，就要有明确的文档来说明职务范围，还要有一个主管来管理这些agent才行。

这就是 Multi-Agent（多智能体）在 2026 年全面爆发的根本原因。

2 单个 Agent 的劣势到底是什么？

三个原因摆出来，你就理解了一半：

① 工具选择困难

模型本就是一个概率型工具，他是按照这个token通过算法算出下一个token的存在概率，然后选择最合适的token作为下一个答案。

也就是说大模型本来就存在不确定性。你现在又给它很多tool，自然出错率就会提高。

② 上下文被污染

我们的agent都有会话存储机制，就是把之前的会话保存下，作为上下文丢给大模型，如果历史会话太多，就会导致上下文太脏，最终这一轮的回复离标准答案的偏差就会越大。

③ 提示词"精神分裂"

如果将"你要热情耐心地安抚用户"和"你要严格按财务规则拒绝退款"，这两条内容同时写到提示语里面，模型就会精神分裂，他不知道到底是要热情还是要严格。

一句话总结：单个的 Agent 就像一名中医，什么病都能看；Multi-Agent 像一家医院，你先去护士台挂号，挂完号以后，护士会给你分派到对应的科室，找对应的医生给你看病，那这个医生就是tool。

3 核心机制：Handoff（交接）

Handoff（交接）就是多智能体系统里的"转手机制" ------一个 Agent 干不完或不该干的活，把它连同必要信息一起交给另一个更合适的 Agent。

Handoff = 交给谁 + 带什么信息

destination（交给谁） ：目标 Agent 是谁
payload（带什么） ：把哪些信息一起递过去

比如订机票 Agent 发现用户还要订酒店，它不必自己去查酒店，而是直接 Handoff 给酒店 Agent，把"城市、日期、预算"打包递过去即可。Handoff 相当于是前台，你要干啥，我就把事情交给对应的 Tool 就好了。

理解了交接，两大主流架构其实就是它的两种排列方式。

4 两大核心架构：Supervisor 与 Swarm

架构一：Supervisor（主管模式）

存在一个主管中心台，所有的工作先在主管这里登记，主管按照具体的工作内容，指派给合适的tool去做。

适合场景：职责边界清晰、需要统一决策和审计。

实现方式：你可以通过langgraph实现，也可以用deepAgent的createSubAgentMiddleware实现

架构二：Swarm（蜂群模式）

每个 Agent 不管和它有没有关系，都要看一眼这个工作，如果发现搞不定，就直接把控制权交给下一位。他的处理方案是线性的，一个一个的尝试，你能做你就做，不能做就交给下一个。

适合场景：流程动态、难以预先画出完整路由图。

两者怎么选？

对比维度	Supervisor 主管模式	Swarm 蜂群模式
控制方式	中心化，主管统筹	去中心化，互相转交
可预测性	高，路径清晰	较低，动态灵活
调试难度	低，有统一审计轨迹	较高，链路分散
LLM 调用	多（每次都要问主管）	少（直接交接，省延迟）
典型场景	客服工单分派、报告生成	多轮对话转接、专家接力

一句话记忆：要可控选 Supervisor，要灵活选 Swarm。

实际生产中最常见的做法是混合------团队内部用 Swarm，团队之间用 Supervisor 串起来。

5.实战：搭一个"旅行规划多智能体"

作为一个合格的旅行助手，它要同时搞定三件事：订机票、订酒店、查天气。

bash 复制代码

npm install @langchain/langgraph @langchain/langgraph-supervisor @langchain/langgraph-swarm @langchain/openai

定义三个工具

js 复制代码

// tools.js

/**
 * 预订机票
 */
function bookFlight(fromAirport, toAirport) {
  return `已成功预订 ${fromAirport} 飞往 ${toAirport} 的航班。`;
}

/**
 * 预订酒店
 */
function bookHotel(hotelName) {
  return `已成功预订 ${hotelName}。`;
}

/**
 * 查询城市天气
 */
function getWeather(city) {
  return `${city} 未来三天晴，气温 18-26 度。`;
}

module.exports = { bookFlight, bookHotel, getWeather };

把每个tool都包装成独立的agent

js 复制代码

// agents.js
const { ChatOpenAI } = require("@langchain/openai");
const { createReactAgent } = require("@langchain/langgraph/prebuilt");
const { bookFlight, bookHotel, getWeather } = require("./tools");

const model = new ChatOpenAI({ model: "gpt-4o" });

const flightAgent = createReactAgent({
  llm: model,
  tools: [bookFlight],
  prompt: "你是机票预订助手，只负责机票相关事务。",
  name: "flight_agent", // 名字必须显式指定
});

const hotelAgent = createReactAgent({
  llm: model,
  tools: [bookHotel],
  prompt: "你是酒店预订助手，只负责酒店相关事务。",
  name: "hotel_agent",
});

const weatherAgent = createReactAgent({
  llm: model,
  tools: [getWeather],
  prompt: "你是天气查询助手，只负责天气查询。",
  name: "weather_agent",
});

module.exports = { flightAgent, hotelAgent, weatherAgent };

5.1 主管模式

supervisor是主管中心，他把三个agent都放在一起管理，用prompt告诉大模型，遇到机票就用机票agent，遇到酒店就用酒店agent，遇到天气就用天气agent。

js 复制代码

// supervisor.js
const { ChatOpenAI } = require("@langchain/openai");
const { createSupervisor } = require("@langchain/langgraph-supervisor");
const { flightAgent, hotelAgent, weatherAgent } = require("./agents");

const supervisor = createSupervisor({
  agents: [flightAgent, hotelAgent, weatherAgent],
  llm: new ChatOpenAI({ model: "gpt-4o" }),
  prompt:
    "你是旅行规划主管。根据用户需求，把任务分派给" +
    "机票、酒店、天气三个助手，最后由你汇总成一份完整方案。",
}).compile();

const result = await supervisor.invoke({
    messages: [
      {
        role: "user",
        content:
          "帮我订一张北京到上海的机票，再订外滩附近的酒店，顺便看看天气",
      },
    ],
  });

  console.log(result);

5.2 蜂群模式

蜂群模式是一个连环调用的过程，我问"今天天气咋样？"和酒店，机票没有关系，但是依旧会把这个事情交给机票agent和酒店agent去做，就显得很多此一举。

js 复制代码

// swarm.js
const { createSwarm, createHandoffTool } = require("@langchain/langgraph-swarm");
const { ChatOpenAI } = require("@langchain/openai");
const { bookFlight, bookHotel } = require("./tools");

// 定义转交通道
const toHotel = createHandoffTool({
  agentName: "hotel_agent",
  description: "把用户转交给酒店助手",
});

const toFlight = createHandoffTool({
  agentName: "flight_agent",
  description: "把用户转交给机票助手",
});

const flightAgent = createReactAgent({
  llm: new ChatOpenAI({ model: "gpt-4o" }),
  tools: [bookFlight, toHotel], // 多了转交工具
  prompt: "你是机票预订助手。用户还提到酒店时，转交给酒店助手。",
  name: "flight_agent",
});

const hotelAgent = createReactAgent({
  llm: new ChatOpenAI({ model: "gpt-4o" }),
  tools: [bookHotel, toFlight],
  prompt: "你是酒店预订助手。用户还提到机票时，转交给机票助手。",
  name: "hotel_agent",
});

const swarm = createSwarm({
  agents: [flightAgent, hotelAgent],
  defaultActiveAgent: "flight_agent", // 谁是"第一接待"
}).compile();

async function main() {
  const result = await swarm.invoke({
    messages: [
      {
        role: "user",
        content: "帮我订一张北京到上海的机票，再订外滩附近的酒店",
      },
    ],
  });

  console.log(result);
}

main();

5.3 deepAgent的实现方案

deepagent的createSubAgentMiddleware他是langgraph-supervisor的一种实现模式，你可以理解成一个中间件封装体，目的就是为了我们更简单的使用它们。

js 复制代码

// agent.js
const { ChatOpenAI } = require("@langchain/openai");
const { createAgent } = require("deepagents");
const { createSubAgentMiddleware } = require("deepagents");
const {
  flightSubAgent,
  hotelSubAgent,
  weatherSubAgent,
} = require("./subagents");

const mainAgent = createAgent({
  model: new ChatOpenAI({ model: "gpt-4o" }),

  // 系统提示：告诉主 Agent 怎么用 task 工具
  systemPrompt:
    "你是旅行规划主管。根据用户需求，通过 task 工具把任务分派给" +
    "机票(flight)、酒店(hotel)、天气(weather)三个助手，" +
    "最后由你汇总成一份完整方案。",

  middleware: [
    createSubAgentMiddleware({
      defaultModel: "gpt-4o",   // 子 Agent 默认模型
      subagents: [flightSubAgent, hotelSubAgent, weatherSubAgent],
    }),
  ],
});

 const result = await mainAgent.invoke({
    messages: [
      {
        role: "user",
        content:
          "帮我订一张北京到上海的机票，再订外滩附近的酒店，顺便看看天气",
      },
    ],
  });

  console.log(result);

落地生产，需要注意这 3 件事

Demo 跑通只是起点。真要上生产，这三件事绕不开。

① State（状态）怎么设计所有 Agent 共享一份 State，默认用 `messages` 累加。但多个 Agent 同时写同一份状态时会冲突，需要用 reducer 明确"合并规则"。比如让每个 Agent 的结果各自追加到列表，而不是互相覆盖。

② 一定要加 Checkpoint（持久化）LangGraph 支持把每一步状态存进数据库（如 SQLite、Postgresql）。这一步带来的能力是质变的：· 进程崩了，能从断点恢复 · 危险操作前暂停，等人工确认再继续· 结合 interrupt 实现**人工介入（HITL）**涉及下单、付款、发邮件这类不可逆操作，HITL 不是可选项，是必需品。

③ 可观测性决定你能不能睡着觉多智能体比单 Agent 更容易出问题，因为链路长、参与者多。建议配合 LangSmith 做全链路追踪，把每一次 Handoff、每一次工具调用都记下来。

生产上最常见的两个坑：Agent 之间互相转交形成死循环 ，以及 Token 消耗失控。都需要用重试计数和调用上限来兜底。