深度代理可以创建子代理来委派工作。您可以在 subagents 参数中指定自定义子代理。子代理对于上下文隔离（保持主代理的上下文清洁）以及提供专门的指令非常有用。本页涵盖同步子代理，即主管代理会阻塞直到子代理完成。对于长时间运行的任务、并行工作流，或需要在执行过程中进行引导和取消的情况，请参阅异步子代理。

为什么要使用子代理？

子代理解决了上下文膨胀问题。当代理使用具有大量输出的工具（网页搜索、文件读取、数据库查询）时，上下文窗口会迅速被中间结果填满。子代理隔离了这些详细工作——主代理只接收最终结果，而不是产生该结果的几十次工具调用。 何时使用子代理：

✅ 可能会混淆主代理上下文的多步骤任务
✅ 需要自定义指令或工具的专业领域
✅ 需要不同模型能力的任务
✅ 当您希望主代理专注于高级协调时

何时不使用子代理：

❌ 简单的单步骤任务
❌ 当您需要保留中间上下文时
❌ 当开销大于收益时

配置

subagents 应该是一个字典列表或 CompiledSubAgent 对象。有两种类型：

默认子代理

深度代理会自动添加一个同步的 general-purpose 子代理，除非您已经提供了一个同名的同步子代理。 general-purpose 子代理默认拥有文件系统工具，并且可以通过额外的工具/中间件进行自定义。

要替换它，请传递您自己的名为 general-purpose 的子代理。
要重命名或重新提示自动添加的版本，请在活动驱动配置上设置 general_purpose_subagent=GeneralPurposeSubagentProfile(...)。
要禁用它，请参阅下面的在没有子代理的情况下运行。

在没有子代理的情况下运行

要运行一个没有 task 工具的代理，需要做两件事：

在活动驱动配置上设置 general_purpose_subagent=GeneralPurposeSubagentProfile(enabled=False)。
通过 create_deep_agent 的 subagents= 参数不传递任何同步子代理。

深度代理仅在存在至少一个同步子代理时才附加 SubAgentMiddleware（以及 task 工具）。既没有默认子代理也没有调用者提供的子代理时，代理将无委派运行。异步子代理不受影响——它们通过自己的中间件和工具流动，如异步子代理中所述。

这里不要使用 excluded_middleware——SubAgentMiddleware 是必需的脚手架，将其列入会引发 ValueError。general_purpose_subagent.enabled = False 是受支持的途径。

自定义子代理

您可以使用 subagents 参数定义具有特定工具的专业化子代理。例如，用作代码审查员、网络研究员或测试运行器。对于大多数用例，请使用 SubAgent 字典将子代理定义为字典。对于复杂的工作流，请使用 CompiledSubAgent：

SubAgent（基于字典）

将子代理定义为匹配 SubAgent 规范的字典，包含以下字段：

字段	类型	描述
`name`	`str`	必需。子代理的唯一标识符。主代理在调用 `task()` 工具时使用此名称。子代理名称成为 `AIMessage` 和流式传输的元数据，有助于区分代理。
`description`	`str`	必需。此子代理功能的描述。要具体且面向操作。主代理用此来决定何时委派。
`system_prompt`	`str`	必需。子代理的指令。自定义子代理必须定义自己的指令。包括工具使用指南和输出格式要求。不从主代理继承。
`tools`	`list[Callable]`	可选。子代理可以使用的工具。保持最小化，仅包含所需内容。默认从主代理继承。指定时，将完全覆盖继承的工具。
`model`	`str` \| `BaseChatModel`	可选。覆盖主代理的模型。省略则使用主代理的模型。默认从主代理继承。您可以传递模型标识符字符串，如 `'openai:gpt-5.5'`（使用 `'provider:model'` 格式）或 LangChain 聊天模型对象（`init_chat_model("gpt-5.5")` 或 `ChatOpenAI(model="gpt-5.5")`）。
`middleware`	`list[Middleware]`	可选。用于自定义行为、日志记录或速率限制的额外中间件。不从主代理继承。合并到默认子代理栈中：其 `.name` 与默认匹配的实例将原地替换它，其他任何内容都落在最后一个核心中间件条目之后、配置文件、提示缓存和内存之前。参见覆盖默认中间件实例。例如，在此处包含一个带有 `tools` 白名单的 `FilesystemMiddleware` 实例，可以独立于主代理限制子代理的文件系统工具。更多信息，请参阅虚拟文件系统访问下的“限制文件系统工具”部分。
`interrupt_on`	`dict[str, bool \| InterruptOnConfig]`	可选。为特定工具配置人在回路。选项：`True`、`False` 或带有 `allowed_decisions` 的 `InterruptOnConfig`。需要检查点。默认从主代理继承。子代理的值覆盖默认值。
`skills`	`list[str]`	可选。技能源路径。指定后，子代理将从这些目录加载技能（例如 `["/skills/research/", "/skills/web-search/"]`）。这允许子代理拥有与主代理不同的技能集。不从主代理继承。只有通用子代理继承主代理的技能。当子代理拥有技能时，它会运行自己独立的 `SkillsMiddleware` 实例。技能状态是完全隔离的——子代理加载的技能对父代理不可见，反之亦然。
`response_format`	`ResponseFormat`	可选。子代理的结构化输出模式。设置后，父代理以 JSON 形式接收子代理的结果，而不是自由格式文本。接受 Pydantic 模型、`ToolStrategy(...)`、`ProviderStrategy(...)` 或原始模式类型。参见结构化输出。
`permissions`	`list[FilesystemPermission]`	可选。子代理的文件系统权限规则。设置后，完全替换父代理的权限。默认从主代理继承。

CompiledSubAgent

对于复杂的工作流，可以使用预构建的 LangGraph 图作为 CompiledSubAgent：

字段	类型	描述
`name`	`str`	必需。子代理的唯一标识符。子代理名称成为 `AIMessage` 和流式传输的元数据，有助于区分代理。
`description`	`str`	必需。此子代理的功能。
`runnable`	`Runnable`	必需。编译后的 LangGraph 图（必须先调用 `.compile()`）。

使用 SubAgent

import os
from typing import Literal

from deepagents import create_deep_agent
from tavily import TavilyClient

tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])


def internet_search(
    query: str,
    max_results: int = 5,
    topic: Literal["general", "news", "finance"] = "general",
    include_raw_content: bool = False,
):
    """执行网络搜索"""
    return tavily_client.search(
        query,
        max_results=max_results,
        include_raw_content=include_raw_content,
        topic=topic,
    )


research_subagent = {
    "name": "research-agent",
    "description": "用于更深入地研究问题",
    "system_prompt": "你是一个优秀的研究员",
    "tools": [internet_search],
    "model": "openai:gpt-5.5",  # 可选覆盖，默认使用主智能体模型
}
subagents = [research_subagent]

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    subagents=subagents,
)

使用 CompiledSubAgent

对于更复杂的用例，您可以使用 CompiledSubAgent 提供您的自定义子代理。您可以使用 LangChain 的 create_agent 或通过图 API 制作自定义 LangGraph 图来创建自定义子代理。如果您正在创建自定义 LangGraph 图，请确保该图具有一个名为 "messages" 的状态键：

from deepagents import CompiledSubAgent, create_deep_agent
from langchain.agents import create_agent
    
    
def internet_search(query: str) -> str:
    """执行网页搜索。"""
    return f"search results for {query}"
    
    
research_instructions = "You are a research coordinator."
your_model = "openai:gpt-5.5"
specialized_tools: list = []
    
# 创建自定义智能体图
custom_graph = create_agent(
    model=your_model,
    tools=specialized_tools,
    system_prompt="You are a specialized agent for data analysis...",
)
    
# 将其用作自定义子智能体
custom_subagent = CompiledSubAgent(
    name="data-analyzer",
    description="用于复杂数据分析任务的专业智能体",
    runnable=custom_graph,
)
    
subagents = [custom_subagent]
    
agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    tools=[internet_search],
    system_prompt=research_instructions,
    subagents=subagents,
)

from deepagents import CompiledSubAgent, create_deep_agent
from langchain.agents import create_agent
    
    
def internet_search(query: str) -> str:
    """执行网页搜索。"""
    return f"search results for {query}"
    
    
research_instructions = "You are a research coordinator."
your_model = "openai:gpt-5.5"
specialized_tools: list = []
    
# 创建自定义智能体图
custom_graph = create_agent(
    model=your_model,
    tools=specialized_tools,
    system_prompt="You are a specialized agent for data analysis...",
)
    
# 将其用作自定义子智能体
custom_subagent = CompiledSubAgent(
    name="data-analyzer",
    description="用于复杂数据分析任务的专业智能体",
    runnable=custom_graph,
)
    
subagents = [custom_subagent]
    
