上一篇介绍了 Deep Agents 适合解决什么问题。

本文继续介绍由 Deep Agents 构建的 Agent，内部究竟由哪些部分组成？

它可以调用工具、读写文件、把任务交给子 Agent，还能处理持续增长的上下文等。

我们首先从 create_deep_agent() 出发，沿着 Agent 的创建和运行过程，理清 Model、Tools、Middleware、Backend、Subagent 和 Runtime 之间的关系。

一、整体架构

理解 Deep Agents，首先要分清它与 LangChain、LangGraph 的关系。

Deep Agents 建立在 LangChain Agent 和 LangGraph Runtime 之上。

关于三者之间详细的关系说明，在之前的 LangChain Agent 开发系列的第一篇文章中有详细的介绍。

Deep Agents 由 create_deep_agent() 函数创建 Agent，该函数最终会调用 LangChain 的 create_agent() 创建 Agent；Agent 运行过程中需要的 State、Checkpoint、Streaming、Interrupt 等能力，则由 LangGraph Runtime 提供。

再结合 LangSmith，这四个组件的职责如下表：

组件/框架主要职责
LangChainModel、Tool、Middleware、Agent Loop
LangGraphState、Checkpoint、Streaming、Interrupt、Durable Execution
Deep AgentsFilesystem、Subagent、Context Management、Memory 等 Harness 能力
LangSmithTrace、Evaluation、运行观测与部署

一个普通 LangChain Agent 已经具备最基本的运行循环：

代码片段Text
用户请求
   ↓
Model
   ↓
Tool
   ↓
Model
   ↓
最终结果

模型根据当前上下文决定下一步。

如果需要外部能力，就调用 Tool；Tool 返回结果后，模型继续判断，是继续行动还是结束任务。

通过上一篇文章，我们已了解，Deep Agents 并没有改变这条核心循环。

它增加的是循环外围的一组工程能力：

代码片段Text
Filesystem
Subagent
Context Management
Backend
Memory
Skills
Human-in-the-loop

这些能力让 Agent 有能力处理长时间、多步骤等类的更为复杂的任务。

从这个角度看，Deep Agents 本质上是一套 Agent Harness。

它不替代 LangChain 和 LangGraph，而是在两者之上组织一套复杂 Agent 常用的运行环境。

二、Agent 的创建

create_deep_agent() 是理解整个架构的入口。

例如：

代码片段Python
agent = create_deep_agent(
    model="openai:gpt-5.5",
    tools=[search],
    system_prompt="You are a research assistant.",
)

这里做的事情不是“运行一次 Agent”，而是创建一个可以反复执行的 Agent。

model 指定模型。

tools 定义 Agent 可以调用的业务工具。

system_prompt 用来设定 Agent 的角色、行为规则和任务边界。

除此之外，create_deep_agent() 还会根据配置加入 Backend、Subagent、Middleware 等组件。

整个过程可以简化成：

代码片段Text
Model
 │
 ├─ Tools
 │
 ├─ System Prompt
 │
 ├─ Backend
 │
 ├─ Subagents
 │
 └─ Middleware
        ↓
 LangChain create_agent()
        ↓
 Runnable Agent Graph

Deep Agents 在这一层完成的是“装配”。

它把模型、工具以及复杂任务需要的各种能力组合起来，然后交给 LangChain 创建最终的 Agent。

另外，需要分清一个重要的区别，Agent 的创建与执行：

代码片段Text
create_deep_agent()
        ↓
创建 Agent

agent.invoke(...)
        ↓
执行任务

前者定义 Agent 是什么样子，后者才真正执行 Agent，处理用户请求。

三、Middleware 层

Deep Agents 的很多扩展能力都通过 Middleware 接入。

Middleware 位于 Agent 的执行过程中，可以影响模型调用、工具调用、上下文处理以及状态变化。

一个 Deep Agent 通常会组合多种 Middleware，例如：

代码片段Text
FilesystemMiddleware
SubAgentMiddleware
SummarizationMiddleware
PatchToolCallsMiddleware
...

Middleware 在架构中的作用如下：

代码片段Text
Model + Tools
     ↑
 Middleware
     ↑
Deep Agents 提供的扩展能力

由此不难看出，Filesystem、Subagent、Context Management 等能力是通过 Middleware 接入现有的 Agent Loop。

因此，本质上，Middleware 是 Deep Agents 扩展 Agent 行为的重要接口。

四、Filesystem 与 Backend

Filesystem 和 Backend 经常一起出现，但两者不是一回事。

Filesystem 面向 Agent。

