Deep Agents是LangChain团队在2025年正式发布的一个开源Agent框架，专门用于构建能够处理生产级、长时程、多步骤任务的深度Agent。与传统的浅层Agent（仅依赖 LLM + 简单工具调用循环）不同，Deep Agents 旨在模拟像Claude Code或Deep Research那样的复杂执行能力。作为一个Agent开发框架，Deep Agents内置了任务规划、文件系统、Sub-Agent生成和长期记忆等功能。我们可以将Deep Agents用于任何任务，包括复杂的多步骤任务。在介绍Deep Agents之前，我们先来简单概括一下LangChain、LangGraph和Deep Agents三者之间的关系。

• LangChain：是一个Agent开发框架，提供了构建Agent的核心模块，如工具调用循环、提示管理、记忆管理等。
• LangGraph：是一个运行时系统，提供了持久执行、流式传输、人机交互等功能。
• Deep Agents：是一个基于LangChain构建的Agent开发框架，它使用LangGraph来实现持久执行、流式传输、人机交互等功能。

也许说了这些你还是觉得困惑，那我说得更简单一点：它们的最终使命都是利用构建的Agent来完成我们给它的任务，但是它们创建Agent的方式不同。

1. LangGraph：将StateGraph编程成Agent

它利用一个StateGraph对象作为Builder，通过添加节点和边根据推理任务构建具有对应结构的状态图。Agent正是StateGraph编译后的结果，它本质上是一个Pregel对象，一个由节点和通道组成的Actor模型。StateGraph的节点转换成Pregel的节点，状态成员转换成Pregel的通道，由边决定的执行流程转换针对通道的订阅规则。原则上任意复杂度的状态图都可以通过为StateGraph添加相应的节点和边构建出来。比如我们利用如下的程序构建了一个包含四个节点（foo、bar、baz和qux）的状态图，并按照流转规则添加了相应的边，最终将其编译成一个Agent。

from typing import TypedDict
from langgraph.graph import StateGraph
from PIL import Image
import io

class State(TypedDict):
    pass

async def foo(state:State):
    pass
async def bar(state:State):
    pass
async def baz(state:State):
    pass
async def qux(state:State):
    pass

agent = (StateGraph(State)
    .add_node("foo",foo)
    .add_node("bar",bar)
    .add_node("baz",baz)
    .add_node("qux",qux)
    .set_entry_point("foo")
    .set_finish_point("qux")
    .add_edge("foo","bar")
    .add_edge("foo","baz")
    .add_edge(["bar","baz"],"qux")
    .compile())

Image.open(io.BytesIO(agent.get_graph().draw_mermaid_png())).show()

我们调用Agent对象的get_graph方法可以得到一个Graph对象，调用它的draw_mermaid_png方法可以得到一个PNG格式的状态图（字节数组），最终利用PIL库将其展示出来。

2. LangChain：利用create_agent函数创建Agent

我们将LangChain和LangGraph和Deep Agents放在一起比较，会将关注点落在用来创建Agent的create_agent工厂函数上。create_agent函数根据指定的模型和工具集创建的Agent，依然是采用上面这道机制创建的。默认状态类型为AgentState将messages作为核心成员，承载了模型、用户和工具三者之间的对话历史。create_agent函数依然会先创建作为Builder的StateGraph，并为其添加两个节点，一个用于封装模型（节点默认名称为model），另一个承载所有的工具(节点默认名称为tools)。

模型节点与工具节点之间具有一条动态条件边,当LLM返回的AIMessage包含工具调用时，被激活的这条边会路由到tools节点完成工具调用，反之则意味着AIMessage携带的就是最终的结果，整个推理过程就此结束。工具节点与模型节点有一条静态边，所以工具执行后会再次回到模型节点，后者在新的状态下完成下一步推理。

LangChain利用create_agent工厂函数创建Agent，一个最简单的Agent只需要指定模型即可，但一般情况我们都需要注册相应的工具。下面的代码利用create_agent函数创建了一个由ChatOpenAI模型和两个注册工具组成的Agent：

from langchain.agents import create_agent
from langchain.tools import tool
from langchain_openai import ChatOpenAI
from PIL import Image
from dotenv import load_dotenv
import io

load_dotenv()

@tool
async def foo():
    """test tool foo"""

@tool
async def bar():
    """test tool bar"""

agent = create_agent(
    model= ChatOpenAI(name= "gpt-5.2-chat"),
    tools=[foo,bar]
)

Image.open(io.BytesIO(agent.get_graph().draw_mermaid_png())).show()

当这个Agent被转换成图后具有如下的结构。这是一个包含两个节点的状态图，一个是用于决策和推理的model节点，作为决策执行者的工具全部被封装到tools节点中。