agent = create_deep_agent(
    model="openai:gpt-5.5",
    tools=[internet_search],
    system_prompt=research_instructions,
    subagents=subagents,
)

from deepagents import CompiledSubAgent, create_deep_agent
from langchain.agents import create_agent
    
    
def internet_search(query: str) -> str:
    """执行网页搜索。"""
    return f"search results for {query}"
    
    
research_instructions = "You are a research coordinator."
your_model = "openai:gpt-5.5"
specialized_tools: list = []
    
# 创建自定义智能体图
custom_graph = create_agent(
    model=your_model,
    tools=specialized_tools,
    system_prompt="You are a specialized agent for data analysis...",
)
    
# 将其用作自定义子智能体
custom_subagent = CompiledSubAgent(
    name="data-analyzer",
    description="用于复杂数据分析任务的专业智能体",
    runnable=custom_graph,
)
    
subagents = [custom_subagent]
    
agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    tools=[internet_search],
    system_prompt=research_instructions,
    subagents=subagents,
)

from deepagents import CompiledSubAgent, create_deep_agent
from langchain.agents import create_agent
    
    
def internet_search(query: str) -> str:
    """执行网页搜索。"""
    return f"search results for {query}"
    
    
research_instructions = "You are a research coordinator."
your_model = "openai:gpt-5.5"
specialized_tools: list = []
    
# 创建自定义智能体图
custom_graph = create_agent(
    model=your_model,
    tools=specialized_tools,
    system_prompt="You are a specialized agent for data analysis...",
)
    
# 将其用作自定义子智能体
custom_subagent = CompiledSubAgent(
    name="data-analyzer",
    description="用于复杂数据分析任务的专业智能体",
    runnable=custom_graph,
)
    
subagents = [custom_subagent]
    
agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    tools=[internet_search],
    system_prompt=research_instructions,
    subagents=subagents,
)

from deepagents import CompiledSubAgent, create_deep_agent
from langchain.agents import create_agent
    
    
def internet_search(query: str) -> str:
    """执行网页搜索。"""
    return f"search results for {query}"
    
    
research_instructions = "You are a research coordinator."
your_model = "openai:gpt-5.5"
specialized_tools: list = []
    
# 创建自定义智能体图
custom_graph = create_agent(
    model=your_model,
    tools=specialized_tools,
    system_prompt="You are a specialized agent for data analysis...",
)
    
# 将其用作自定义子智能体
custom_subagent = CompiledSubAgent(
    name="data-analyzer",
    description="用于复杂数据分析任务的专业智能体",
    runnable=custom_graph,
)
    
subagents = [custom_subagent]
    
agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    tools=[internet_search],
    system_prompt=research_instructions,
    subagents=subagents,
)

from deepagents import CompiledSubAgent, create_deep_agent
from langchain.agents import create_agent
    
    
def internet_search(query: str) -> str:
    """执行网页搜索。"""
    return f"search results for {query}"
    
    
research_instructions = "You are a research coordinator."
your_model = "openai:gpt-5.5"
specialized_tools: list = []
    
# 创建自定义智能体图
custom_graph = create_agent(
    model=your_model,
    tools=specialized_tools,
    system_prompt="You are a specialized agent for data analysis...",
)
    
# 将其用作自定义子智能体
custom_subagent = CompiledSubAgent(
    name="data-analyzer",
    description="用于复杂数据分析任务的专业智能体",
    runnable=custom_graph,
)
    
subagents = [custom_subagent]
    
agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    tools=[internet_search],
    system_prompt=research_instructions,
    subagents=subagents,
)

from deepagents import CompiledSubAgent, create_deep_agent
from langchain.agents import create_agent
    
    
def internet_search(query: str) -> str:
    """执行网页搜索。"""
    return f"search results for {query}"
    
    
research_instructions = "You are a research coordinator."
your_model = "openai:gpt-5.5"
specialized_tools: list = []
    
# 创建自定义智能体图
custom_graph = create_agent(
    model=your_model,
    tools=specialized_tools,
    system_prompt="You are a specialized agent for data analysis...",
)
    
# 将其用作自定义子智能体
custom_subagent = CompiledSubAgent(
    name="data-analyzer",
    description="用于复杂数据分析任务的专业智能体",
    runnable=custom_graph,
)
    
subagents = [custom_subagent]
    
agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    tools=[internet_search],
    system_prompt=research_instructions,
    subagents=subagents,
)

动态子代理

默认情况下，主代理通过 task 工具调用委派给子代理（它可以在单个轮次中发出多个调用以并行运行它们）。附加了解释器后，代理可以改为从代码中派发子代理——使用循环、分支和并行批处理将工作分散到多个项目并以编程方式综合结果。这称为动态子代理。当工作跨越许多独立单元（审查目录中的每个文件、分流一批工单）、需要多个视角，或受益于递归分析时，请考虑使用动态子代理。

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

启用动态子代理

只要代理拥有子代理和解释器中间件，动态子代理就可用。安装 QuickJS 解释器包，然后将 CodeInterpreterMiddleware 添加到您的代理。

pip install -U "deepagents[quickjs]"

uv add "deepagents[quickjs]"

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    subagents=[{
        "name": "reviewer",
        "description": "审查代码以发现安全问题，引用行号并说明严重程度",
        "system_prompt": "您是一位专注于安全的代码审查员。请报告问题，注明行号和严重程度。",
    }],
    middleware=[CodeInterpreterMiddleware()],
)

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="openai:gpt-5.5",
    subagents=[{
        "name": "reviewer",
        "description": "审查代码以发现安全问题，引用行号并说明严重程度",
        "system_prompt": "您是一位专注于安全的代码审查员。请报告问题，注明行号和严重程度。",
    }],
    middleware=[CodeInterpreterMiddleware()],
)

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    subagents=[{
        "name": "reviewer",
        "description": "审查代码以发现安全问题，引用行号并说明严重程度",
        "system_prompt": "您是一位专注于安全的代码审查员。请报告问题，注明行号和严重程度。",
    }],
    middleware=[CodeInterpreterMiddleware()],
)

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    subagents=[{
        "name": "reviewer",
        "description": "审查代码以发现安全问题，引用行号并说明严重程度",
        "system_prompt": "您是一位专注于安全的代码审查员。请报告问题，注明行号和严重程度。",
    }],
    middleware=[CodeInterpreterMiddleware()],
)

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    subagents=[{
        "name": "reviewer",
        "description": "审查代码以发现安全问题，引用行号并说明严重程度",
        "system_prompt": "您是一位专注于安全的代码审查员。请报告问题，注明行号和严重程度。",
    }],
    middleware=[CodeInterpreterMiddleware()],
)

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    subagents=[{
        "name": "reviewer",
        "description": "审查代码以发现安全问题，引用行号并说明严重程度",
        "system_prompt": "您是一位专注于安全的代码审查员。请报告问题，注明行号和严重程度。",
    }],
    middleware=[CodeInterpreterMiddleware()],
)

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    subagents=[{
        "name": "reviewer",
        "description": "审查代码以发现安全问题，引用行号并说明严重程度",
        "system_prompt": "您是一位专注于安全的代码审查员。请报告问题，注明行号和严重程度。",
    }],
    middleware=[CodeInterpreterMiddleware()],
)

只要代理拥有子代理和解释器中间件，动态子代理派发默认开启。传递 CodeInterpreterMiddleware(subagents=False) 以要求通过常规 task 工具路径派发。解释器需要 langchain-quickjs>=0.2.0 和 Python >=3.11。

触发动态编排

动态派发是隐式的：代理根据任务的形状决定是否从代码中分散工作，而不是通过每次调用的标志。

“workflow”一词是一个有用的触发词。 内置的解释器系统提示将“workflow”视为一个信号，表示通过解释器组织工作——从代码中使用 task() 派发子代理。将请求表述为“workflow”是一个您可以在选择启用动态编排时拉动的有意杠杆：当您希望代理从代码中分散工作时，请包含它。对于单个直接委派，请直接明了地表述请求。

例如，将请求表述为“workflow”会启用从代码中的扇出：

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

python 使用 stream_events 获取类型化投影——用于子代理、消息、工具调用和值的独立迭代器——以便您可以独立消费每个。 :::

流式传输子代理进度

最简单的模式是迭代 stream.subagents 以跟踪每个委派的任务开始、运行和完成。每个子代理句柄都公开 .name、.messages、.tool_calls 和 .output。

from deepagents import (
    create_deep_agent
)

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    system_prompt=(
        "你是一个没有研究知识的项目协调员。 "
        "对于每个用户请求，你必须调用 task() 工具， "
        "并将 subagent_type 设置为 research-agent。 "
        "永远不要自己回答研究问题。"
    ),
    subagents=[
        {
            "name": "research-agent",
            "description": (
                "将研究任务委派给此子代理。每次只给出一个主题。"
            ),
            "system_prompt": (
                "你是一个出色的研究员。返回简要的总结。"
            ),
        },
    ],
    name="main-agent",
)

