Deep Agents、LangChain 与 LangGraph：三层 Agent 技术栈对比

作者：袖梨 2026-09-17

构建 AI Agent 时，开发者常会同时遇到 Deep Agents、LangChain 和 LangGraph，却不容易判断它们分别解决什么问题。三者实际处于技术栈的不同层级，在开箱即用能力、抽象程度和流程控制上各有侧重，理解这些差异是合理选型与组合使用的前提。

这篇文章发布于 2026 年 8 月 6 日，作者是 Sydney Runkle，主要解释 Deep Agents、LangChain 和 LangGraph 在整个 Agent 技术栈中的定位、区别，以及实际开发时应该如何选择。(LangChain)

Deep Agents、LangChain 和 LangGraph 到底有什么区别？

LangChain 提供的 Deep Agents、LangChain 和 LangGraph，分别代表了构建 Agent（智能体）的不同方式。

本文将介绍这三个开源框架之间的核心区别，以及在什么情况下应该选择哪一个。(LangChain)

Deep Agents、LangChain 和 LangGraph 是我们开源 Agent 技术栈（agent stack）的三个层次。

它们建立在同一个理念之上：

开发者应该能够掌控 Agent 的每一个部分——包括选择什么模型、模型看到什么上下文，以及运行 Agent 的 Harness（运行与控制框架）。

三个层次承担不同的角色，也提供不同程度的控制能力：

  • LangGraph：Agent Runtime（智能体运行时）
  • LangChain：Agent Framework（智能体框架）
  • Deep Agents：Agent Harness（智能体 Harness / 运行控制层）

Runtime 提供最多的控制权和最少的抽象；

Harness 则相反——提供更多开箱即用的能力，但牺牲一部分底层控制权。

更重要的是：

这三个层次并不是互相排斥的。它们完全可以组合使用，你可以在不同层次之间自由切换，而不必只能选择其中一个。 (LangChain)

每一层分别提供什么？

Deep Agents：开箱即用的 Agent Harness

Deep Agents 是一个开箱即用的 Agent Harness。

Agent Harness 的主要职责，是通过 Context Engineering（上下文工程） ，在正确的时间，把正确的上下文提供给模型。

Deep Agents 已经内置了一系列关于 Context Management（上下文管理）的最佳实践，包括：

  • Filesystem（文件系统）
    用来读写上下文信息。当你不希望所有信息都直接塞进 LLM 的 Context Window（上下文窗口）时，可以把它们放到文件系统中。
  • Subagents（子 Agent）
    用于执行专业化任务，同时避免把主 Agent 的 Context Window 撑得过大。
  • Skills（技能）
    允许你提供 Instructions（指令）和 Scripts（脚本），Agent 可以在需要的时候按需加载。
  • Memory（记忆）
    让 Agent 能够跨不同运行过程学习和持续改进。(LangChain)

除此之外，Deep Agents 默认还包含很多其他组件。

这些都是经过明确设计的、具有一定 Opinionated（有明确设计取向） 的 Context Management 最佳实践。

LangChain 团队会持续审视和更新这些实践。

所以，使用 Deep Agents 的一个好处是：

你可以把寻找和吸收 Agent 领域最新最佳实践这件事交给我们。

如何开始使用 Deep Agents？

使用 create_deep_agent 就可以非常简单地创建一个 Agent：

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="anthropic:claude-sonnet-5",
    tools=[web_search],
    system_prompt="you are a research agent...",
    # skills path with citation-format, source-eval
    skills=["./skills/"],
)

你只需要指定：

  • Model（模型）
  • Tools（工具）
  • System Prompt（系统提示词）
  • Skills（技能）

就可以快速构建一个具备大量能力的 Agent。(LangChain)

LangChain：Agent Framework

LangChain 是 Agent Framework（智能体框架） 。

它主要负责：

Abstraction + Integrations（抽象层 + 集成层）

与 Deep Agents 不同，LangChain 提供的是一个非常精简的 Agent Harness。

Deep Agents 内置了大量 Context Management 最佳实践，而 LangChain 的 Agent Abstraction（Agent 抽象）则非常：