这种AgentState + 双节点的结构虽然简单，但却能满足常规的推理任务。对于更复杂的推理任务，一方面我们可以扩展AgentState，提供更多的状态成员来承载更多的上下文信息；另一方面我们也可以通过注册AgentMiddleware来添加更多的节点来完善工作流。具体来说，注册的AgentMiddleware提供了如下的功能：

• 添加状态字段：如果AgentMiddleware涉及到针对状态更新，对应的状态字段会定义在state_schema字段返回的状态类型中。此状态状态类型通常是AgentState的子类，定义其中的字段最终会转换成通道；
• 用于注册工具：当Middleware被注册到创建的Agent上时，存储在其tools字段中的工具会自动注册到Agent上。这相当于提供了一种模块化的工具开发和注册的方式；
• 添加节点：当Middleware重写了before_agent/abefore_agent、before_model/abefore_model、after_model/aafter_model、after_agent/aafter_agent方法，都会在状态图中相应的位置添加一个节点。Middleware相当于利用此方式完善了Agent的工作流；
• 包装模型和工具调用：Middleware利用重写的wrap_model_call/awrap_model_call、wrap_tool_call/awrap_tool_call方法对模型和工具的调用进行包装，将AOP引入到模型和工具的调用中，使得在调用前后添加一些额外的操作变得非常简单。比如很多Middleware都具有各自的系统提示词，它们基本上都是利用重写的wrap_model_call/awrap_model_call方法的方式实现针对系统提示词的注入；