if __name__ == "__main__":
    stream = agent.stream_events(
        {
            "messages": [
                {
                    "role": "user",
                    "content": "研究一个量子计算的最新进展。",
                }
            ]
        },
        version="v3",
    )

    coordinator_messages: list[str] = []
    subagent_handles = []

    for name, item in stream.interleave("messages", "subagents"):
        if name == "messages":
            print("[协调员]", item.text)
            coordinator_messages.append(item.text)
        else:
            print(f"[{item.name}] 已启动")
            subagent_handles.append(item)
            for message in item.messages:
                print(f"[{item.name}]", message.text)
            print(f"[{item.name}] 状态: {item.status}")

from deepagents import (
    create_deep_agent
)

agent = create_deep_agent(
    model="openai:gpt-5.5",
    system_prompt=(
        "你是一个没有研究知识的项目协调员。 "
        "对于每个用户请求，你必须调用 task() 工具， "
        "并将 subagent_type 设置为 research-agent。 "
        "永远不要自己回答研究问题。"
    ),
    subagents=[
        {
            "name": "research-agent",
            "description": (
                "将研究任务委派给此子代理。每次只给出一个主题。"
            ),
            "system_prompt": (
                "你是一个出色的研究员。返回简要的总结。"
            ),
        },
    ],
    name="main-agent",
)

if __name__ == "__main__":
    stream = agent.stream_events(
        {
            "messages": [
                {
                    "role": "user",
                    "content": "研究一个量子计算的最新进展。",
                }
            ]
        },
        version="v3",
    )

    coordinator_messages: list[str] = []
    subagent_handles = []

    for name, item in stream.interleave("messages", "subagents"):
        if name == "messages":
            print("[协调员]", item.text)
            coordinator_messages.append(item.text)
        else:
            print(f"[{item.name}] 已启动")
            subagent_handles.append(item)
            for message in item.messages:
                print(f"[{item.name}]", message.text)
            print(f"[{item.name}] 状态: {item.status}")

from deepagents import (
    create_deep_agent
)

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    system_prompt=(
        "你是一个没有研究知识的项目协调员。 "
        "对于每个用户请求，你必须调用 task() 工具， "
        "并将 subagent_type 设置为 research-agent。 "
        "永远不要自己回答研究问题。"
    ),
    subagents=[
        {
            "name": "research-agent",
            "description": (
                "将研究任务委派给此子代理。每次只给出一个主题。"
            ),
            "system_prompt": (
                "你是一个出色的研究员。返回简要的总结。"
            ),
        },
    ],
    name="main-agent",
)

if __name__ == "__main__":
    stream = agent.stream_events(
        {
            "messages": [
                {
                    "role": "user",
                    "content": "研究一个量子计算的最新进展。",
                }
            ]
        },
        version="v3",
    )

    coordinator_messages: list[str] = []
    subagent_handles = []

    for name, item in stream.interleave("messages", "subagents"):
        if name == "messages":
            print("[协调员]", item.text)
            coordinator_messages.append(item.text)
        else:
            print(f"[{item.name}] 已启动")
            subagent_handles.append(item)
            for message in item.messages:
                print(f"[{item.name}]", message.text)
            print(f"[{item.name}] 状态: {item.status}")

from deepagents import (
    create_deep_agent
)

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    system_prompt=(
        "你是一个没有研究知识的项目协调员。 "
        "对于每个用户请求，你必须调用 task() 工具， "
        "并将 subagent_type 设置为 research-agent。 "
        "永远不要自己回答研究问题。"
    ),
    subagents=[
        {
            "name": "research-agent",
            "description": (
                "将研究任务委派给此子代理。每次只给出一个主题。"
            ),
            "system_prompt": (
                "你是一个出色的研究员。返回简要的总结。"
            ),
        },
    ],
    name="main-agent",
)

if __name__ == "__main__":
    stream = agent.stream_events(
        {
            "messages": [
                {
                    "role": "user",
                    "content": "研究一个量子计算的最新进展。",
                }
            ]
        },
        version="v3",
    )

    coordinator_messages: list[str] = []
    subagent_handles = []

    for name, item in stream.interleave("messages", "subagents"):
        if name == "messages":
            print("[协调员]", item.text)
            coordinator_messages.append(item.text)
        else:
            print(f"[{item.name}] 已启动")
            subagent_handles.append(item)
            for message in item.messages:
                print(f"[{item.name}]", message.text)
            print(f"[{item.name}] 状态: {item.status}")

from deepagents import (
    create_deep_agent
)

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    system_prompt=(
        "你是一个没有研究知识的项目协调员。 "
        "对于每个用户请求，你必须调用 task() 工具， "
        "并将 subagent_type 设置为 research-agent。 "
        "永远不要自己回答研究问题。"
    ),
    subagents=[
        {
            "name": "research-agent",
            "description": (
                "将研究任务委派给此子代理。每次只给出一个主题。"
            ),
            "system_prompt": (
                "你是一个出色的研究员。返回简要的总结。"
            ),
        },
    ],
    name="main-agent",
)

if __name__ == "__main__":
    stream = agent.stream_events(
        {
            "messages": [
                {
                    "role": "user",
                    "content": "研究一个量子计算的最新进展。",
                }
            ]
        },
        version="v3",
    )

    coordinator_messages: list[str] = []
    subagent_handles = []

    for name, item in stream.interleave("messages", "subagents"):
        if name == "messages":
            print("[协调员]", item.text)
            coordinator_messages.append(item.text)
        else:
            print(f"[{item.name}] 已启动")
            subagent_handles.append(item)
            for message in item.messages:
                print(f"[{item.name}]", message.text)
            print(f"[{item.name}] 状态: {item.status}")

from deepagents import (
    create_deep_agent
)

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    system_prompt=(
        "你是一个没有研究知识的项目协调员。 "
        "对于每个用户请求，你必须调用 task() 工具， "
        "并将 subagent_type 设置为 research-agent。 "
        "永远不要自己回答研究问题。"
    ),
    subagents=[
        {
            "name": "research-agent",
            "description": (
                "将研究任务委派给此子代理。每次只给出一个主题。"
            ),
            "system_prompt": (
                "你是一个出色的研究员。返回简要的总结。"
            ),
        },
    ],
    name="main-agent",
)

if __name__ == "__main__":
    stream = agent.stream_events(
        {
            "messages": [
                {
                    "role": "user",
                    "content": "研究一个量子计算的最新进展。",
                }
            ]
        },
        version="v3",
    )

    coordinator_messages: list[str] = []
    subagent_handles = []

    for name, item in stream.interleave("messages", "subagents"):
        if name == "messages":
            print("[协调员]", item.text)
            coordinator_messages.append(item.text)
        else:
            print(f"[{item.name}] 已启动")
            subagent_handles.append(item)
            for message in item.messages:
                print(f"[{item.name}]", message.text)
            print(f"[{item.name}] 状态: {item.status}")

from deepagents import (
    create_deep_agent
)

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    system_prompt=(
        "你是一个没有研究知识的项目协调员。 "
        "对于每个用户请求，你必须调用 task() 工具， "
        "并将 subagent_type 设置为 research-agent。 "
        "永远不要自己回答研究问题。"
    ),
    subagents=[
        {
            "name": "research-agent",
            "description": (
                "将研究任务委派给此子代理。每次只给出一个主题。"
            ),
            "system_prompt": (
                "你是一个出色的研究员。返回简要的总结。"
            ),
        },
    ],
    name="main-agent",
)

if __name__ == "__main__":
    stream = agent.stream_events(
        {
            "messages": [
                {
                    "role": "user",
                    "content": "研究一个量子计算的最新进展。",
                }
            ]
        },
        version="v3",
    )

    coordinator_messages: list[str] = []
    subagent_handles = []

    for name, item in stream.interleave("messages", "subagents"):
        if name == "messages":
            print("[协调员]", item.text)
            coordinator_messages.append(item.text)
        else:
            print(f"[{item.name}] 已启动")
            subagent_handles.append(item)
            for message in item.messages:
                print(f"[{item.name}]", message.text)
            print(f"[{item.name}] 状态: {item.status}")

LangSmith 追踪

当您的深度代理运行时，由子代理或协调器执行的所有运行都将在其元数据中的 lc_agent_name 键下拥有代理名称——例如 {'lc_agent_name': 'research-agent'}。这使您能够在 LangSmith 中按子代理识别和过滤运行。显示元数据的 LangSmith 示例追踪