Minimal（精简）且 Un-opinionated（不预设具体设计方式）。

它的核心 Agent 抽象其实非常简单：

一个 LLM，不断运行一个循环，并在循环中调用 Tools。

也就是：

LLM → Tool → Result → LLM → Tool → Result → ……

这个 Loop（循环）非常简单，但也非常强大。(LangChain)

为什么要修改 Agent Loop？

有时候，你可能希望修改这个 Agent Loop。

通常，这是为了加入一些更加 Deterministic（确定性） 的步骤。

例如：

  • 当 Context 快要达到上限时，自动进行 Summarization（摘要压缩）；
  • 在 Agent 结束之前运行一个 Verifier（验证器）；
  • 添加 Approval Step（审批步骤）；
  • 加入其他固定的业务逻辑。

LangChain Agent 最强大的能力之一，就是：

允许你通过 Middleware（中间件）修改这个 Loop。

LangChain Middleware 提供了一系列 Hooks（钩子） ，可以从不同角度修改 Agent Loop 的行为。(LangChain)

一个很有意思的事实

Deep Agents 实际上就是 LangChain Core Agent + 大量 Middleware！

也就是说，Deep Agents 并不是完全独立于 LangChain 的另一套 Agent 架构。

它是在 LangChain Agent 核心循环之上，通过 Middleware 等机制加入了：

  • Context Management
  • Filesystem
  • Subagents
  • Skills
  • Memory
  • Summarization
  • 等大量能力。

这也是理解三者关系的一个关键。(LangChain)

LangChain Agent 怎么用？

你可以通过简单的 create_agent 抽象来创建 LangChain Agent：

from langchain.agents import create_agent

agent = create_agent(
    model="anthropic:claude-sonnet-5",
    tools=[send_email],
    prompt="you are my email assistant...",
    middleware=[...]
)

这里你可以自行决定：

  • 使用什么模型；
  • 使用什么工具；
  • Prompt 怎么写；
  • Middleware 怎么配置。

因此，相比 Deep Agents，你可以获得更细粒度的控制。(LangChain)

LangGraph：Agent Runtime

LangGraph 是 Agent Runtime（智能体运行时） 。

它是一个基于 Graph（图）的框架，用于构建自定义 Agent Workflow（智能体工作流）。

同时，它背后拥有一个持久化执行引擎（durable execution engine），内置支持：

  • Human-in-the-loop（人在回路中）
  • Fault Tolerance（容错）
  • Observability（可观测性）

并且可以对每一步执行进行观察和控制。(LangChain)

把 Agent 看作 Graph 的一个好处是：

你可以在 Graph 中显式编码更多 Determinism（确定性），并更加精确地控制每一步发生什么。

例如：

 Step A
   ↓
 Step B
   ↓
  判断
 ↙  ↘
C      D

这里每个节点（Node）和边（Edge）都可以代表明确的逻辑。

因此，与完全由模型决定下一步做什么相比，Graph 能够让开发者获得更强的流程控制能力。

事实上：

LangGraph 正是 LangChain 和 Deep Agents 底层 Agent 抽象的运行基础。 (LangChain)

三者应该怎么选择？

一个简单的经验法则

先从 Deep Agents 开始。

Deep Agents 是一个功能非常强大的 Agent Harness，已经包含大量开箱即用的能力。

只有当你需要：

  • 建模复杂 Workflow；
  • 更细粒度地控制 Agent；
  • 完全控制每一步执行逻辑；

时，才进一步考虑 LangChain 和 LangGraph。(LangChain)

Deep Agents：什么时候使用？

当你希望：

开箱即用地获得一个能力比较完整的 Agent

时，就应该考虑 Deep Agents。

对于大多数开发者而言，这应该是一个很好的起点。

只有当你需要对 Harness 本身进行更深入的控制时，才应该进一步向下探索。

举个例子：GTM Agent

假设你正在构建一个 GTM Agent（Go-To-Market 智能体，市场/销售增长智能体） 。

它可能需要：

