动态子代理

动态子代理允许一个代理从解释器代码中调度子代理。该代理可以使用 JavaScript 循环、条件分支和并行批处理来将工作路由到已配置的子代理并综合结果，而不是要求模型一次选择一个子代理调用。当工作跨越许多独立单元、需要多重视角或受益于递归分析时，请使用此模式。关于通用解释器设置，请参阅解释器。

动态子代理使用解释器运行时，该功能处于Beta 版。API 和生命周期行为可能在版本之间发生变化。

解释器需要 @langchain/quickjs。

快速入门

动态子代理需要解释器中间件。请先安装并连接解释器。内置的通用子代理无需额外配置即可处理基本的扇出操作。

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "google-genai:gemini-3.6-flash",
  subagents: [{
    name: "reviewer",
    description: "审查代码安全问题，引用行号和严重程度",
    systemPrompt: "你是一个专注于安全的代码审查员。报告问题时需包含行号和严重程度。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openai:gpt-5.5",
  subagents: [{
    name: "reviewer",
    description: "审查代码安全问题，引用行号和严重程度",
    systemPrompt: "你是一个专注于安全的代码审查员。报告问题时需包含行号和严重程度。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  subagents: [{
    name: "reviewer",
    description: "审查代码安全问题，引用行号和严重程度",
    systemPrompt: "你是一个专注于安全的代码审查员。报告问题时需包含行号和严重程度。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  subagents: [{
    name: "reviewer",
    description: "审查代码安全问题，引用行号和严重程度",
    systemPrompt: "你是一个专注于安全的代码审查员。报告问题时需包含行号和严重程度。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  subagents: [{
    name: "reviewer",
    description: "审查代码安全问题，引用行号和严重程度",
    systemPrompt: "你是一个专注于安全的代码审查员。报告问题时需包含行号和严重程度。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  subagents: [{
    name: "reviewer",
    description: "审查代码安全问题，引用行号和严重程度",
    systemPrompt: "你是一个专注于安全的代码审查员。报告问题时需包含行号和严重程度。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  subagents: [{
    name: "reviewer",
    description: "审查代码安全问题，引用行号和严重程度",
    systemPrompt: "你是一个专注于安全的代码审查员。报告问题时需包含行号和严重程度。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

::> 有关安装步骤和解释器设置，请参阅解释器。对于专门的工作，请配置具有各自名称、描述和系统提示的自定义子代理。子代理的名称和描述用作代理评估应使用哪种角色的信息。要触发动态子代理，请使用 “workflow”（工作流）一词提示代理： python

result = agent.invoke({
    "messages": [{"role": "user", "content": "运行一个工作流，审查src/routes/中的每个文件并总结主要风险。"}]
})

:::

const result = await agent.invoke({
  messages: [{ role: "user", content: "运行一个工作流，该工作流会检查src/routes/目录下的每个文件并总结主要风险。" }],
});

“workflow”（工作流）一词是一个有用的触发器。 解释器系统提示将 “workflow” 视为一个信号，用于组织通过解释器的工作，使用代码中的 task() 来调度子代理，而不是通过一次由模型选择的工具调用来逐步处理项目。将请求表述为 “workflow” 是您可以主动选择启用动态编排的一个明确手段。如需进行单次、直接的委派，请改用简单直接的措辞。

与 dcode（LangChain 的终端编码代理）一起使用动态子代理？dcode 启用了代码解释器，因此动态子代理开箱即用。有关设置和使用详情，请参阅 dcode 子代理页面。

工作原理

当一个代理拥有子代理和解释器中间件时，解释器会公开一个内置的 task() 全局函数，用于从代码中调度子代理。跨越许多独立单元的任务（检查目录中的每个文件、分类处理一批工单）变成一个扇出工作的循环，从而可以确定性地运行，而不是一次由模型选择一个工具调用。子代理编排还支持递归语言模型（RLM）工作流，这是在递归语言模型论文中描述的方法：将工作集保存在解释器变量中，选择切片，使用 task() 调用子代理，并综合结果。许多编排工作流将动态子代理与程序化工具调用（PTC）结合使用：使用解释器代码中的 tools.* 来发现或筛选输入，然后使用 task() 调度子代理。PTC 默认是关闭的；通过在解释器中间件上设置显式的允许列表来启用它。 task() 是进入子代理执行的能力桥梁，类似于用于工具的 PTC。有关隔离默认值、审批边界和中间件选项，请参阅安全性和配置。 task() 接受以下输入：

description：给子代理的提示
subagentType：要运行哪个已配置的子代理
responseSchema（可选）：结构化输出

task() 运行一个完整的代理循环并解析为子代理的结果：

const review = await task({
  description: "审查 src/auth/login.ts 的认证问题。请引用行号。",
  subagentType: "reviewer",
  responseSchema: {
    type: "object",
    properties: {
      issues: { type: "array", items: { type: "object", properties: {
        file: { type: "string" }, line: { type: "number" },
        severity: { type: "string" }, description: { type: "string" },
      }}},
    },
  },
});

// 由于使用了 responseSchema，结果已经是类型化的值，因此不需要 JSON.parse。
const critical = review.issues.filter((issue) => issue.severity === "high");

当你传递 responseSchema 时，解析后的值已经是一个类型化的 JavaScript 对象；仅当子代理故意返回了一个 JSON 字符串时才调用 JSON.parse。

模式

代理根据任务的形态选择策略；这些策略源于其编写解释器代码的方式，而非源于配置，而您提供的子代理决定了它能做什么。每种模式都共享相同的编排方法：将工作保存在 JS 变量中，使用 task() 调度子代理，并在代码中组合结果。下图展示了常见的形态，每种都附带一个可运行的示例。

分类与执行

首先对项目进行分类，然后根据分类结果由专门的子代理处理每个项目。这允许您处理混合输入，其中不同的项目需要不同的专业知识。 用例： 分类处理支持工单、错误日志、用户反馈或任何需要根据类型进行不同处理的项目批。

示例：分类与执行

您配置的内容

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";
    
const agent = createDeepAgent({
  model: "google-genai:gemini-3.6-flash",
  subagents: [
    {
      name: "bug-fixer",
      description: "调查缺陷报告并提供复现步骤",
      systemPrompt: "你是一位缺陷分诊专家。调查每份缺陷报告，并提供清晰的复现步骤。",
    },
    {
      name: "feature-analyst",
      description: "评估功能请求的可行性和工作量",
      systemPrompt: "你是一位产品分析师。评估每个功能请求的技术可行性、预估工作量和潜在影响。",
    },
    {
      name: "support-agent",
      description: "基于文档回答用户问题",
      systemPrompt: "你是一位支持专家。根据现有文档，清晰地回答用户问题。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";
    
const agent = createDeepAgent({
  model: "openai:gpt-5.5",
  subagents: [
    {
      name: "bug-fixer",
      description: "调查缺陷报告并提供复现步骤",
      systemPrompt: "你是一位缺陷分诊专家。调查每份缺陷报告，并提供清晰的复现步骤。",
    },
    {
      name: "feature-analyst",
      description: "评估功能请求的可行性和工作量",
      systemPrompt: "你是一位产品分析师。评估每个功能请求的技术可行性、预估工作量和潜在影响。",
    },
    {
      name: "support-agent",
      description: "基于文档回答用户问题",
      systemPrompt: "你是一位支持专家。根据现有文档，清晰地回答用户问题。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";
    
const agent = createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  subagents: [
    {
      name: "bug-fixer",
      description: "调查缺陷报告并提供复现步骤",
      systemPrompt: "你是一位缺陷分诊专家。调查每份缺陷报告，并提供清晰的复现步骤。",
    },
    {
      name: "feature-analyst",
      description: "评估功能请求的可行性和工作量",
      systemPrompt: "你是一位产品分析师。评估每个功能请求的技术可行性、预估工作量和潜在影响。",
    },
    {
      name: "support-agent",
      description: "基于文档回答用户问题",
      systemPrompt: "你是一位支持专家。根据现有文档，清晰地回答用户问题。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";
    
const agent = createDeepAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  subagents: [
    {
      name: "bug-fixer",
      description: "调查缺陷报告并提供复现步骤",
      systemPrompt: "你是一位缺陷分诊专家。调查每份缺陷报告，并提供清晰的复现步骤。",
    },
    {
      name: "feature-analyst",
      description: "评估功能请求的可行性和工作量",
      systemPrompt: "你是一位产品分析师。评估每个功能请求的技术可行性、预估工作量和潜在影响。",
    },
    {
      name: "support-agent",
      description: "基于文档回答用户问题",
      systemPrompt: "你是一位支持专家。根据现有文档，清晰地回答用户问题。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";
    
const agent = createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  subagents: [
    {
      name: "bug-fixer",
      description: "调查缺陷报告并提供复现步骤",
      systemPrompt: "你是一位缺陷分诊专家。调查每份缺陷报告，并提供清晰的复现步骤。",
    },
    {
      name: "feature-analyst",
      description: "评估功能请求的可行性和工作量",
      systemPrompt: "你是一位产品分析师。评估每个功能请求的技术可行性、预估工作量和潜在影响。",
    },
    {
      name: "support-agent",
      description: "基于文档回答用户问题",
      systemPrompt: "你是一位支持专家。根据现有文档，清晰地回答用户问题。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";
    
const agent = createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  subagents: [
    {
      name: "bug-fixer",
      description: "调查缺陷报告并提供复现步骤",
      systemPrompt: "你是一位缺陷分诊专家。调查每份缺陷报告，并提供清晰的复现步骤。",
    },
    {
      name: "feature-analyst",
      description: "评估功能请求的可行性和工作量",
      systemPrompt: "你是一位产品分析师。评估每个功能请求的技术可行性、预估工作量和潜在影响。",
    },
    {
      name: "support-agent",
      description: "基于文档回答用户问题",
      systemPrompt: "你是一位支持专家。根据现有文档，清晰地回答用户问题。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";
    
const agent = createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  subagents: [
    {
      name: "bug-fixer",
      description: "调查缺陷报告并提供复现步骤",
      systemPrompt: "你是一位缺陷分诊专家。调查每份缺陷报告，并提供清晰的复现步骤。",
    },
    {
      name: "feature-analyst",
      description: "评估功能请求的可行性和工作量",
      systemPrompt: "你是一位产品分析师。评估每个功能请求的技术可行性、预估工作量和潜在影响。",
    },
    {
      name: "support-agent",
      description: "基于文档回答用户问题",
      systemPrompt: "你是一位支持专家。根据现有文档，清晰地回答用户问题。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

代理编写的代码

// 代理已经对每个工单进行了分类；这里将每个项目路由到合适的专家并收集处理结果。
const SPECIALIST = { bug: "bug-fixer", feature: "feature-analyst", question: "support-agent" };

const handled = await Promise.all(
  tickets.map((ticket) =>
    task({
      description: `处理此 ${ticket.category}:\n${ticket.text}`,
      subagentType: SPECIALIST[ticket.category],
    }),
  ),
);
// ... 将处理结果按类别分组到一份分类报告中
handled;

扇出与综合

代理并行地跨多个项目调度同类工作，然后合并结果。 用例： 跨目录的代码审查、分析一批文档、处理日志文件、跨多个服务运行相同检查。从解释器代码中发现文件需要程序化工具调用（PTC）。在解释器中间件的 PTC 允许列表中启用 glob。

示例：扇出与综合

您配置的内容

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "google-genai:gemini-3.6-flash",
  subagents: [{
    name: "reviewer",
    description: "审查代码安全问题，引用行号和严重程度",
    systemPrompt: "你是一位专注于安全的代码审查员。请仔细阅读文件，并报告任何认证或授权问题，包括行号和严重程度。",
  }],
  middleware: [createCodeInterpreterMiddleware({ ptc: ["glob"] })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openai:gpt-5.5",
  subagents: [{
    name: "reviewer",
    description: "审查代码安全问题，引用行号和严重程度",
    systemPrompt: "你是一位专注于安全的代码审查员。请仔细阅读文件，并报告任何认证或授权问题，包括行号和严重程度。",
  }],
  middleware: [createCodeInterpreterMiddleware({ ptc: ["glob"] })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  subagents: [{
    name: "reviewer",
    description: "审查代码安全问题，引用行号和严重程度",
    systemPrompt: "你是一位专注于安全的代码审查员。请仔细阅读文件，并报告任何认证或授权问题，包括行号和严重程度。",
  }],
  middleware: [createCodeInterpreterMiddleware({ ptc: ["glob"] })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  subagents: [{
    name: "reviewer",
    description: "审查代码安全问题，引用行号和严重程度",
    systemPrompt: "你是一位专注于安全的代码审查员。请仔细阅读文件，并报告任何认证或授权问题，包括行号和严重程度。",
  }],
  middleware: [createCodeInterpreterMiddleware({ ptc: ["glob"] })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  subagents: [{
    name: "reviewer",
    description: "审查代码安全问题，引用行号和严重程度",
    systemPrompt: "你是一位专注于安全的代码审查员。请仔细阅读文件，并报告任何认证或授权问题，包括行号和严重程度。",
  }],
  middleware: [createCodeInterpreterMiddleware({ ptc: ["glob"] })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  subagents: [{
    name: "reviewer",
    description: "审查代码安全问题，引用行号和严重程度",
    systemPrompt: "你是一位专注于安全的代码审查员。请仔细阅读文件，并报告任何认证或授权问题，包括行号和严重程度。",
  }],
  middleware: [createCodeInterpreterMiddleware({ ptc: ["glob"] })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  subagents: [{
    name: "reviewer",
    description: "审查代码安全问题，引用行号和严重程度",
    systemPrompt: "你是一位专注于安全的代码审查员。请仔细阅读文件，并报告任何认证或授权问题，包括行号和严重程度。",
  }],
  middleware: [createCodeInterpreterMiddleware({ ptc: ["glob"] })],
});

代理编写的代码

// 每个文件分配一个审查员，以并行方式执行，然后将审查结果合并。
const files = (await tools.glob({ pattern: "src/routes/**/*.ts" }))
  .split("\n")
  .filter(Boolean);

const reviews = await Promise.all(
  files.map((file) =>
    task({
      description: `审查 ${file} 的认证问题。请注明行号。`,
      subagentType: "reviewer",
      responseSchema: issuesSchema, // -> { issues: [{ file, line, severity }] }
    }),
  ),
);

const issues = reviews.flatMap((r) => r.issues);
// ... 按严重程度排序，去除重复项，总结最高风险
issues;

对抗性验证

一种两遍模式。第一遍产生发现结果。第二遍将每个发现结果发送给独立的验证者，只有通过共识的发现结果才会被保留。当置信度比速度更重要时，这可以减少误报。 用例： 误报代价高昂的安全审计、合规性检查、任何需要对结果有高度信心的审查。

示例：对抗性验证

您配置的内容

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "google-genai:gemini-3.6-flash",
  subagents: [
    {
      name: "reviewer",
      description: "查找代码中潜在的安全漏洞",
      systemPrompt: "你是一名安全审计员。找出潜在漏洞并报告每个漏洞的文件、行号和描述。",
    },
    {
      name: "verifier",
      description: "独立验证报告的漏洞是否真实",
      systemPrompt: "你是一名安全验证专家。给定一个报告的漏洞，独立验证其是否可被利用。保持怀疑态度。只确认真实问题。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openai:gpt-5.5",
  subagents: [
    {
      name: "reviewer",
      description: "查找代码中潜在的安全漏洞",
      systemPrompt: "你是一名安全审计员。找出潜在漏洞并报告每个漏洞的文件、行号和描述。",
    },
    {
      name: "verifier",
      description: "独立验证报告的漏洞是否真实",
      systemPrompt: "你是一名安全验证专家。给定一个报告的漏洞，独立验证其是否可被利用。保持怀疑态度。只确认真实问题。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  subagents: [
    {
      name: "reviewer",
      description: "查找代码中潜在的安全漏洞",
      systemPrompt: "你是一名安全审计员。找出潜在漏洞并报告每个漏洞的文件、行号和描述。",
    },
    {
      name: "verifier",
      description: "独立验证报告的漏洞是否真实",
      systemPrompt: "你是一名安全验证专家。给定一个报告的漏洞，独立验证其是否可被利用。保持怀疑态度。只确认真实问题。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  subagents: [
    {
      name: "reviewer",
      description: "查找代码中潜在的安全漏洞",
      systemPrompt: "你是一名安全审计员。找出潜在漏洞并报告每个漏洞的文件、行号和描述。",
    },
    {
      name: "verifier",
      description: "独立验证报告的漏洞是否真实",
      systemPrompt: "你是一名安全验证专家。给定一个报告的漏洞，独立验证其是否可被利用。保持怀疑态度。只确认真实问题。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  subagents: [
    {
      name: "reviewer",
      description: "查找代码中潜在的安全漏洞",
      systemPrompt: "你是一名安全审计员。找出潜在漏洞并报告每个漏洞的文件、行号和描述。",
    },
    {
      name: "verifier",
      description: "独立验证报告的漏洞是否真实",
      systemPrompt: "你是一名安全验证专家。给定一个报告的漏洞，独立验证其是否可被利用。保持怀疑态度。只确认真实问题。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  subagents: [
    {
      name: "reviewer",
      description: "查找代码中潜在的安全漏洞",
      systemPrompt: "你是一名安全审计员。找出潜在漏洞并报告每个漏洞的文件、行号和描述。",
    },
    {
      name: "verifier",
      description: "独立验证报告的漏洞是否真实",
      systemPrompt: "你是一名安全验证专家。给定一个报告的漏洞，独立验证其是否可被利用。保持怀疑态度。只确认真实问题。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  subagents: [
    {
      name: "reviewer",
      description: "查找代码中潜在的安全漏洞",
      systemPrompt: "你是一名安全审计员。找出潜在漏洞并报告每个漏洞的文件、行号和描述。",
    },
    {
      name: "verifier",
      description: "独立验证报告的漏洞是否真实",
      systemPrompt: "你是一名安全验证专家。给定一个报告的漏洞，独立验证其是否可被利用。保持怀疑态度。只确认真实问题。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

代理编写的代码

// 第一遍：审计。第二遍：独立验证每个发现；仅保留已确认的。
const { findings } = await task({
  description: "审计支付模块的漏洞。",
  subagentType: "reviewer",
  responseSchema: findingsSchema, // -> { findings: [{ id, file, line, description }] }
});

const verdicts = await Promise.all(
  findings.map((f) =>
    task({
      description: `验证 ${f.file}:${f.line} (${f.description})。确认或驳斥。`,
      subagentType: "verifier",
      responseSchema: verdictSchema, // -> { confirmed: boolean }
    }),
  ),
);

const confirmed = findings.filter((_, i) => verdicts[i]?.confirmed);
// ... 仅报告已确认的漏洞
confirmed;

生成与筛选

多个子代理针对同一问题生成独立的解决方案。代理在代码中比较、评分和筛选结果，只保留最佳结果。 用例： 架构提案、重构策略、内容变体，以及在提交之前探索多个选项能产生更好结果的任务。

示例：生成与筛选

您配置的内容

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "google-genai:gemini-3.6-flash",
  subagents: [{
    name: "architect",
    description: "提出包含权衡分析的数据库架构设计",
    systemPrompt: "你是一名数据库架构师。请为给定的需求提出一个架构设计。需要包含权衡分析、迁移注意事项和清晰的理论依据。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openai:gpt-5.5",
  subagents: [{
    name: "architect",
    description: "提出包含权衡分析的数据库架构设计",
    systemPrompt: "你是一名数据库架构师。请为给定的需求提出一个架构设计。需要包含权衡分析、迁移注意事项和清晰的理论依据。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  subagents: [{
    name: "architect",
    description: "提出包含权衡分析的数据库架构设计",
    systemPrompt: "你是一名数据库架构师。请为给定的需求提出一个架构设计。需要包含权衡分析、迁移注意事项和清晰的理论依据。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  subagents: [{
    name: "architect",
    description: "提出包含权衡分析的数据库架构设计",
    systemPrompt: "你是一名数据库架构师。请为给定的需求提出一个架构设计。需要包含权衡分析、迁移注意事项和清晰的理论依据。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  subagents: [{
    name: "architect",
    description: "提出包含权衡分析的数据库架构设计",
    systemPrompt: "你是一名数据库架构师。请为给定的需求提出一个架构设计。需要包含权衡分析、迁移注意事项和清晰的理论依据。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  subagents: [{
    name: "architect",
    description: "提出包含权衡分析的数据库架构设计",
    systemPrompt: "你是一名数据库架构师。请为给定的需求提出一个架构设计。需要包含权衡分析、迁移注意事项和清晰的理论依据。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  subagents: [{
    name: "architect",
    description: "提出包含权衡分析的数据库架构设计",
    systemPrompt: "你是一名数据库架构师。请为给定的需求提出一个架构设计。需要包含权衡分析、迁移注意事项和清晰的理论依据。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

代理编写的代码

// 并行生成独立提案，然后评分并保留最佳提案。
const proposals = await Promise.all(
  [1, 2, 3].map((n) =>
    task({
      description: `方案 ${n}：重新设计订单架构，并考虑权衡。`,
      subagentType: "architect",
      responseSchema: designSchema, // -> { 设计, 权衡 }
    }),
  ),
);

// ... 根据要求对每个提案进行评分
const best = proposals.sort((a, b) => score(b) - score(a))[0];
best;

锦标赛

变体由一个裁判子代理进行一对一比较，获胜者在淘汰赛中晋级。 用例： 在主观标准下的优化、样式选择、在竞争性的实现之间做出选择。

示例：锦标赛

您配置的内容

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "google-genai:gemini-3.6-flash",
  subagents: [
    {
      name: "writer",
      description: "重写函数，专注于提高可读性和清晰度",
      systemPrompt: "您是一位专注于编写简洁代码的专家程序员。请重写给定的函数以最大化其可读性。请解释您的选择。",
    },
    {
      name: "judge",
      description: "比较两个代码实现，并选择更易读的那个",
      systemPrompt: "您是一位代码质量裁判。请比较两个实现，并选择更易读的那个。请用具体的标准来论证您的选择。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openai:gpt-5.5",
  subagents: [
    {
      name: "writer",
      description: "重写函数，专注于提高可读性和清晰度",
      systemPrompt: "您是一位专注于编写简洁代码的专家程序员。请重写给定的函数以最大化其可读性。请解释您的选择。",
    },
    {
      name: "judge",
      description: "比较两个代码实现，并选择更易读的那个",
      systemPrompt: "您是一位代码质量裁判。请比较两个实现，并选择更易读的那个。请用具体的标准来论证您的选择。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  subagents: [
    {
      name: "writer",
      description: "重写函数，专注于提高可读性和清晰度",
      systemPrompt: "您是一位专注于编写简洁代码的专家程序员。请重写给定的函数以最大化其可读性。请解释您的选择。",
    },
    {
      name: "judge",
      description: "比较两个代码实现，并选择更易读的那个",
      systemPrompt: "您是一位代码质量裁判。请比较两个实现，并选择更易读的那个。请用具体的标准来论证您的选择。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  subagents: [
    {
      name: "writer",
      description: "重写函数，专注于提高可读性和清晰度",
      systemPrompt: "您是一位专注于编写简洁代码的专家程序员。请重写给定的函数以最大化其可读性。请解释您的选择。",
    },
    {
      name: "judge",
      description: "比较两个代码实现，并选择更易读的那个",
      systemPrompt: "您是一位代码质量裁判。请比较两个实现，并选择更易读的那个。请用具体的标准来论证您的选择。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  subagents: [
    {
      name: "writer",
      description: "重写函数，专注于提高可读性和清晰度",
      systemPrompt: "您是一位专注于编写简洁代码的专家程序员。请重写给定的函数以最大化其可读性。请解释您的选择。",
    },
    {
      name: "judge",
      description: "比较两个代码实现，并选择更易读的那个",
      systemPrompt: "您是一位代码质量裁判。请比较两个实现，并选择更易读的那个。请用具体的标准来论证您的选择。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  subagents: [
    {
      name: "writer",
      description: "重写函数，专注于提高可读性和清晰度",
      systemPrompt: "您是一位专注于编写简洁代码的专家程序员。请重写给定的函数以最大化其可读性。请解释您的选择。",
    },
    {
      name: "judge",
      description: "比较两个代码实现，并选择更易读的那个",
      systemPrompt: "您是一位代码质量裁判。请比较两个实现，并选择更易读的那个。请用具体的标准来论证您的选择。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  subagents: [
    {
      name: "writer",
      description: "重写函数，专注于提高可读性和清晰度",
      systemPrompt: "您是一位专注于编写简洁代码的专家程序员。请重写给定的函数以最大化其可读性。请解释您的选择。",
    },
    {
      name: "judge",
      description: "比较两个代码实现，并选择更易读的那个",
      systemPrompt: "您是一位代码质量裁判。请比较两个实现，并选择更易读的那个。请用具体的标准来论证您的选择。",
    },
  ],
  middleware: [createCodeInterpreterMiddleware()],
});

代理编写的代码

// 生成变体，然后进行成对判断，直到剩下唯一的获胜者。
let bracket = await Promise.all(
  [1, 2, 3, 4, 5].map((n) =>
    task({ description: `重写 processOrder 以提高可读性 (变体 ${n})。`, subagentType: "writer" }),
  ),
);

while (bracket.length > 1) {
  const winners = [];
  for (let i = 0; i < bracket.length; i += 2) {
    if (bracket[i + 1] === undefined) { winners.push(bracket[i]); break; }
    const { winner } = await task({
      description: `选择更具可读性的版本：\n\nA:\n${bracket[i]}\n\nB:\n${bracket[i + 1]}`,
      subagentType: "judge",
      responseSchema: pickSchema, // -> { winner: "A" | "B" }
    });
    winners.push(winner === "A" ? bracket[i] : bracket[i + 1]);
  }
  bracket = winners;
}
bracket[0]; // 获胜的重写版本

循环直至完成

代理运行一个发现循环，针对已找到的内容进行去重，直到没有新结果出现。当工作范围事先未知时很有用。 用例： 穷尽搜索、死代码检测、依赖审计，以及任何需要完整性而非固定数量结果的扫描。

示例：循环直至完成

您配置的内容

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "google-genai:gemini-3.6-flash",
  subagents: [{
    name: "analyzer",
    description: "分析代码中未使用的导出、函数和死代码路径",
    systemPrompt: "您是一位专注于死代码检测的代码分析师。找出未使用的导出、无法访问的函数和孤立模块。为每一项报告其文件路径和相关证据。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openai:gpt-5.5",
  subagents: [{
    name: "analyzer",
    description: "分析代码中未使用的导出、函数和死代码路径",
    systemPrompt: "您是一位专注于死代码检测的代码分析师。找出未使用的导出、无法访问的函数和孤立模块。为每一项报告其文件路径和相关证据。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  subagents: [{
    name: "analyzer",
    description: "分析代码中未使用的导出、函数和死代码路径",
    systemPrompt: "您是一位专注于死代码检测的代码分析师。找出未使用的导出、无法访问的函数和孤立模块。为每一项报告其文件路径和相关证据。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  subagents: [{
    name: "analyzer",
    description: "分析代码中未使用的导出、函数和死代码路径",
    systemPrompt: "您是一位专注于死代码检测的代码分析师。找出未使用的导出、无法访问的函数和孤立模块。为每一项报告其文件路径和相关证据。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  subagents: [{
    name: "analyzer",
    description: "分析代码中未使用的导出、函数和死代码路径",
    systemPrompt: "您是一位专注于死代码检测的代码分析师。找出未使用的导出、无法访问的函数和孤立模块。为每一项报告其文件路径和相关证据。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  subagents: [{
    name: "analyzer",
    description: "分析代码中未使用的导出、函数和死代码路径",
    systemPrompt: "您是一位专注于死代码检测的代码分析师。找出未使用的导出、无法访问的函数和孤立模块。为每一项报告其文件路径和相关证据。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  subagents: [{
    name: "analyzer",
    description: "分析代码中未使用的导出、函数和死代码路径",
    systemPrompt: "您是一位专注于死代码检测的代码分析师。找出未使用的导出、无法访问的函数和孤立模块。为每一项报告其文件路径和相关证据。",
  }],
  middleware: [createCodeInterpreterMiddleware()],
});

代理编写的代码

// 持续分发轮次，并对已找到的内容进行去重，直到某一轮没有新增内容。
const seen = new Set();
const found = [];

while (true) {
  const { items } = await task({
    description: `查找无效代码。已找到：${[...seen].join(", ") || "（无）"}.`,
    subagentType: "analyzer",
    responseSchema: itemsSchema, // -> { items: [{ id, file }] }
  });
  const fresh = items.filter((i) => !seen.has(i.id));
  if (fresh.length === 0) break; // 已收敛：无新发现
  for (const i of fresh) { seen.add(i.id); found.push(i); }
}
found;

task() 从一个已经运行的 eval 调用内部调度。它不经过常规的工具调用路径，因此父代理上的 interruptOn 审批工作流不会针对每次调度强制执行。如果您需要在子代理编排运行之前进行审批，请对 eval 工具本身设置门控。

禁用动态子代理

只要代理拥有子代理，子代理调度默认就是开启的。如果您希望子代理仅通过常规的 task 工具路径可用，请禁用它。有关其他中间件选项，请参阅解释器页面上的配置部分。

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "google-genai:gemini-3.6-flash",
  subagents: [{ name: "reviewer", description: "审阅代码", systemPrompt: "审阅代码。" }],
  middleware: [createCodeInterpreterMiddleware({ subagents: false })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openai:gpt-5.5",
  subagents: [{ name: "reviewer", description: "审阅代码", systemPrompt: "审阅代码。" }],
  middleware: [createCodeInterpreterMiddleware({ subagents: false })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  subagents: [{ name: "reviewer", description: "审阅代码", systemPrompt: "审阅代码。" }],
  middleware: [createCodeInterpreterMiddleware({ subagents: false })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  subagents: [{ name: "reviewer", description: "审阅代码", systemPrompt: "审阅代码。" }],
  middleware: [createCodeInterpreterMiddleware({ subagents: false })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  subagents: [{ name: "reviewer", description: "审阅代码", systemPrompt: "审阅代码。" }],
  middleware: [createCodeInterpreterMiddleware({ subagents: false })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  subagents: [{ name: "reviewer", description: "审阅代码", systemPrompt: "审阅代码。" }],
  middleware: [createCodeInterpreterMiddleware({ subagents: false })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  subagents: [{ name: "reviewer", description: "审阅代码", systemPrompt: "审阅代码。" }],
  middleware: [createCodeInterpreterMiddleware({ subagents: false })],
});

另请参阅

解释器：QuickJS 设置、程序化工具调用、持久化、安全性和中间件配置
子代理：配置子代理的名称、描述和系统提示
事件流：从协调器和委派的子代理流式传输更新

Connect these docs to Claude, VSCode, and more via MCP for real-time answers.

Edit this page on GitHub or file an issue.

Get started

Deployment

Execution environment

Context management

Delegation

Steering

Frontend

Protocols

快速入门

工作原理

模式

分类与执行

扇出与综合

对抗性验证

生成与筛选

锦标赛

循环直至完成

禁用动态子代理

另请参阅

​快速入门

​工作原理

​模式

​分类与执行

​扇出与综合

​对抗性验证

​生成与筛选

​锦标赛

​循环直至完成

​禁用动态子代理

​另请参阅

快速入门

工作原理

模式

分类与执行

扇出与综合

对抗性验证

生成与筛选

锦标赛

循环直至完成

禁用动态子代理

另请参阅