在 LangSmith 中打开运行以比较协调器追踪与每个子代理运行。请遵循可观测性快速入门进行设置。我们建议您还设置 LangSmith Engine，它会监控您的追踪、检测问题并提出修复建议。

在 LangSmith 中按子代理过滤

因为每个子代理的 name 都写入其产生的每个运行的 lc_agent_name 元数据键中，您可以使用 LangSmith 的元数据过滤来隔离来自特定子代理的所有运行——这对于调试、监控或比较子代理随时间的行为非常有用。

在 LangSmith UI 中过滤

在 LangSmith 中打开您的追踪项目。
在追踪项目页面将视图切换到 Runs 以查看单个跨度。
单击 Add filter 并选择 Metadata。
将 Key 设置为 lc_agent_name，将 Value 设置为子代理名称，例如 coordinator。

LangSmith Runs 视图，lc_agent_name 元数据过滤器设置为 coordinator

这将仅显示该子代理产生的运行。您可以将过滤器保存为命名视图以便重复使用。有关过滤选项的完整参考，请参阅过滤追踪。

使用 SDK 以编程方式过滤

在 LangSmith 过滤查询语言中使用 has 比较器通过元数据键值对匹配运行：

from langsmith import Client

client = Client()

runs = client.list_runs(
    project_name="<your-project>",
    filter='has(metadata, \'{"lc_agent_name": "research-agent"}\')',
)

for run in runs:
    print(run.name, run.start_time, run.status)

要获取来自任何命名子代理（不包括主代理）的运行，请过滤具有 lc_agent_name 键的运行：

runs = client.list_runs(
    project_name="<your-project>",
    filter="has(metadata, 'lc_agent_name')",
)

有关完整的过滤查询语言参考，请参阅追踪查询语法。

结构化输出

子代理支持结构化输出，因此父代理接收到的是可预测、可解析的 JSON，而不是自由格式文本。

子代理的结构化输出需要 deepagents>=0.5.3。

在子代理配置上传递 response_format。当子代理完成时，其结构化响应将被 JSON 序列化并作为 ToolMessage 内容返回给父代理。该模式接受 create_agent 支持的任何内容：Pydantic 模型、ToolStrategy(...)、ProviderStrategy(...) 或原始模式类型。

import asyncio

from pydantic import BaseModel, Field

from deepagents import create_deep_agent


def web_search(query: str) -> str:
    """搜索网络。"""
    return f"搜索 {query} 的网络结果"


class ResearchFindings(BaseModel):
    """研究任务的结构化发现。"""

    summary: str = Field(description="发现摘要")
    confidence: float = Field(description="0 到 1 之间的置信度分数")
    sources: list[str] = Field(description="来源 URL 列表")


research_subagent = {
    "name": "researcher",
    "description": "研究主题并返回结构化发现",
    "system_prompt": "彻底研究给定主题。返回你的发现。",
    "tools": [web_search],
    "response_format": ResearchFindings,
}

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    subagents=[research_subagent],
)

async def main():
    result = await agent.ainvoke(
        {"messages": [{"role": "user", "content": "研究量子计算的最新进展"}]}
    )
    return result

result = asyncio.run(main())

# 父级的 ToolMessage 包含 JSON 序列化的结构化数据：
# '{"summary": "...", "confidence": 0.87, "sources": ["https://..."]}'

import asyncio

from pydantic import BaseModel, Field

from deepagents import create_deep_agent


def web_search(query: str) -> str:
    """搜索网络。"""
    return f"搜索 {query} 的网络结果"


class ResearchFindings(BaseModel):
    """研究任务的结构化发现。"""

    summary: str = Field(description="发现摘要")
    confidence: float = Field(description="0 到 1 之间的置信度分数")
    sources: list[str] = Field(description="来源 URL 列表")


research_subagent = {
    "name": "researcher",
    "description": "研究主题并返回结构化发现",
    "system_prompt": "彻底研究给定主题。返回你的发现。",
    "tools": [web_search],
    "response_format": ResearchFindings,
}

agent = create_deep_agent(
    model="openai:gpt-5.5",
    subagents=[research_subagent],
)

async def main():
    result = await agent.ainvoke(
        {"messages": [{"role": "user", "content": "研究量子计算的最新进展"}]}
    )
    return result

result = asyncio.run(main())

# 父级的 ToolMessage 包含 JSON 序列化的结构化数据：
# '{"summary": "...", "confidence": 0.87, "sources": ["https://..."]}'

import asyncio

from pydantic import BaseModel, Field

from deepagents import create_deep_agent


def web_search(query: str) -> str:
    """搜索网络。"""
    return f"搜索 {query} 的网络结果"


class ResearchFindings(BaseModel):
    """研究任务的结构化发现。"""

    summary: str = Field(description="发现摘要")
    confidence: float = Field(description="0 到 1 之间的置信度分数")
    sources: list[str] = Field(description="来源 URL 列表")


research_subagent = {
    "name": "researcher",
    "description": "研究主题并返回结构化发现",
    "system_prompt": "彻底研究给定主题。返回你的发现。",
    "tools": [web_search],
    "response_format": ResearchFindings,
}

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    subagents=[research_subagent],
)

async def main():
    result = await agent.ainvoke(
        {"messages": [{"role": "user", "content": "研究量子计算的最新进展"}]}
    )
    return result

result = asyncio.run(main())

# 父级的 ToolMessage 包含 JSON 序列化的结构化数据：
# '{"summary": "...", "confidence": 0.87, "sources": ["https://..."]}'

import asyncio

from pydantic import BaseModel, Field

from deepagents import create_deep_agent


def web_search(query: str) -> str:
    """搜索网络。"""
    return f"搜索 {query} 的网络结果"


class ResearchFindings(BaseModel):
    """研究任务的结构化发现。"""

    summary: str = Field(description="发现摘要")
    confidence: float = Field(description="0 到 1 之间的置信度分数")
    sources: list[str] = Field(description="来源 URL 列表")


research_subagent = {
    "name": "researcher",
    "description": "研究主题并返回结构化发现",
    "system_prompt": "彻底研究给定主题。返回你的发现。",
    "tools": [web_search],
    "response_format": ResearchFindings,
}

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    subagents=[research_subagent],
)

async def main():
    result = await agent.ainvoke(
        {"messages": [{"role": "user", "content": "研究量子计算的最新进展"}]}
    )
    return result

result = asyncio.run(main())

# 父级的 ToolMessage 包含 JSON 序列化的结构化数据：
# '{"summary": "...", "confidence": 0.87, "sources": ["https://..."]}'

import asyncio

from pydantic import BaseModel, Field

from deepagents import create_deep_agent


def web_search(query: str) -> str:
    """搜索网络。"""
    return f"搜索 {query} 的网络结果"


class ResearchFindings(BaseModel):
    """研究任务的结构化发现。"""

    summary: str = Field(description="发现摘要")
    confidence: float = Field(description="0 到 1 之间的置信度分数")
    sources: list[str] = Field(description="来源 URL 列表")


research_subagent = {
    "name": "researcher",
    "description": "研究主题并返回结构化发现",
    "system_prompt": "彻底研究给定主题。返回你的发现。",
    "tools": [web_search],
    "response_format": ResearchFindings,
}

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    subagents=[research_subagent],
)

async def main():
    result = await agent.ainvoke(
        {"messages": [{"role": "user", "content": "研究量子计算的最新进展"}]}
    )
    return result

result = asyncio.run(main())

# 父级的 ToolMessage 包含 JSON 序列化的结构化数据：
# '{"summary": "...", "confidence": 0.87, "sources": ["https://..."]}'

import asyncio

from pydantic import BaseModel, Field

from deepagents import create_deep_agent


def web_search(query: str) -> str:
    """搜索网络。"""
    return f"搜索 {query} 的网络结果"


class ResearchFindings(BaseModel):
    """研究任务的结构化发现。"""

    summary: str = Field(description="发现摘要")
    confidence: float = Field(description="0 到 1 之间的置信度分数")
    sources: list[str] = Field(description="来源 URL 列表")


research_subagent = {
    "name": "researcher",
    "description": "研究主题并返回结构化发现",
    "system_prompt": "彻底研究给定主题。返回你的发现。",
    "tools": [web_search],
    "response_format": ResearchFindings,
}

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    subagents=[research_subagent],
)

async def main():
    result = await agent.ainvoke(
        {"messages": [{"role": "user", "content": "研究量子计算的最新进展"}]}
    )
    return result

result = asyncio.run(main())

# 父级的 ToolMessage 包含 JSON 序列化的结构化数据：
# '{"summary": "...", "confidence": 0.87, "sources": ["https://..."]}'

import asyncio

from pydantic import BaseModel, Field

from deepagents import create_deep_agent