每个销售代表独立的 Memory

例如：

  • Email Style Preferences（邮件写作风格偏好）
  • Relationship Understanding（客户关系理解）

Skills

用于处理周期性的工作流，例如：

  • QBR Preparation（季度业务回顾准备）
  • 客户研究

Subagents

用于深入研究某个客户：

  • Call Transcripts（通话记录）
  • News（新闻）
  • CRM History（CRM 历史记录）

等信息。

这并不是一个简单的 Demo。

LangChain 团队自己就使用 deepagents 构建了 GTM Agent。

目前这个 Agent：

  • 每周接近 10,000 次请求
  • 超过 150 名活跃用户
  • 26% 的流量由用户主动发起
  • 剩余 74% 来自 Ambient Agent Work（后台/环境式 Agent 工作）

他们使用 LangSmith Deployments 进行部署，因此既能够处理突发流量，也能够支持定时或事件触发的后台 Agent 运行。(LangChain)

LangChain：什么时候使用？

当你需要：

基础构建模块（building blocks）

或者计划：

在 LangChain 之上自己组装一个定制化 Harness

时，就应该选择 LangChain。

LangChain 的 Integrations（集成）和 Abstractions（抽象）可以在多个层次发挥作用：

  • 自定义 LangGraph；
  • create_agent；
  • create_deep_agent。

如果你希望对：

每一步到底有哪些 Tools 和 Context 能够进入模型

拥有非常细粒度的控制，那么 LangChain 也非常适合。

特别是对于：

Ultra Latency-Sensitive Applications（对延迟极度敏感的应用）

这种精细控制可能非常重要。(LangChain)

举个例子：RAG 文档问答机器人

假设你正在构建一个：

RAG Docs Q&A Bot（RAG 文档问答机器人） 。

用户提出问题之后：

  1. Agent 搜索 Vector Store（向量数据库）；
  2. 找到相关页面；
  3. Agent Loop 判断是否已经得到满意答案；
  4. 如果没有，就继续执行；
  5. 直到完成 Query（查询）。

这种 Agent 通常并不需要：

  • Subagents；
  • Filesystem；
  • 复杂的 Context Management。

你只需要：

  • 把任意 Vector Store 接入成 Tool；
  • 选择你想使用的 Model；
  • 用 create_agent 提供核心 Agent Loop。

这种情况下，LangChain 就非常合适。(LangChain)

LangGraph：什么时候使用？

当你的 Agent：

不适合标准 Agent Loop

或者：

需要在同一个 Workflow 中混合 Deterministic Steps（确定性步骤）和 Agentic Steps（智能体步骤）

时，就应该考虑 LangGraph。(LangChain)

举个例子：租房申请处理流程

假设你正在构建一个 Rental Application Processing Pipeline（租房申请处理流程）。

它包含几个步骤：

第一步

从每份申请中提取：

  • 收入；
  • 信用记录；
  • 租房历史。

第二步

根据房东设定的标准进行评分。

第三步

根据结果：

  • 明确符合条件 → 自动批准；
  • 明确不符合条件 → 自动拒绝；
  • 边界情况 → 交给人工处理。

这里最重要的一点是：

只有第一步需要 LLM。

剩下的步骤都是固定代码。

因此，这是一个相对 Deterministic（确定性） 的 Pipeline（流程）。

LLM 在这里负责从文档中提取信息，但不会获得可以自主采取行动的 Tools。(LangChain)

这就是 LangGraph 非常适合的场景。

如果你已经在使用 LangGraph 呢？

如果你的 LangGraph Workflow 的价值主要来自：

  • Graph 的结构；
  • Deterministic Steps；
  • 对执行路径的精确控制；

那么：

继续使用 LangGraph。

但如果你的 LangGraph Workflow 已经变得非常 Agentic（智能体化） ：

那么你可能会从迁移到 Deep Agents 中获益。(LangChain)

三者可以一起使用

这是理解整个架构时非常重要的一点：

你并不需要在三者之间做一个“非此即彼”的选择。

三个框架都是 Composable（可组合的） 。