它提供一套文件操作能力，让 Agent 可以把任务中的资料、代码和中间结果放进工作区。

Backend 面向存储。

它决定这些文件最终保存在哪里。

两层关系可以概括成：

代码片段Text
Agent
  ↓
Filesystem
  ↓
Backend
  ↓
实际存储

例如同一个文件操作：

代码片段Text
write_file("/notes/report.md", ...)

背后既可以保存到当前 Graph State，也可以落到真实文件系统、长期 Store 或隔离 Sandbox。

Deep Agents 提供了多种 Backend：

代码片段Text
StateBackend
StoreBackend
FilesystemBackend
CompositeBackend
Sandbox Backend

它们的具体区别本文不展开，后续文章中会分别介绍。

五、Subagent 层

复杂任务往往不是一条线性运行结构执行到底。

例如一个研究任务，可能同时包含：

代码片段Text
搜索市场资料
分析竞争对手
整理技术方案
检查风险
生成最终报告

这些子任务如果全部由主 Agent 完成，主 Context 会越来越大。

Deep Agents 因此加入了 Subagent。

主 Agent 可以通过 task 等机制，把一部分相对独立的工作交给子 Agent：

代码片段Text
Main Agent
   │
   ├─ 子任务 A → Subagent
   │
   ├─ 子任务 B → Subagent
   │
   └─ 汇总结果

Subagent 拥有独立的执行上下文，可以有自己的 Prompt、Tools，甚至使用不同的 Model。

任务完成后，再把结果返回给主 Agent。

因此，Subagent 不只是任务分工机制，它也影响整个系统的 Context 组织方式。

至于什么时候应该创建 Subagent、主 Agent 与 Subagent 如何通信、怎样避免过度拆分，在后续文章中会详细介绍。

六、Runtime 层

Agent 创建好以后，真正运行任务时，底层由 LangGraph Runtime 推进整个过程。

最常见的执行方式是：

代码片段Python
result = agent.invoke(
    {
        "messages": [
            {
                "role": "user",
                "content": "分析这个项目的风险",
            }
        ]
    }
)

一次任务的执行路径可能很简单：

代码片段Text
User
 ↓
Model
 ↓
Tool
 ↓
Model
 ↓
Answer

也可能复杂得多：

代码片段Text
User
 ↓
Model
 ↓
Tool
 ↓
Filesystem
 ↓
Model
 ↓
Subagent
 ↓
Subagent Result
 ↓
Model
 ↓
Final Answer

但无论过程多复杂，最里面仍然是同一条循环：

代码片段Text
读取当前状态
     ↓
模型决定下一步
     ↓
执行动作
     ↓
结果写回状态
     ↓
继续判断

LangGraph Runtime 负责推动这条执行链。

它维护 State，处理节点执行，并提供 Checkpoint、Streaming、Interrupt、Durable Execution 等底层能力。

Deep Agents 基于这套 Runtime，并加入了 Filesystem、Subagent、Context Management 等 Harness 能力。

七、各组件的关系

到这里，可以把整个 Deep Agents 架构放到一张图里：

代码片段Text
                 Deep Agents
              Agent Harness Layer
                       │
        ┌──────────────┼──────────────┐
        │              │              │
   Filesystem       Subagent       Context
        │              │              │
     Backend         task          Summary
        │              │              │
        └──────────────┼──────────────┘
                       │
                  Middleware
                       │
                       ↓
               LangChain Agent
              Model + Tools + Loop
                       │
                       ↓
               LangGraph Runtime
          State + Checkpoint + Execution

如果从一次具体调用来看，又可以简化成：

代码片段Text
create_deep_agent()
        ↓
装配 Model / Tools / Middleware
        ↓
创建 Agent Graph
        ↓
agent.invoke()
        ↓
LangGraph Runtime 开始执行
        ↓
Model 决定下一步
        ↓
Tool / Filesystem / Subagent
        ↓
结果写回 State
        ↓
继续执行

上述结构与流程基本覆盖了 Deep Agents 内部各组件之间的重要关系。

总结

Deep Agents 建立在 LangChain Agent 和 LangGraph Runtime 之上，本质上是一套面向复杂任务的 Agent Harness。

它保留了 Model、Tool 和 Agent Loop 的基本运行方式，并通过 Middleware 补充 Filesystem、Subagent、Context Management、Memory 等能力。

create_deep_agent() 负责完成这些组件的装配，LangGraph Runtime 则负责状态维护与实际执行。

理解这些关系，是后续学习 Planning、Filesystem、Backend、Subagent 和 Persistence 的基础。