def web_search(query: str) -> str:
    """搜索网络。"""
    return f"搜索 {query} 的网络结果"


class ResearchFindings(BaseModel):
    """研究任务的结构化发现。"""

    summary: str = Field(description="发现摘要")
    confidence: float = Field(description="0 到 1 之间的置信度分数")
    sources: list[str] = Field(description="来源 URL 列表")


research_subagent = {
    "name": "researcher",
    "description": "研究主题并返回结构化发现",
    "system_prompt": "彻底研究给定主题。返回你的发现。",
    "tools": [web_search],
    "response_format": ResearchFindings,
}

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    subagents=[research_subagent],
)

async def main():
    result = await agent.ainvoke(
        {"messages": [{"role": "user", "content": "研究量子计算的最新进展"}]}
    )
    return result

result = asyncio.run(main())

# 父级的 ToolMessage 包含 JSON 序列化的结构化数据：
# '{"summary": "...", "confidence": 0.87, "sources": ["https://..."]}'

如果没有 response_format，父代理会原样接收子代理最后的消息文本。使用它时，父代理总是获得符合模式的有效 JSON，这在父代理需要以编程方式处理结果或将其传递给下游工具时非常有用。有关模式类型和策略（工具调用与原生提供程序）的完整详细信息，请参阅结构化输出。

通用子代理

除了任何用户定义的子代理之外，每个深度代理在任何时候都可以访问一个 general-purpose 子代理。此子代理：

使用其自己的应用了配置文件覆盖的默认系统提示
可以访问所有相同的工具
使用相同的模型（除非被覆盖）
从主代理继承技能（当技能已配置时）

覆盖通用子代理

在您的 subagents 列表中包含一个 name="general-purpose" 的子代理以替换默认的。使用此方法可以为通用子代理配置不同的模型、工具或系统提示：

from deepagents import create_deep_agent


def internet_search(query: str) -> str:
    """执行网络搜索。"""
    return f"search results for {query}"


# 主代理使用 Gemini；通用子代理使用 GPT
agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    tools=[internet_search],
    subagents=[
        {
            "name": "general-purpose",
            "description": "用于研究和多步骤任务的通用代理",
            "system_prompt": "你是一个通用助手。",
            "tools": [internet_search],
            "model": "openai:gpt-5.5",  # 为委派任务使用不同的模型
        },
    ],
)

from deepagents import create_deep_agent


def internet_search(query: str) -> str:
    """执行网络搜索。"""
    return f"search results for {query}"


# 主代理使用 Gemini；通用子代理使用 GPT
agent = create_deep_agent(
    model="openai:gpt-5.5",
    tools=[internet_search],
    subagents=[
        {
            "name": "general-purpose",
            "description": "用于研究和多步骤任务的通用代理",
            "system_prompt": "你是一个通用助手。",
            "tools": [internet_search],
            "model": "openai:gpt-5.5",  # 为委派任务使用不同的模型
        },
    ],
)

from deepagents import create_deep_agent


def internet_search(query: str) -> str:
    """执行网络搜索。"""
    return f"search results for {query}"


# 主代理使用 Gemini；通用子代理使用 GPT
agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    tools=[internet_search],
    subagents=[
        {
            "name": "general-purpose",
            "description": "用于研究和多步骤任务的通用代理",
            "system_prompt": "你是一个通用助手。",
            "tools": [internet_search],
            "model": "openai:gpt-5.5",  # 为委派任务使用不同的模型
        },
    ],
)

from deepagents import create_deep_agent


def internet_search(query: str) -> str:
    """执行网络搜索。"""
    return f"search results for {query}"


# 主代理使用 Gemini；通用子代理使用 GPT
agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    tools=[internet_search],
    subagents=[
        {
            "name": "general-purpose",
            "description": "用于研究和多步骤任务的通用代理",
            "system_prompt": "你是一个通用助手。",
            "tools": [internet_search],
            "model": "openai:gpt-5.5",  # 为委派任务使用不同的模型
        },
    ],
)

from deepagents import create_deep_agent


def internet_search(query: str) -> str:
    """执行网络搜索。"""
    return f"search results for {query}"


# 主代理使用 Gemini；通用子代理使用 GPT
agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    tools=[internet_search],
    subagents=[
        {
            "name": "general-purpose",
            "description": "用于研究和多步骤任务的通用代理",
            "system_prompt": "你是一个通用助手。",
            "tools": [internet_search],
            "model": "openai:gpt-5.5",  # 为委派任务使用不同的模型
        },
    ],
)

from deepagents import create_deep_agent


def internet_search(query: str) -> str:
    """执行网络搜索。"""
    return f"search results for {query}"


# 主代理使用 Gemini；通用子代理使用 GPT
agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    tools=[internet_search],
    subagents=[
        {
            "name": "general-purpose",
            "description": "用于研究和多步骤任务的通用代理",
            "system_prompt": "你是一个通用助手。",
            "tools": [internet_search],
            "model": "openai:gpt-5.5",  # 为委派任务使用不同的模型
        },
    ],
)

from deepagents import create_deep_agent


def internet_search(query: str) -> str:
    """执行网络搜索。"""
    return f"search results for {query}"


# 主代理使用 Gemini；通用子代理使用 GPT
agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    tools=[internet_search],
    subagents=[
        {
            "name": "general-purpose",
            "description": "用于研究和多步骤任务的通用代理",
            "system_prompt": "你是一个通用助手。",
            "tools": [internet_search],
            "model": "openai:gpt-5.5",  # 为委派任务使用不同的模型
        },
    ],
)

当您提供一个具有通用名称的子代理时，默认的通用子代理不会被添加。您的规范完全替换了它。要完全移除内置的通用子代理而不是替换它，请将活动驱动配置文件的通用子代理 enabled 标志设置为 False。

何时使用它

通用子代理非常适合在没有专门行为的情况下进行上下文隔离。主代理可以将一个复杂的多步骤任务委派给此子代理，并获得简洁的结果，而不会因为中间工具调用而膨胀。

示例

主代理不是自己进行 10 次网络搜索并用结果填满其上下文，而是委派给通用子代理：task(name="general-purpose", task="研究量子计算趋势")。子代理在内部执行所有搜索，并仅返回摘要。

技能继承

使用 create_deep_agent 配置技能时：

通用子代理：自动从主代理继承技能
自定义子代理：默认不继承技能——使用 skills 参数赋予它们自己的技能

只有配置了技能的子代理才会获得 SkillsMiddleware 实例——没有 skills 参数的自定义子代理则不会。存在时，技能状态在两个方向上都是完全隔离的：父代理的技能对子代理不可见，子代理的技能也不会传播回父代理。

from deepagents import create_deep_agent

research_subagent = {
    "name": "researcher",
    "description": "具有专业技能的研究助理",
    "system_prompt": "你是一名研究员。",
    "tools": [web_search],
    "skills": ["/skills/research/", "/skills/web-search/"],  # 子智能体专属技能
}

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    skills=["/skills/main/"],  # 主智能体和GP子智能体获取这些技能
    subagents=[research_subagent],  # 研究员仅获取自身技能
)

最佳实践

编写清晰的描述

主代理使用描述来决定调用哪个子代理。要具体： ✅ 好： "分析金融数据并生成带有置信度分数的投资洞察" ❌ 差： "处理金融事务"

保持系统提示详细

包含关于如何使用工具和格式化输出的具体指导：

research_subagent = {
    "name": "research-agent",
    "description": "使用网络搜索进行深度研究并综合分析发现",
    "system_prompt": """你是一位细致的研究员。你的工作是：

    1. 将研究问题分解为可搜索的查询
    2. 使用 internet_search 查找相关信息
    3. 将发现综合分析为全面但简洁的摘要
    4. 在提出主张时注明引用来源

    输出格式：
    - 摘要（2-3段）
    - 关键发现（要点列表）
    - 来源（附URL）

    请将回答控制在500字以内，以保持上下文清晰。""",
    "tools": [internet_search],
}

最小化工具集

只给子代理他们需要的工具。这可以提高专注度和安全性：

✅ 正面示例：聚焦的工具集

email_agent = {
    "name": "email-sender",
    "tools": [send_email, validate_email],  # 仅限邮件相关
}

# ❌ 不佳：工具过多
email_agent = {
    "name": "email-sender",
    "tools": [send_email, web_search_tool, database_query, format_document],  # 不聚焦
}

按任务选择模型

不同的模型擅长不同的任务：

subagents = [
    {
        "name": "contract-reviewer",
        "description": "审查法律文件和合同",
        "system_prompt": "你是一位专业的法律审查专家...",
        "tools": [read_document, analyze_contract],
        "model": "google_genai:gemini-3.6-flash",  # 大型上下文，适用于长文档
    },
    {
        "name": "financial-analyst",
        "description": "分析财务数据和市场趋势",
        "system_prompt": "你是一位专业的财务分析师...",
        "tools": [get_stock_price, analyze_fundamentals],
        "model": "openai:gpt-5.5",  # 更擅长数值分析
    },
]