例如，你可以：

LangGraph 中使用 Deep Agents

把：

create_agent

或者：

create_deep_agent

直接放进一个更大的 LangGraph Workflow。

反过来也可以：

Deep Agents 中使用 LangGraph

把一个自定义 LangGraph Workflow：

作为 Subagent（子 Agent）

放进 create_agent 或 create_deep_agent 中。(LangChain)

无论你最终使用哪个 Package（软件包）：

都可以使用：

LangSmith Deployments

进行部署，并使用：

LangSmith Observability

进行可观测性分析。(LangChain)

Determinism 与 Agency 之间的平衡

Agent 越自主（Autonomous），通常意味着：

潜在能力越强，但可靠性也可能越低。

因此：

Determinism（确定性）

更适合：

  • 敏感业务；
  • 预先定义好的 Workflow；
  • 重复性很强的任务；
  • 根本不需要 Agent 自主决策的任务。

而：

Agency（自主性）

越高：

  • Agent 可以做更多动态决策；
  • 能够处理更多未知情况；
  • 具有更高的创造性；
  • 可以完成更复杂的任务。

但与此同时：

可预测性和可靠性可能下降。 (LangChain)

三个框架分别处于什么位置？

可以把它们理解成这样：

LangGraph ←———— LangChain ————→ Deep Agents

从：

Determinism（确定性）

逐渐走向：

Agency（自主性）

LangGraph：最大化 Determinism

LangGraph 可以让你直接把：

Domain Knowledge（领域知识）

编码进 Graph Topology（图的拓扑结构）中。

而不是把这些判断交给模型。

也就是说：

你决定 Agent 应该怎么走。

LangChain：位于中间

LangChain 的核心 Agent Loop 本身具有一定的：

Non-deterministic（非确定性）

模型会在每一步决定：

下一步应该做什么。

但你仍然可以通过 Middleware 添加确定性的步骤。(LangChain)

Deep Agents：最大化 Agency

Deep Agents 提供最大的自主性。

它允许 Agent：

  • 运行更长时间；
  • 大规模 Fan-out（任务扇出/并行扩展）；
  • 使用 Subagents；
  • 自动进行 Summarization（摘要压缩）；
  • 管理更复杂的 Context。

因此：

Deep Agents 更倾向于让 Agent 自己决定怎么完成任务。 (LangChain)

Middleware：两者之间的重要桥梁

很多 Agent 都使用 Core Agent Loop。

但是即便如此，它们仍然可能需要几个 Deterministic Steps。

例如：

  • Approval Step（审批步骤）
  • Compliance Check（合规检查）
  • Business Rule（业务规则）

这些事情：

不应该完全交给模型决定。

Middleware 就解决了这个问题。

它允许你在 Deep Agents 和 LangChain 的 Core Loop 周围：

  • 注入确定性步骤；
  • 加入 Human-in-the-loop；
  • 加入各种 Hooks；
  • 控制 Agent 行为。(LangChain)

如果 Middleware 提供的 Hooks 仍然无法满足你的需求：

LangGraph 就是你的 Escape Hatch（逃生舱/更底层的控制出口）。

你可以在 LangGraph 中构建一个完全自定义的 Graph。

然后直接把你的 Workflow Logic（工作流逻辑）编码进 Graph 的结构里。

这样，你就拥有几乎完全的执行控制权。(LangChain)

为什么要设计成三个层次？

这三个层次并不是一开始就同时存在的。

它们实际上代表了 LangChain 技术栈随着 Agent 发展逐渐演进的过程。

2022：LangChain

LangChain 于 2022 年 10 月发布。

最初的目标是：

让开发者能够尽快构建一个 LLM Application（LLM 应用）。

当时的重点是：

快速使用 LLM。

2024：LangGraph

随着 Agent 越来越复杂，开发者发现：

Chain 提供的控制能力已经不够了。

因此，LangChain 团队在 2024 年 1 月推出了 LangGraph。

它提供了一个：

Graph-Based Runtime（基于图的运行时）