class AgentMiddleware(Generic[StateT, ContextT]):

    def before_agent(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None:
        pass
    async def abefore_agent(
        self, state: StateT, runtime: Runtime[ContextT]
    ) -> dict[str, Any] | None:
       pass

    def before_model(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None:
        pass
    async def abefore_model(
        self, state: StateT, runtime: Runtime[ContextT]
    ) -> dict[str, Any] | None:
        pass

    def after_model(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None:
        pass
    async def aafter_model(
        self, state: StateT, runtime: Runtime[ContextT]
    ) -> dict[str, Any] | None:
        pass    

    def after_agent(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None:
        pass
    async def aafter_agent(
        self, state: StateT, runtime: Runtime[ContextT]
    ) -> dict[str, Any] | None:
        pass

    def wrap_model_call(
        self,
        request: ModelRequest,
        handler: Callable[[ModelRequest], ModelResponse],
    ) -> ModelCallResult
    async def awrap_model_call(
        self,
        request: ModelRequest,
        handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
    ) -> ModelCallResult

    def wrap_tool_call(
        self,
        request: ToolCallRequest,
        handler: Callable[[ToolCallRequest], ToolMessage | Command[Any]],
    ) -> ToolMessage | Command[Any]
    async def awrap_tool_call(
        self,
        request: ToolCallRequest,
        handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command[Any]]],
    ) -> ToolMessage | Command[Any]

在下面的程序中，我们定义了一个FoobarMiddleware，并将其注册到Agent上。虽然它没有添加任何新的功能，但它会在Agent如下所示的状态图中添加四个新的节点，分别是before_agent、before_model、after_model和after_agent节点。

from langchain.agents import create_agent
from dotenv import load_dotenv
from langchain.agents.middleware.types import AgentState
from langchain.tools import tool
from langchain_openai import ChatOpenAI
from PIL import Image
from langchain.agents.middleware import AgentMiddleware
from typing import Any
from langgraph.runtime import Runtime
import io

load_dotenv()

class FoobarMiddleware(AgentMiddleware):
    def before_agent(self, state: AgentState[Any], runtime: Runtime[None]) -> dict[str, Any] | None:
        return super().before_agent(state, runtime) 
    def before_model(self, state: AgentState[Any], runtime: Runtime[None]) -> dict[str, Any] | None:
        return super().before_model(state, runtime)
    def after_agent(self, state: AgentState[Any], runtime: Runtime[None]) -> dict[str, Any] | None:
        return super().after_agent(state, runtime)
    def after_model(self, state: AgentState[Any], runtime: Runtime[None]) -> dict[str, Any] | None:
        return super().after_model(state, runtime) 

@tool
async def foo():
    """test tool foo"""

@tool
async def bar():
    """test tool bar"""

agent = create_agent(
    model= ChatOpenAI(name= "gpt-5.2-chat"),
    tools=[foo,bar],
    middleware=[FoobarMiddleware()]
)

Image.open(io.BytesIO(agent.get_graph().draw_mermaid_png())).show()

状态图结构如下所示：

3. Deep Agents：利用create_deep_agent函数创建Agent

Deep Agents拥有属于自己的Agent工厂函数create_deep_agent，它其实最终也会调用LangChain的create_agent函数来创建Agent，它仅仅在调用此方法时利用注册的Middleware为Agent添加了更多的功能，如任务规划、用于上下文管理的文件系统、Sub-Agent生成和长期记忆等功能。

从LangGraph和LangChain创建Agent的方式可以看出，它们相当于是自助餐和套餐的差别。LangGraph赋予完全的自由度，我们可以根据具体的推理任务对状态图进行DIY。虽然灵活自由，实则对用户提出了更高的要求。相比之下，LangChain利用create_agent函数创建的Agent具有固定结构，却能满足大部分的推理任务。它相当于提供了一款符合大众口味的基础套餐。在点餐的时候，我们可以选择这个基础套餐，也可以在此基础上添加、替换和剔除一些配菜来满足个性化的需求，这就是Middleware赋予的定制能力。

LangChain和Deep Agents的关系就像是基础套餐和升级套餐的关系。LangChain利用create_agent函数构建的Agent只具有基础的功能，任务定制的功能都需要通过注册Middleware来提供。企业级Agent来往往具有一些公共的功能需求，如任务规划、用于上下文管理的文件系统、Sub-Agent生成和长期记忆等功能。如果任何一个功能都要求用户通过注册Middleware来实现的话，无疑也会增加用户的使用门槛。于是Deep Agents对套餐进行了升级，在通过create_deep_agent函数创建Agent的时候，根据提供的配置自动注册了对应的Middleware。

为了探究create_deep_agent函数为创建的Agent注册了怎样的Middleware，我们编写了如下的演示程序：

from deepagents import create_deep_agent
from deepagents.middleware import SubAgent,AsyncSubAgent
from langchain.tools import tool
from langchain_openai import ChatOpenAI
from PIL import Image
import io
from dotenv import load_dotenv

load_dotenv()

@tool
async def foo():
    """test tool foo"""

@tool
async def bar():
    """test tool bar"""

inline_subagent:SubAgent = {
    "name": "inline-sub-agent",
    "description": "A test inline sub-agent",
    "system_prompt": "System prompt for inline sub-agent",
    "model": ChatOpenAI(name= "gpt-5.2-chat"),  
}

async_subagent:AsyncSubAgent = {
    "name": "async-sub-agent",
    "description": "A test async sub-agent",
    "graph_id": "graph-001",
}

agent = create_deep_agent(
    model= ChatOpenAI(name= "gpt-5.2-chat"),
    memory=["/memories/AGENTS.md"],
    skills=["/skills/"],
    tools=[foo,bar],
    interrupt_on={"foo":True},
    subagents=[inline_subagent,async_subagent],
)

Image.open(io.BytesIO(agent.get_graph().draw_mermaid_png())).show()

在上面的程序中，我们通过create_deep_agent函数创建了一个Agent，并为它指定了模型、记忆、Skill、工具、中断规则和Sub-Agent（同步和异步）等配置。最终我们得到的状态图如下所示：

在上面这张图中，我们看到了五个Middleware。但是Deep Agents涉及的Middleware远不止这些，因为只有重写了before_agent/abefore_agent、before_model/abefore_model、after_model/aafter_model方法的Middleware才会转换成状态图的节点，而且SubAgentMiddleware和AsyncSubAgentMiddleware生成的Sub-Agent也会有自己的Middleware。总的来说，整个Deep Agents就建立在如下这几个Middleware之上，了解了它们你就了解了Deep Agents的全部。

• FileSystemMiddleware: 提供一个抽象的文件系统。让Agent拥有读写本地文件的能力（如read_file和write_file），用于存放中间结果或处理超长内容，防止上下文溢出；
• TodoListMiddleware: 利用提供的系统提示词指示LLM将复杂的任务拆分为子任务列表（Todo-List），并以此为蓝本逐步实施。它同时提供了write_todos工具实时记录每个子任务的完成状态；
• SkillsMiddleware: 允许Agent动态加载预定义的专业能力（Skills），通过注入系统提示词让Agent快速获得特定领域的专业知识;
• HumanInTheLoopMiddleware: 实现了人机交互，在Agent调用关键/敏感工具前（如支付、删除文件）暂停并请求人类批准、修改或拒绝;
• PatchToolCallsMiddleware：用于在模型输出不符合规范或需要动态调整时，对工具调用的参数进行实时补丁或格式修正，提高调用成功率；
• _DeepAgentsSummarizationMiddleware：记忆瘦身器。自动对冗长的对话历史进行摘要压缩。它在信息进入模型前执行，仅保留关键摘要和最新消息，从而节省Token并维持长期对话的连贯性；
• MemoryMiddleware：记忆持久化与注入器。它负责将用户偏好、业务规则或跨会话的关键事实提取出来，并以系统提示词的形式注入到Agent的大脑中；
• SubAgentMiddleware: 分身指挥官。支持Agent生成具有独立上下文的Sub-Agent来分担任务，实现复杂工作的委派与隔离；
• AsyncSubAgentMiddleware: 异步分身。在SubAgent基础上增加了异步执行能力，允许Main-Agent在Sub-Agent处理耗时任务时继续执行其他操作或同时管理多个子任务；