返回简洁的结果

指示子代理返回摘要，而不是原始数据：

data_analyst = {
    "system_prompt": """分析数据并返回以下内容：
    1. 关键见解（3-5个要点）
    2. 综合置信度评分
    3. 建议的下一步行动

    请勿包含：
    - 原始数据
    - 中间计算过程
    - 详细的工具输出

    回复内容控制在300字以内。"""
}

常见模式

多个专业化子代理

为不同的领域创建专业化的子代理：

from deepagents import create_deep_agent

subagents = [
    {
        "name": "data-collector",
        "description": "从各种来源收集原始数据",
        "system_prompt": "收集关于该主题的全面数据",
        "tools": [web_search_tool, api_call, database_query],
    },
    {
        "name": "data-analyzer",
        "description": "分析收集的数据以提取见解",
        "system_prompt": "分析数据并提取关键见解",
        "tools": [statistical_analysis],
    },
    {
        "name": "report-writer",
        "description": "根据分析撰写精炼的报告",
        "system_prompt": "根据见解创建专业报告",
        "tools": [format_document],
    },
]

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    system_prompt="你负责协调数据分析和报告。使用子代理处理专门任务。",
    subagents=subagents,
)

from deepagents import create_deep_agent

subagents = [
    {
        "name": "data-collector",
        "description": "从各种来源收集原始数据",
        "system_prompt": "收集关于该主题的全面数据",
        "tools": [web_search_tool, api_call, database_query],
    },
    {
        "name": "data-analyzer",
        "description": "分析收集的数据以提取见解",
        "system_prompt": "分析数据并提取关键见解",
        "tools": [statistical_analysis],
    },
    {
        "name": "report-writer",
        "description": "根据分析撰写精炼的报告",
        "system_prompt": "根据见解创建专业报告",
        "tools": [format_document],
    },
]

agent = create_deep_agent(
    model="openai:gpt-5.5",
    system_prompt="你负责协调数据分析和报告。使用子代理处理专门任务。",
    subagents=subagents,
)

from deepagents import create_deep_agent

subagents = [
    {
        "name": "data-collector",
        "description": "从各种来源收集原始数据",
        "system_prompt": "收集关于该主题的全面数据",
        "tools": [web_search_tool, api_call, database_query],
    },
    {
        "name": "data-analyzer",
        "description": "分析收集的数据以提取见解",
        "system_prompt": "分析数据并提取关键见解",
        "tools": [statistical_analysis],
    },
    {
        "name": "report-writer",
        "description": "根据分析撰写精炼的报告",
        "system_prompt": "根据见解创建专业报告",
        "tools": [format_document],
    },
]

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    system_prompt="你负责协调数据分析和报告。使用子代理处理专门任务。",
    subagents=subagents,
)

from deepagents import create_deep_agent

subagents = [
    {
        "name": "data-collector",
        "description": "从各种来源收集原始数据",
        "system_prompt": "收集关于该主题的全面数据",
        "tools": [web_search_tool, api_call, database_query],
    },
    {
        "name": "data-analyzer",
        "description": "分析收集的数据以提取见解",
        "system_prompt": "分析数据并提取关键见解",
        "tools": [statistical_analysis],
    },
    {
        "name": "report-writer",
        "description": "根据分析撰写精炼的报告",
        "system_prompt": "根据见解创建专业报告",
        "tools": [format_document],
    },
]

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    system_prompt="你负责协调数据分析和报告。使用子代理处理专门任务。",
    subagents=subagents,
)

from deepagents import create_deep_agent

subagents = [
    {
        "name": "data-collector",
        "description": "从各种来源收集原始数据",
        "system_prompt": "收集关于该主题的全面数据",
        "tools": [web_search_tool, api_call, database_query],
    },
    {
        "name": "data-analyzer",
        "description": "分析收集的数据以提取见解",
        "system_prompt": "分析数据并提取关键见解",
        "tools": [statistical_analysis],
    },
    {
        "name": "report-writer",
        "description": "根据分析撰写精炼的报告",
        "system_prompt": "根据见解创建专业报告",
        "tools": [format_document],
    },
]

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    system_prompt="你负责协调数据分析和报告。使用子代理处理专门任务。",
    subagents=subagents,
)

from deepagents import create_deep_agent

subagents = [
    {
        "name": "data-collector",
        "description": "从各种来源收集原始数据",
        "system_prompt": "收集关于该主题的全面数据",
        "tools": [web_search_tool, api_call, database_query],
    },
    {
        "name": "data-analyzer",
        "description": "分析收集的数据以提取见解",
        "system_prompt": "分析数据并提取关键见解",
        "tools": [statistical_analysis],
    },
    {
        "name": "report-writer",
        "description": "根据分析撰写精炼的报告",
        "system_prompt": "根据见解创建专业报告",
        "tools": [format_document],
    },
]

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    system_prompt="你负责协调数据分析和报告。使用子代理处理专门任务。",
    subagents=subagents,
)

from deepagents import create_deep_agent

subagents = [
    {
        "name": "data-collector",
        "description": "从各种来源收集原始数据",
        "system_prompt": "收集关于该主题的全面数据",
        "tools": [web_search_tool, api_call, database_query],
    },
    {
        "name": "data-analyzer",
        "description": "分析收集的数据以提取见解",
        "system_prompt": "分析数据并提取关键见解",
        "tools": [statistical_analysis],
    },
    {
        "name": "report-writer",
        "description": "根据分析撰写精炼的报告",
        "system_prompt": "根据见解创建专业报告",
        "tools": [format_document],
    },
]

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    system_prompt="你负责协调数据分析和报告。使用子代理处理专门任务。",
    subagents=subagents,
)

工作流：

主代理创建高级计划
将数据收集委派给 data-collector
将结果传递给 data-analyzer
将洞察发送给 report-writer
编译最终输出

每个子代理都在干净的上下文中工作，只专注于其任务。

上下文管理

当您使用运行时上下文调用父代理时，该上下文会自动传播到所有子代理。每个子代理运行都会接收到您在父代理 invoke / ainvoke 调用中传递的相同运行时上下文。这意味着在任何子代理内部运行的工具都可以访问您提供给父代理的相同上下文值：

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.messages import HumanMessage
from langchain.tools import ToolRuntime, tool


@dataclass
class Context:
    user_id: str
    session_id: str


@tool
def get_user_data(query: str, runtime: ToolRuntime[Context]) -> str:
    """获取当前用户的数据。"""
    user_id = runtime.context.user_id
    return f"Data for user {user_id}: {query}"


research_subagent = {
    "name": "researcher",
    "description": "为当前用户进行研究",
    "system_prompt": "你是一名研究助理。",
    "tools": [get_user_data],
}

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    subagents=[research_subagent],
    context_schema=Context,
)

# 上下文会自动流向研究子代理及其工具
result = agent.invoke(
    {"messages": [HumanMessage("查找我的近期活动")]},
    context=Context(user_id="user-123", session_id="abc"),
)

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.messages import HumanMessage
from langchain.tools import ToolRuntime, tool


@dataclass
class Context:
    user_id: str
    session_id: str


@tool
def get_user_data(query: str, runtime: ToolRuntime[Context]) -> str:
    """获取当前用户的数据。"""
    user_id = runtime.context.user_id
    return f"Data for user {user_id}: {query}"


research_subagent = {
    "name": "researcher",
    "description": "为当前用户进行研究",
    "system_prompt": "你是一名研究助理。",
    "tools": [get_user_data],
}

agent = create_deep_agent(
    model="openai:gpt-5.5",
    subagents=[research_subagent],
    context_schema=Context,
)

# 上下文会自动流向研究子代理及其工具
result = agent.invoke(
    {"messages": [HumanMessage("查找我的近期活动")]},
    context=Context(user_id="user-123", session_id="abc"),
)

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.messages import HumanMessage
from langchain.tools import ToolRuntime, tool


@dataclass
class Context:
    user_id: str
    session_id: str


@tool
def get_user_data(query: str, runtime: ToolRuntime[Context]) -> str:
    """获取当前用户的数据。"""
    user_id = runtime.context.user_id
    return f"Data for user {user_id}: {query}"


research_subagent = {
    "name": "researcher",
    "description": "为当前用户进行研究",
    "system_prompt": "你是一名研究助理。",
    "tools": [get_user_data],
}

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    subagents=[research_subagent],
    context_schema=Context,
)