并将：

  • Durable Execution（持久化执行）
  • Streaming（流式处理）
  • Human-in-the-loop

作为一等公民（First-Class Primitives）提供。(LangChain)

2025：Deep Agents

随着模型能力不断提高：

Core Agent Loop

逐渐变得足够强大，可以标准化。

一个模型：

  1. 进行 Planning；
  2. 调用 Tool；
  3. 获得结果；
  4. 根据结果继续行动；

已经足以构成一个通用 Agent 的基础。

于是：

create_agent

成为 LangChain 提供的 Minimal Harness（最小化 Harness）。

而它本身又建立在 LangGraph 之上。

原因是：

生产级 Agent 需要 Human-in-the-loop、Observability、Fault Tolerance 等底层能力。

随后，在 2025 年 7 月，LangChain 又进一步推出了 Deep Agents。

它建立在相同的 Core Loop 之上，但默认加入了：

  • Context Management
  • Subagents
  • 等能力。

受到 Claude Code 和 Manus 的启发，LangChain 团队认为开发者也希望拥有：

同样强大的、可以应用于自己业务场景的 Agent。

于是，他们将 deepagents 打造成了一个：

General-Purpose Agent Harness（通用型 Agent Harness）。 (LangChain)

TLDR：到底应该选哪个？

如果你正在：

构建一个新的 Agent，或者重新设计一个已有 Agent

那么：

首先选择 Deep Agents

使用：

create_deep_agent

这是 LangChain 团队目前内部构建 Agent 时主要使用的方式，包括：

  • GTM Agent
  • Coding Agent
  • Docs Writing Agent
  • 等等。(LangChain)

如果你希望更精细地控制 Agent Loop

选择：

create_agent

也就是：

LangChain

它提供：

  • 更少的内置 Context Management；
  • 更少的预设；
  • 更细粒度的 Agent Loop 控制。

如果你需要更强的控制能力和 Determinism

选择：

LangGraph

尤其是当你需要：

  • 自定义 Workflow；
  • 混合 Workflow + Agent；
  • 精确控制每一步；
  • 强确定性；
  • 复杂的条件分支；
  • Human-in-the-loop；

LangGraph 会更加合适。(LangChain)

最后用一张图理解三者

可以把这三个框架理解成一个逐层向下的技术栈：

                   更高层 / 更强的开箱即用能力
                              ↑
                              │
                    ┌─────────────────┐
                    │   Deep Agents   │
                    │  Agent Harness  │
                    │                 │
                    │ Context         │
                    │ Subagents       │
                    │ Skills          │
                    │ Memory          │
                    │ Filesystem      │
                    └────────┬────────┘
                             │
                    ┌────────▼────────┐
                    │    LangChain    │
                    │ Agent Framework │
                    │                 │
                    │ Agent Loop      │
                    │ Tools           │
                    │ Middleware      │
                    │ Integrations    │ （集成）
                    └────────┬────────┘
                             │
                    ┌────────▼────────┐
                    │    LangGraph    │
                    │  Agent Runtime  │
                    │                 │
                    │ Graph           │
                    │ Durable Runtime │ （持久化运行时）
                    │ HITL            │
                    │ Fault Tolerance │ （容错）
                    └─────────────────┘
                              │
                              ↓
                    更底层 / 更强的控制能力

这个关系其实就是整篇文章最核心的内容：

Deep Agents 是 Harness，LangChain 是 Framework，LangGraph 是 Runtime。

三者不是竞争关系，而是逐层构建、彼此组合的关系。(LangChain)

一句话理解三者

如果只记住三个词：

Deep Agents = 开箱即用

LangChain = 灵活组装

LangGraph = 完全掌控

或者更准确一点：

Deep Agents 帮你把 Agent 做好；LangChain 给你 Agent 的核心积木；LangGraph 则让你掌控整个 Agent Workflow 的执行方式。

而且，这三层并非互斥——你可以在 LangGraph 中运行 Deep Agents，也可以把 LangGraph Workflow 作为 Deep Agents 的 Subagent。

这也是这篇文章最重要的架构思想。

相关文章

精彩推荐