# 上下文会自动流向研究子代理及其工具
result = agent.invoke(
    {"messages": [HumanMessage("查找我的近期活动")]},
    context=Context(user_id="user-123", session_id="abc"),
)

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.messages import HumanMessage
from langchain.tools import ToolRuntime, tool


@dataclass
class Context:
    user_id: str
    session_id: str


@tool
def get_user_data(query: str, runtime: ToolRuntime[Context]) -> str:
    """获取当前用户的数据。"""
    user_id = runtime.context.user_id
    return f"Data for user {user_id}: {query}"


research_subagent = {
    "name": "researcher",
    "description": "为当前用户进行研究",
    "system_prompt": "你是一名研究助理。",
    "tools": [get_user_data],
}

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    subagents=[research_subagent],
    context_schema=Context,
)

# 上下文会自动流向研究子代理及其工具
result = agent.invoke(
    {"messages": [HumanMessage("查找我的近期活动")]},
    context=Context(user_id="user-123", session_id="abc"),
)

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.messages import HumanMessage
from langchain.tools import ToolRuntime, tool


@dataclass
class Context:
    user_id: str
    session_id: str


@tool
def get_user_data(query: str, runtime: ToolRuntime[Context]) -> str:
    """获取当前用户的数据。"""
    user_id = runtime.context.user_id
    return f"Data for user {user_id}: {query}"


research_subagent = {
    "name": "researcher",
    "description": "为当前用户进行研究",
    "system_prompt": "你是一名研究助理。",
    "tools": [get_user_data],
}

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    subagents=[research_subagent],
    context_schema=Context,
)

# 上下文会自动流向研究子代理及其工具
result = agent.invoke(
    {"messages": [HumanMessage("查找我的近期活动")]},
    context=Context(user_id="user-123", session_id="abc"),
)

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.messages import HumanMessage
from langchain.tools import ToolRuntime, tool


@dataclass
class Context:
    user_id: str
    session_id: str


@tool
def get_user_data(query: str, runtime: ToolRuntime[Context]) -> str:
    """获取当前用户的数据。"""
    user_id = runtime.context.user_id
    return f"Data for user {user_id}: {query}"


research_subagent = {
    "name": "researcher",
    "description": "为当前用户进行研究",
    "system_prompt": "你是一名研究助理。",
    "tools": [get_user_data],
}

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    subagents=[research_subagent],
    context_schema=Context,
)

# 上下文会自动流向研究子代理及其工具
result = agent.invoke(
    {"messages": [HumanMessage("查找我的近期活动")]},
    context=Context(user_id="user-123", session_id="abc"),
)

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.messages import HumanMessage
from langchain.tools import ToolRuntime, tool


@dataclass
class Context:
    user_id: str
    session_id: str


@tool
def get_user_data(query: str, runtime: ToolRuntime[Context]) -> str:
    """获取当前用户的数据。"""
    user_id = runtime.context.user_id
    return f"Data for user {user_id}: {query}"


research_subagent = {
    "name": "researcher",
    "description": "为当前用户进行研究",
    "system_prompt": "你是一名研究助理。",
    "tools": [get_user_data],
}

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    subagents=[research_subagent],
    context_schema=Context,
)

# 上下文会自动流向研究子代理及其工具
result = agent.invoke(
    {"messages": [HumanMessage("查找我的近期活动")]},
    context=Context(user_id="user-123", session_id="abc"),
)

每个子代理的上下文

所有子代理都接收相同的父上下文。要传递特定于某个子代理的配置，请在扁平的 context 映射中使用命名空间键（用子代理名称为键添加前缀，例如 researcher:max_depth），或者将这些设置建模为上下文类型上的单独字段：

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.messages import HumanMessage
from langchain.tools import ToolRuntime, tool


@dataclass
class Context:
    user_id: str
    researcher_max_depth: int | None = None
    fact_checker_strict_mode: bool | None = None


@tool
def verify_claim(claim: str, runtime: ToolRuntime[Context]) -> str:
    """验证一个事实性主张。"""
    strict_mode = runtime.context.fact_checker_strict_mode or False
    if strict_mode:
        return strict_verification(claim)
    return basic_verification(claim)


agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    subagents=[
        {
            "name": "fact-checker",
            "description": "验证事实性主张",
            "system_prompt": "请仔细验证主张。",
            "tools": [verify_claim],
        },
    ],
    context_schema=Context,
)

result = agent.invoke(
    {"messages": [HumanMessage("请研究此内容并验证这些主张")]},
    context=Context(
        user_id="user-123",
        researcher_max_depth=3,
        fact_checker_strict_mode=True,
    ),
)

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.messages import HumanMessage
from langchain.tools import ToolRuntime, tool


@dataclass
class Context:
    user_id: str
    researcher_max_depth: int | None = None
    fact_checker_strict_mode: bool | None = None


@tool
def verify_claim(claim: str, runtime: ToolRuntime[Context]) -> str:
    """验证一个事实性主张。"""
    strict_mode = runtime.context.fact_checker_strict_mode or False
    if strict_mode:
        return strict_verification(claim)
    return basic_verification(claim)


agent = create_deep_agent(
    model="openai:gpt-5.5",
    subagents=[
        {
            "name": "fact-checker",
            "description": "验证事实性主张",
            "system_prompt": "请仔细验证主张。",
            "tools": [verify_claim],
        },
    ],
    context_schema=Context,
)

result = agent.invoke(
    {"messages": [HumanMessage("请研究此内容并验证这些主张")]},
    context=Context(
        user_id="user-123",
        researcher_max_depth=3,
        fact_checker_strict_mode=True,
    ),
)

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.messages import HumanMessage
from langchain.tools import ToolRuntime, tool


@dataclass
class Context:
    user_id: str
    researcher_max_depth: int | None = None
    fact_checker_strict_mode: bool | None = None


@tool
def verify_claim(claim: str, runtime: ToolRuntime[Context]) -> str:
    """验证一个事实性主张。"""
    strict_mode = runtime.context.fact_checker_strict_mode or False
    if strict_mode:
        return strict_verification(claim)
    return basic_verification(claim)


agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    subagents=[
        {
            "name": "fact-checker",
            "description": "验证事实性主张",
            "system_prompt": "请仔细验证主张。",
            "tools": [verify_claim],
        },
    ],
    context_schema=Context,
)

result = agent.invoke(
    {"messages": [HumanMessage("请研究此内容并验证这些主张")]},
    context=Context(
        user_id="user-123",
        researcher_max_depth=3,
        fact_checker_strict_mode=True,
    ),
)

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.messages import HumanMessage
from langchain.tools import ToolRuntime, tool


@dataclass
class Context:
    user_id: str
    researcher_max_depth: int | None = None
    fact_checker_strict_mode: bool | None = None


@tool
def verify_claim(claim: str, runtime: ToolRuntime[Context]) -> str:
    """验证一个事实性主张。"""
    strict_mode = runtime.context.fact_checker_strict_mode or False
    if strict_mode:
        return strict_verification(claim)
    return basic_verification(claim)


agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    subagents=[
        {
            "name": "fact-checker",
            "description": "验证事实性主张",
            "system_prompt": "请仔细验证主张。",
            "tools": [verify_claim],
        },
    ],
    context_schema=Context,
)

result = agent.invoke(
    {"messages": [HumanMessage("请研究此内容并验证这些主张")]},
    context=Context(
        user_id="user-123",
        researcher_max_depth=3,
        fact_checker_strict_mode=True,
    ),
)

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.messages import HumanMessage
from langchain.tools import ToolRuntime, tool


@dataclass
class Context:
    user_id: str
    researcher_max_depth: int | None = None
    fact_checker_strict_mode: bool | None = None


@tool
def verify_claim(claim: str, runtime: ToolRuntime[Context]) -> str:
    """验证一个事实性主张。"""
    strict_mode = runtime.context.fact_checker_strict_mode or False
    if strict_mode:
        return strict_verification(claim)
    return basic_verification(claim)


agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    subagents=[
        {
            "name": "fact-checker",
            "description": "验证事实性主张",
            "system_prompt": "请仔细验证主张。",
            "tools": [verify_claim],
        },
    ],
    context_schema=Context,
)

result = agent.invoke(
    {"messages": [HumanMessage("请研究此内容并验证这些主张")]},
    context=Context(
        user_id="user-123",
        researcher_max_depth=3,
        fact_checker_strict_mode=True,
    ),
)

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.messages import HumanMessage
from langchain.tools import ToolRuntime, tool


@dataclass
class Context:
    user_id: str
    researcher_max_depth: int | None = None
    fact_checker_strict_mode: bool | None = None


@tool
def verify_claim(claim: str, runtime: ToolRuntime[Context]) -> str:
    """验证一个事实性主张。"""
    strict_mode = runtime.context.fact_checker_strict_mode or False
    if strict_mode:
        return strict_verification(claim)
    return basic_verification(claim)


agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    subagents=[
        {
            "name": "fact-checker",
            "description": "验证事实性主张",
            "system_prompt": "请仔细验证主张。",
            "tools": [verify_claim],
        },
    ],
    context_schema=Context,
)

result = agent.invoke(
    {"messages": [HumanMessage("请研究此内容并验证这些主张")]},
    context=Context(
        user_id="user-123",
        researcher_max_depth=3,
        fact_checker_strict_mode=True,
    ),
)

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.messages import HumanMessage
from langchain.tools import ToolRuntime, tool


@dataclass
class Context:
    user_id: str
    researcher_max_depth: int | None = None
    fact_checker_strict_mode: bool | None = None


@tool
def verify_claim(claim: str, runtime: ToolRuntime[Context]) -> str:
    """验证一个事实性主张。"""
    strict_mode = runtime.context.fact_checker_strict_mode or False
    if strict_mode:
        return strict_verification(claim)
    return basic_verification(claim)


agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    subagents=[
        {
            "name": "fact-checker",
            "description": "验证事实性主张",
            "system_prompt": "请仔细验证主张。",
            "tools": [verify_claim],
        },
    ],
    context_schema=Context,
)

result = agent.invoke(
    {"messages": [HumanMessage("请研究此内容并验证这些主张")]},
    context=Context(
        user_id="user-123",
        researcher_max_depth=3,
        fact_checker_strict_mode=True,
    ),
)

识别哪个子代理调用了工具

当同一个工具在父代理和多个子代理之间共享时，您可以使用 lc_agent_name 元数据（与流式传输中使用的值相同）来确定是哪个代理发起了调用：

# :snippet-start: subagents-shared-lookup-py
from langchain.tools import ToolRuntime, tool


@tool
def shared_lookup(query: str, runtime: ToolRuntime) -> str:
    """查询信息。"""
    agent_name = runtime.config.get("metadata", {}).get("lc_agent_name")
    if agent_name == "fact-checker":
        return strict_lookup(query)
    return general_lookup(query)

您可以结合两种模式——从 runtime.context 读取代理特定设置，并在分支工具行为时从 runtime.config 元数据读取 lc_agent_name。

from dataclasses import dataclass

from langchain.tools import ToolRuntime, tool


@dataclass
class Context:
    user_id: str
    researcher_max_depth: int | None = None
    fact_checker_strict_mode: bool | None = None


@tool
def flexible_search(query: str, runtime: ToolRuntime[Context]) -> str:
    """使用特定于代理的设置进行搜索。"""
    agent_name = runtime.config.get("metadata", {}).get("lc_agent_name", "unknown")
    ctx = runtime.context
    if agent_name == "researcher":
        max_results = ctx.researcher_max_depth or 5
    else:
        max_results = 5
    include_raw = False

    return perform_search(query, max_results=max_results, include_raw=include_raw)

故障排除

子代理未被调用

问题：主代理试图自己完成工作而不是委派。 解决方案：

使描述更具体：

# ✅ 好
good_subagent = {
    "name": "研究专家",
    "description": "使用网络搜索对特定主题进行深入研究。当您需要需要多次搜索的详细信息时使用。",
}

# ❌ Bad
bad_subagent = {
    "name": "helper",
    "description": "helps with stuff",
}

指示主代理委派：

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    system_prompt="""...你的指令...

        重要提示：对于复杂任务，请使用 task() 工具委托给你的子智能体。
        这能保持你的上下文整洁，并提升结果质量。""",
    subagents=[
            {
                "name": "research-agent",
                "description": "执行研究工作",
                "system_prompt": "你是一名研究员。",
            },
        ],
)

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="openai:gpt-5.5",
    system_prompt="""...你的指令...

        重要提示：对于复杂任务，请使用 task() 工具委托给你的子智能体。
        这能保持你的上下文整洁，并提升结果质量。""",
    subagents=[
            {
                "name": "research-agent",
                "description": "执行研究工作",
                "system_prompt": "你是一名研究员。",
            },
        ],
)

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    system_prompt="""...你的指令...

        重要提示：对于复杂任务，请使用 task() 工具委托给你的子智能体。
        这能保持你的上下文整洁，并提升结果质量。""",
    subagents=[
            {
                "name": "research-agent",
                "description": "执行研究工作",
                "system_prompt": "你是一名研究员。",
            },
        ],
)

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    system_prompt="""...你的指令...

        重要提示：对于复杂任务，请使用 task() 工具委托给你的子智能体。
        这能保持你的上下文整洁，并提升结果质量。""",
    subagents=[
            {
                "name": "research-agent",
                "description": "执行研究工作",
                "system_prompt": "你是一名研究员。",
            },
        ],
)

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    system_prompt="""...你的指令...

        重要提示：对于复杂任务，请使用 task() 工具委托给你的子智能体。
        这能保持你的上下文整洁，并提升结果质量。""",
    subagents=[
            {
                "name": "research-agent",
                "description": "执行研究工作",
                "system_prompt": "你是一名研究员。",
            },
        ],
)

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    system_prompt="""...你的指令...

        重要提示：对于复杂任务，请使用 task() 工具委托给你的子智能体。
        这能保持你的上下文整洁，并提升结果质量。""",
    subagents=[
            {
                "name": "research-agent",
                "description": "执行研究工作",
                "system_prompt": "你是一名研究员。",
            },
        ],
)

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    system_prompt="""...你的指令...

        重要提示：对于复杂任务，请使用 task() 工具委托给你的子智能体。
        这能保持你的上下文整洁，并提升结果质量。""",
    subagents=[
            {
                "name": "research-agent",
                "description": "执行研究工作",
                "system_prompt": "你是一名研究员。",
            },
        ],
)

上下文仍然膨胀

问题：尽管使用了子代理，上下文仍然填满。 解决方案：

指示子代理返回简洁结果：

system_prompt = """...

重要：仅返回必要的摘要。
不要包含原始数据、中间搜索结果或详细的工具输出。
你的回复应控制在500字以内。"""

对大数据使用文件系统：

system_prompt = """当你收集大量数据时：
1. 将原始数据保存到 /data/raw_results.txt
2. 处理并分析数据
3. 仅返回分析摘要

这样可以保持上下文整洁。"""

选择了错误的子代理

问题：主代理为任务调用了不合适的子代理。 解决方案：在描述中清晰地区分子代理：

subagents = [
    {
        "name": "quick-researcher",
        "description": "用于简单的、需要1-2次搜索的快速研究问题。当你需要基本事实或定义时使用。",
        "system_prompt": "你是快速研究员子代理。",
    },
    {
        "name": "deep-researcher",
        "description": "用于需要多次搜索、综合和分析的复杂、深入研究。用于生成综合性报告。",
        "system_prompt": "你是深度研究员子代理。",
    },
]

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

Edit this page on GitHub or file an issue.

​为什么要使用子代理？

​配置

​默认子代理

​在没有子代理的情况下运行

​自定义子代理

​SubAgent（基于字典）

​CompiledSubAgent

​使用 SubAgent

​使用 CompiledSubAgent

​动态子代理

​启用动态子代理

​触发动态编排

​流式传输子代理进度

​LangSmith 追踪

​在 LangSmith 中按子代理过滤

​在 LangSmith UI 中过滤

​使用 SDK 以编程方式过滤

​结构化输出

​通用子代理

​覆盖通用子代理

​何时使用它

示例

​技能继承

​最佳实践

​编写清晰的描述

​保持系统提示详细

​最小化工具集

​✅ 正面示例：聚焦的工具集

​按任务选择模型

​返回简洁的结果

​常见模式

​多个专业化子代理

​上下文管理

​每个子代理的上下文

​识别哪个子代理调用了工具

​故障排除

​子代理未被调用

​上下文仍然膨胀

​选择了错误的子代理

为什么要使用子代理？

配置

默认子代理

在没有子代理的情况下运行

自定义子代理

SubAgent（基于字典）

CompiledSubAgent

使用 SubAgent

使用 CompiledSubAgent

动态子代理

启用动态子代理

触发动态编排

流式传输子代理进度

LangSmith 追踪

在 LangSmith 中按子代理过滤

在 LangSmith UI 中过滤

使用 SDK 以编程方式过滤

结构化输出

通用子代理

覆盖通用子代理

何时使用它

技能继承

最佳实践

编写清晰的描述

保持系统提示详细

最小化工具集

✅ 正面示例：聚焦的工具集

按任务选择模型

返回简洁的结果

常见模式

多个专业化子代理

上下文管理

每个子代理的上下文

识别哪个子代理调用了工具

故障排除

子代理未被调用

上下文仍然膨胀

选择了错误的子代理