一次性读懂读透 DeerFlow：字节跳动开源的 Super Agent Harness 全景深度解析

一次性读懂读透 DeerFlow：字节跳动开源的 Super Agent Harness 全景深度解析

当所有 AI Agent 框架还在解决"怎么让 AI 多说几句"时，字节跳动的 DeerFlow 已经把问题换成了——怎么让 AI 真正动手干活。

DeerFlow（Deep Exploration and Efficient Research Flow）是字节跳动于 2025 年 5 月开源的 AI 智能体框架，在 2026 年 2 月发布了完全重写的 2.0 版本，上线 24 小时即冲上 GitHub Trending 第一，2.0 发布后短短三个月内狂揽超过 70,000 Stars。它不是又一个"会聊天的 AI Demo"，而是一个生产级的 Super Agent Harness——一个能让 AI 真正执行代码、操控浏览器、生成报告、协调多个子智能体协同工作的运行时底座。

本文将从"为什么需要它"出发，沿着"架构设计→核心能力→实战上手→生产部署→生态对比→未来展望"的路径，带你一次性读懂、读透 DeerFlow。

目录

• 第一部分：为什么需要 DeerFlow——从"聊天"到"干活"的鸿沟
• 第二部分：架构与设计哲学——Super Agent Harness 全景图
• 第三部分：核心能力深度拆解
• 第四部分：快速上手与实战演练
• 第五部分：生产级部署与运维
• 第六部分：生态、对比与未来展望
• 附录

第一部分：为什么需要 DeerFlow——从"聊天"到"干活"的鸿沟

章节导读：在写代码之前，先搞清楚问题是什么。这一部分我们聊 DeerFlow 诞生的行业背景——AI Agent 赛道到底缺什么。

1.1 AI Agent 的"最后一公里"困境

2024 年到 2025 年，AI Agent（AI 智能体）概念火遍整个技术圈。LangChain 让大模型调用工具变得简单，AutoGPT 展示了"自主循环执行"的可能性，CrewAI 让多个 Agent 角色扮演协作看起来触手可及。

然而，当开发者真正试图把 Agent 部署到生产环境去处理复杂任务时，会撞上一堵现实的墙：大多数框架只解决了"让 AI 想"的问题，却没有解决"让 AI 做"的问题。

具体来说，这个鸿沟体现在以下几个层面：

第一，缺乏安全的代码执行环境。 你让 AI 写一个爬虫脚本，它能给你完美的代码。但你让它自己运行这个脚本？对不起，大多数框架没有提供隔离的沙箱环境。让 AI 直接在你的服务器上执行代码，无异于把 root 权限交给一个偶尔会产生幻觉的系统。

第二，缺乏可靠的长任务编排能力。 一个"做市场调研并生成 50 页报告"的任务可能需要 30 分钟，涉及搜索、阅读、分析、编码、可视化等多个步骤。大多数框架的 Agent Loop 设计无法支撑这种"分钟到小时"级别的长程任务，中间一旦出错或上下文溢出，整个任务就会崩溃。

第三，缺乏生产级的约束与可观测性。 Agent 在生产环境中运行时，你需要知道它在做什么、为什么这么做、花了多少 Token、调用了哪些工具。当它"跑偏"时，你需要有机制及时发现并干预。而大多数开源框架在这方面的能力近乎空白——没有日志追踪、没有执行回放、没有中间件拦截。

第四，扩展性不足。 当你想给 Agent 添加一种新能力（比如生成 PPT、发送飞书消息、操控浏览器），大多数框架需要你修改核心代码，而不是简单地"安装一个插件"。

1.2 从 OpenAI Deep Research 到 DeerFlow

2025 年初，OpenAI 发布了 Deep Research 功能——一个能够自动进行多轮搜索、推理和综合分析的"深度研究"Agent。这个功能让全世界看到了 AI Agent 的真正潜力：不是回答一个简单问题，而是像一个研究员一样，花几十分钟甚至更长时间，自主完成一份深度调研报告。

然而 Deep Research 是闭源的，只在 ChatGPT Pro 订阅中可用。社区迫切需要一个开源替代方案。

这正是 DeerFlow 1.0 诞生的背景。2025 年 5 月，字节跳动以 MIT 协议开源了 DeerFlow，其全称 Deep Exploration and Efficient Research Flow 直接点明了它的定位：一个开源的深度研究框架，能够像人类研究员一样进行多轮搜索-推理-综合分析的循环。

1.0 版本的核心能力集中在"深度研究"这一个场景上：自动拆解研究问题，调度研究员 Agent 进行网络搜索，汇总信息并生成结构化报告。这个阶段的 DeerFlow 更像一个"AI 研究助手工具"，而非通用框架。

尽管如此，1.0 在开源社区的反响远超预期。它在短短几个月内获得了数万 Stars，大量用户开始在深度研究之外的场景中尝试使用它——有人用它做竞品分析，有人用它做自动化的数据处理，甚至有人试图让它帮助编写和部署代码。这些"超出设计意图"的使用方式，恰恰暴露了 1.0 架构的局限性：没有安全的代码执行环境、没有灵活的任务编排、没有完善的扩展机制。社区用行动告诉字节跳动：人们需要的不是一个研究工具，而是一个能让 AI 真正"干活"的通用平台。

1.3 2.0：从"深度研究工具"到"超级智能体框架"的质变

2026 年 2 月 28 日，DeerFlow 2.0 发布。这不是一次增量更新，而是一次完全重写——两个版本之间没有共用一行代码。

1.0 的定位是"深度研究助手"，2.0 的定位是Super Agent Harness（超级智能体运行时底座）。社区反馈很直接：用户需要的不是一个研究工具，而是一个能真正让 AI"动手做事"的通用执行平台。

2.0 带来的变化是根本性的：基于 LangGraph 重构的多智能体编排引擎、Docker 沙箱隔离的代码执行环境、基于 Markdown 定义的 Skill 技能系统、MCP（Model Context Protocol）工具协议集成、LangSmith 全链路可观测性、以及一套精心设计的 18 层中间件体系。

用 DeerFlow 团队的话来说：1.0 给 AI 装了一个"大脑"，2.0 给 AI 装了一整台"电脑"。

更具体地说，1.0 到 2.0 的演进体现在以下维度：

这张表清楚地展示了 2.0 的"完全重写"并非虚言——几乎每一个维度都经历了根本性的重构。这种大胆推倒重来的决策，在开源项目中并不常见，它反映了字节跳动团队对"什么才是真正重要的"这个问题的深刻反思：1.0 验证了"AI 深度研究"这个场景的可行性，但也暴露了将 Agent 投入实际工作所面临的工程挑战远比想象中复杂。 与其在 1.0 的架构上修修补补，不如从头构建一个真正面向生产环境的系统。

本节要点：DeerFlow 的诞生源于 AI Agent 从"聊天"到"干活"的现实鸿沟。1.0 是深度研究助手，2.0 是生产级超级智能体运行时，完成了从工具到基础设施的质变。

第二部分：架构与设计哲学——Super Agent Harness 全景图

章节导读：这一部分是理解 DeerFlow 的关键。我们将深入剖析"Harness"这个核心概念，并用架构图拆解整个系统的分层设计。

2.1 什么是 Harness？为什么不是"又一个框架"

DeerFlow 2.0 把自己定义为 Super Agent Harness，而不是"framework"或"library"。这个命名选择不是营销噱头，而是精确反映了它的架构定位。

在传统软件工程中，Harness（测试线束/执行框架）是一种为被测系统提供运行环境、隔离、控制和观测的基础设施。DeerFlow 借用了这个概念：它不是 Agent 本身，而是让 Agent 安全、可控、可观测地运行起来的执行底座。

如果用类比来理解：

• LangChain 是一把瑞士军刀——提供各种工具，让你快速组装 AI 应用。
• LangGraph 是电路设计图——让你用状态图定义 Agent 的执行流程。
• CrewAI 是剧本——定义角色和协作流程，让多个 Agent 按剧本演戏。
• DeerFlow 是操作系统——提供进程管理、文件系统、安全隔离、监控告警等一切 Agent 运行所需的基础设施。

DeerFlow 构建在 LangGraph 和 LangChain 之上，但它加入了四个关键维度：沙箱执行环境（Sandbox）、技能约束系统（Skill）、全链路可观测性（Observability）、以及中间件拦截链（Middleware Chain）。这四个维度正是从"框架"到"Harness"的本质区别。

2.2 四层架构全景图

DeerFlow 2.0 采用清晰的四层分层架构。每一层职责明确，层间通过标准接口通信：

#mermaid-svg-ATqdUTmBgUFG7EkH{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-ATqdUTmBgUFG7EkH .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-ATqdUTmBgUFG7EkH .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-ATqdUTmBgUFG7EkH .error-icon{fill:#552222;}#mermaid-svg-ATqdUTmBgUFG7EkH .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-ATqdUTmBgUFG7EkH .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-ATqdUTmBgUFG7EkH .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-ATqdUTmBgUFG7EkH .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-ATqdUTmBgUFG7EkH .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-ATqdUTmBgUFG7EkH .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-ATqdUTmBgUFG7EkH .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-ATqdUTmBgUFG7EkH .marker{fill:#333333;stroke:#333333;}#mermaid-svg-ATqdUTmBgUFG7EkH .marker.cross{stroke:#333333;}#mermaid-svg-ATqdUTmBgUFG7EkH svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-ATqdUTmBgUFG7EkH p{margin:0;}#mermaid-svg-ATqdUTmBgUFG7EkH .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-ATqdUTmBgUFG7EkH .cluster-label text{fill:#333;}#mermaid-svg-ATqdUTmBgUFG7EkH .cluster-label span{color:#333;}#mermaid-svg-ATqdUTmBgUFG7EkH .cluster-label span p{background-color:transparent;}#mermaid-svg-ATqdUTmBgUFG7EkH .label text,#mermaid-svg-ATqdUTmBgUFG7EkH span{fill:#333;color:#333;}#mermaid-svg-ATqdUTmBgUFG7EkH .node rect,#mermaid-svg-ATqdUTmBgUFG7EkH .node circle,#mermaid-svg-ATqdUTmBgUFG7EkH .node ellipse,#mermaid-svg-ATqdUTmBgUFG7EkH .node polygon,#mermaid-svg-ATqdUTmBgUFG7EkH .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-ATqdUTmBgUFG7EkH .rough-node .label text,#mermaid-svg-ATqdUTmBgUFG7EkH .node .label text,#mermaid-svg-ATqdUTmBgUFG7EkH .image-shape .label,#mermaid-svg-ATqdUTmBgUFG7EkH .icon-shape .label{text-anchor:middle;}#mermaid-svg-ATqdUTmBgUFG7EkH .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-ATqdUTmBgUFG7EkH .rough-node .label,#mermaid-svg-ATqdUTmBgUFG7EkH .node .label,#mermaid-svg-ATqdUTmBgUFG7EkH .image-shape .label,#mermaid-svg-ATqdUTmBgUFG7EkH .icon-shape .label{text-align:center;}#mermaid-svg-ATqdUTmBgUFG7EkH .node.clickable{cursor:pointer;}#mermaid-svg-ATqdUTmBgUFG7EkH .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-ATqdUTmBgUFG7EkH .arrowheadPath{fill:#333333;}#mermaid-svg-ATqdUTmBgUFG7EkH .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-ATqdUTmBgUFG7EkH .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-ATqdUTmBgUFG7EkH .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-ATqdUTmBgUFG7EkH .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-ATqdUTmBgUFG7EkH .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-ATqdUTmBgUFG7EkH .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-ATqdUTmBgUFG7EkH .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-ATqdUTmBgUFG7EkH .cluster text{fill:#333;}#mermaid-svg-ATqdUTmBgUFG7EkH .cluster span{color:#333;}#mermaid-svg-ATqdUTmBgUFG7EkH div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-ATqdUTmBgUFG7EkH .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-ATqdUTmBgUFG7EkH rect.text{fill:none;stroke-width:0;}#mermaid-svg-ATqdUTmBgUFG7EkH .icon-shape,#mermaid-svg-ATqdUTmBgUFG7EkH .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-ATqdUTmBgUFG7EkH .icon-shape p,#mermaid-svg-ATqdUTmBgUFG7EkH .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-ATqdUTmBgUFG7EkH .icon-shape .label rect,#mermaid-svg-ATqdUTmBgUFG7EkH .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-ATqdUTmBgUFG7EkH .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-ATqdUTmBgUFG7EkH .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-ATqdUTmBgUFG7EkH :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

基础设施层 (Infrastructure Layer)

执行层 (Execution Layer)

编排层 (Orchestration Layer)

接入层 (Access Layer)

Next.js Web UI端口 3000

Gateway API端口 8001

IM 通道飞书/钉钉/Slack

LangGraph 状态机

Lead Agent主智能体

18 层中间件链

Research Sub-Agent研究子智能体

Code Sub-Agent编码子智能体

Browser Sub-Agent浏览器子智能体

Custom Sub-Agent自定义子智能体

Sandbox 沙箱Docker/K8s 隔离

MCP 工具协议

Skill 技能系统

Memory 记忆系统

LangSmith 可观测性

接入层（Access Layer） 是用户与系统交互的入口。DeerFlow 提供了一个基于 Next.js 的 Web UI（运行在 3000 端口），同时暴露了一套 RESTful Gateway API（运行在 8001 端口），还预留了 IM 通道集成能力（支持飞书、钉钉、Slack 等）。Nginx 作为反向代理统一接入。

编排层（Orchestration Layer） 是整个系统的大脑。Lead Agent（主智能体）是用户直接对话的对象，它负责任务理解、规划、分解和调度。LangGraph 状态机提供了有状态的图结构编排能力，而 18 层中间件链则在每次 Agent 执行前后进行拦截、增强和控制。

执行层（Execution Layer） 是真正"干活"的地方。Lead Agent 将子任务委派给不同的 Sub-Agent（子智能体）：Research Sub-Agent 负责搜索和信息收集，Code Sub-Agent 负责代码编写和执行，Browser Sub-Agent 负责浏览器操作，你还可以自定义 Sub-Agent 来扩展能力。所有代码执行都发生在 Sandbox 沙箱中，确保安全性。

基础设施层（Infrastructure Layer） 提供横切关注点：MCP 工具协议让 Agent 能够调用外部工具和服务，Skill 技能系统提供模块化的能力定义，Memory 记忆系统提供跨会话的持久化记忆，LangSmith 可观测性提供全链路追踪和监控。

2.3 Gateway-Worker 模式

在部署架构上，DeerFlow 2.0 采用 Gateway-Worker 模式：

Docker Sandbox

Sub-Agent Worker

Lead Agent

LangGraph Server

Gateway API

用户

Docker Sandbox

Sub-Agent Worker

Lead Agent

LangGraph Server

Gateway API

用户

#mermaid-svg-hW2cWyRX9vdcTRfy{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-hW2cWyRX9vdcTRfy .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-hW2cWyRX9vdcTRfy .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-hW2cWyRX9vdcTRfy .error-icon{fill:#552222;}#mermaid-svg-hW2cWyRX9vdcTRfy .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-hW2cWyRX9vdcTRfy .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-hW2cWyRX9vdcTRfy .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-hW2cWyRX9vdcTRfy .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-hW2cWyRX9vdcTRfy .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-hW2cWyRX9vdcTRfy .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-hW2cWyRX9vdcTRfy .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-hW2cWyRX9vdcTRfy .marker{fill:#333333;stroke:#333333;}#mermaid-svg-hW2cWyRX9vdcTRfy .marker.cross{stroke:#333333;}#mermaid-svg-hW2cWyRX9vdcTRfy svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-hW2cWyRX9vdcTRfy p{margin:0;}#mermaid-svg-hW2cWyRX9vdcTRfy .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-hW2cWyRX9vdcTRfy text.actor>tspan{fill:black;stroke:none;}#mermaid-svg-hW2cWyRX9vdcTRfy .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-hW2cWyRX9vdcTRfy .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-svg-hW2cWyRX9vdcTRfy .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-svg-hW2cWyRX9vdcTRfy .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-svg-hW2cWyRX9vdcTRfy #arrowhead path{fill:#333;stroke:#333;}#mermaid-svg-hW2cWyRX9vdcTRfy .sequenceNumber{fill:white;}#mermaid-svg-hW2cWyRX9vdcTRfy #sequencenumber{fill:#333;}#mermaid-svg-hW2cWyRX9vdcTRfy #crosshead path{fill:#333;stroke:#333;}#mermaid-svg-hW2cWyRX9vdcTRfy .messageText{fill:#333;stroke:none;}#mermaid-svg-hW2cWyRX9vdcTRfy .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-hW2cWyRX9vdcTRfy .labelText,#mermaid-svg-hW2cWyRX9vdcTRfy .labelText>tspan{fill:black;stroke:none;}#mermaid-svg-hW2cWyRX9vdcTRfy .loopText,#mermaid-svg-hW2cWyRX9vdcTRfy .loopText>tspan{fill:black;stroke:none;}#mermaid-svg-hW2cWyRX9vdcTRfy .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-hW2cWyRX9vdcTRfy .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-hW2cWyRX9vdcTRfy .noteText,#mermaid-svg-hW2cWyRX9vdcTRfy .noteText>tspan{fill:black;stroke:none;}#mermaid-svg-hW2cWyRX9vdcTRfy .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-svg-hW2cWyRX9vdcTRfy .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-svg-hW2cWyRX9vdcTRfy .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-svg-hW2cWyRX9vdcTRfy .actorPopupMenu{position:absolute;}#mermaid-svg-hW2cWyRX9vdcTRfy .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-hW2cWyRX9vdcTRfy .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-hW2cWyRX9vdcTRfy .actor-man circle,#mermaid-svg-hW2cWyRX9vdcTRfy line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-svg-hW2cWyRX9vdcTRfy :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

发送任务请求

认证 & 限流

创建 Thread & Run

激活 Lead Agent

任务分析 & 规划

委派子任务

在沙箱中执行代码

返回执行结果

汇报子任务结果

汇总 & 生成输出

更新状态

流式返回结果

展示最终输出

Gateway 负责接收用户请求、认证、限流和路由。LangGraph Server 管理状态图的执行，是核心的编排节点。Worker 是执行具体子任务的 Agent 实例，它们运行在独立的进程或容器中。这种分离使得系统具备良好的水平扩展能力：你可以独立扩容 Gateway 层和 Worker 层。

2.4 设计哲学：Harness Engineering

DeerFlow 团队提出了一个值得关注的设计理念：Harness Engineering（线束工程）。

核心思想是：在生产环境中，Agent 的"能力"不是最大的挑战——大模型本身足够聪明。真正的挑战是如何让 Agent 在约束条件下稳定、安全、可观测地运行。

Harness Engineering 关注三个维度：

约束（Constraint）：通过 Skill 定义"该怎么做"，通过 Guardrails 拦截"不该做的事"，通过 Sandbox 限制"能影响的范围"。这三层约束确保 Agent 不会"失控"。

隔离（Isolation）：每次代码执行在独立的 Docker 容器中，每个用户线程的文件系统相互隔离，进程和网络空间相互隔离。即使 Agent 执行了恶意代码，也不会影响宿主系统。

可观测（Observability）：通过 LangSmith 集成，每一次 LLM 调用、每一次工具调用、每一个决策节点都被记录和追踪。你可以像调试代码一样调试 Agent 的行为。

本节要点：DeerFlow 不是"又一个 Agent 框架"，而是一个 Harness——让 Agent 安全、可控、可观测运行的执行底座。四层架构（接入/编排/执行/基础设施）和 Harness Engineering 理念是其核心设计支柱。

2.5 DeerFlow 与 LangGraph 的关系：站在巨人肩上

理解 DeerFlow 的架构，必须理解它与 LangGraph 的关系。LangGraph 是 LangChain 团队开发的有状态图编排引擎，它解决了构建复杂 Agent 工作流的核心难题——如何让 Agent 在多步骤任务中保持状态、支持条件分支和循环、以及实现人机协同（Human-in-the-loop）。

DeerFlow 2.0 选择构建在 LangGraph 之上，而非从零造轮子。这个决策背后的逻辑是：编排问题已经被 LangGraph 解决了，DeerFlow 要解决的是编排之上的问题——如何让 Agent 在真实环境中安全、可控地运行。

LangGraph 为 DeerFlow 提供了三个核心能力：

有状态图（Stateful Graph）：每个 Agent 执行流程被建模为一个状态图，节点（Node）代表计算步骤，边（Edge）代表状态转移。图的状态（State）在节点间流动，可以被持久化、回溯和恢复。这是 DeerFlow 能够支撑长任务的基础——即使任务执行到一半系统重启，也可以从最后保存的状态点恢复执行。

条件路由（Conditional Routing）：状态图的边可以包含条件逻辑，根据当前状态动态选择下一个执行节点。DeerFlow 的 Lead Agent 在制定执行计划后，使用条件路由将不同的子任务分发到不同的 Sub-Agent 节点。

Checkpointing（检查点）：LangGraph 内置了检查点机制，定期将图的状态持久化到存储后端。DeerFlow 利用这一机制实现了任务中断恢复和对话历史的持久化。

但 LangGraph 本身不解决以下问题——这正是 DeerFlow 的价值所在：

用一个比喻来说：LangGraph 是一台引擎，提供了强大的动力和精密的控制；DeerFlow 是围绕这台引擎打造的整辆汽车——有底盘、有车身、有安全气囊、有仪表盘、有方向盘。你可以用 LangGraph 引擎自己造车，但 DeerFlow 给了你一辆开箱即用的成品。

这种"构建在成熟基础设施之上"的策略也体现在 DeerFlow 的其他技术选型中：前端使用 Next.js（成熟的 React 框架），API 层使用 FastAPI（高性能的 Python Web 框架），沙箱使用 Docker（工业级的容器技术）。DeerFlow 团队显然深谙一个道理：在生产系统中，选择经过验证的组件比自己发明轮子更明智。

第三部分：核心能力深度拆解

章节导读：这是本文最核心的部分。我们将逐一拆解 DeerFlow 2.0 的七大核心能力：Lead Agent、Sub-Agent 系统、Sandbox 沙箱、MCP 工具协议、Skill 技能系统、Memory 记忆系统、以及 18 层中间件链。

3.1 Lead Agent：超级智能体的"大脑"

Lead Agent 是 DeerFlow 中的主智能体，也是用户直接对话的对象。它的角色类似于一个项目经理：理解用户需求，制定执行计划，将子任务分配给合适的 Sub-Agent，然后汇总结果。

Lead Agent 的关键设计特点包括：

Plan Mode（计划模式）：在执行复杂任务之前，Lead Agent 会先进入计划模式，生成一个结构化的执行计划。这个计划会被展示给用户确认，用户可以选择同意、修改或追加要求。这种"先规划再执行"的模式大大降低了长任务跑偏的风险。

# Plan Mode 的执行计划示例
task: "分析 2025 年全球新能源汽车市场趋势"
plan:
– step: 1
action: "搜索全球新能源汽车销量数据"
agent: research–sub–agent
– step: 2
action: "搜索主要厂商市场份额和技术路线"
agent: research–sub–agent
– step: 3
action: "爬取行业报告关键图表数据"
agent: browser–sub–agent
– step: 4
action: "用 Python 进行数据分析与可视化"
agent: code–sub–agent
– step: 5
action: "生成结构化研究报告"
agent: lead–agent

Context Summarization（上下文摘要）：长任务执行过程中，对话历史会不断膨胀。DeerFlow 内置了上下文摘要机制，自动对过长的上下文进行压缩和总结，确保 Agent 不会因为 Token 溢出而崩溃。

Vision Support（视觉支持）：Lead Agent 支持图片输入，用户可以上传图片让 Agent 分析，这在代码调试、设计审查等场景中非常实用。

File Upload（文件上传）：支持用户上传文件作为任务输入，Agent 可以读取文件内容并基于其进行分析、转换或处理。

3.2 Sub-Agent 系统：多智能体协作的执行引擎

DeerFlow 的多智能体协作不是简单的"角色扮演"，而是一种任务委派模式。Lead Agent 根据任务性质，将子任务委派给专门的 Sub-Agent，每个 Sub-Agent 都是特定领域的专家。

DeerFlow 2.0 内置了三类 Sub-Agent：

Research Sub-Agent（研究子智能体） 负责信息搜索和收集。它会执行多轮搜索-阅读-摘要的循环，像一个尽职的研究助理一样，不断深挖直到收集到足够的信息。它集成了 Tavily 等搜索引擎，能够进行高质量的网络搜索。

Code Sub-Agent（编码子智能体） 负责代码的编写和执行。它不仅能写出代码，更重要的是——它能在沙箱中真正运行代码并获取执行结果。这意味着 Agent 可以写一个数据分析脚本，运行它，根据实际输出调整代码，形成"编写-运行-调试"的闭环。

Browser Sub-Agent（浏览器子智能体） 负责浏览器操作。它可以打开网页、提取内容、填写表单、截图等，适用于需要与 Web 页面交互的场景。

这种委派模式的一个关键优势是并行执行。当多个子任务之间没有依赖关系时，多个 Sub-Agent 可以并行工作，显著提升任务完成速度。例如，在一个市场调研任务中，Research Sub-Agent 搜索数据的同时，Browser Sub-Agent 可以爬取特定网站的信息。

你还可以通过 Skill 系统自定义 Sub-Agent，赋予它特定的工具和行为模式。

3.2.1 Sub-Agent 的内部运行机制

每个 Sub-Agent 在 DeerFlow 内部本质上是一个独立的 LangGraph 节点（Node），具备自己的 System Prompt、工具集和执行策略。当 Lead Agent 决定委派一个子任务时，它会构造一个标准化的委派请求，包含任务描述、上下文片段和预期输出格式。

以下是一个自定义 Sub-Agent 的简化定义示例，展示其内部结构：

# custom_sub_agent.py – DeerFlow Sub-Agent 定义示例
# 需要 DeerFlow 2.0+

from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI

# 定义 Sub-Agent 的状态结构
class SubAgentState:
task: str # 任务描述
context: dict # 从 Lead Agent 传入的上下文
tool_calls: list # 工具调用历史
result: str # 执行结果
iteration: int # 当前迭代次数

# 创建一个"数据分析 Sub-Agent"
def create_data_analyst_subagent():
llm = ChatOpenAI(model="gpt-4o", temperature=0.3)

# 绑定工具：代码执行沙箱、文件读取、图表生成
tools = [
sandbox_execute_python, # 在沙箱中执行 Python 代码
file_read_csv, # 读取 CSV/Excel 文件
generate_chart, # 生成可视化图表
]
llm_with_tools = llm.bind_tools(tools)

# Sub-Agent 的 System Prompt
system_prompt = """你是一个专业的数据分析师 Sub-Agent。
你的任务是接收数据分析需求，编写并执行 Python 代码完成任务。
关键原则：
1. 优先使用 pandas 进行数据处理
2. 使用 matplotlib/seaborn 生成可视化
3. 代码必须在沙箱中执行，路径使用 /mnt/user-data/
4. 如果执行报错，分析错误并修正代码后重试（最多 3 次）
5. 返回结构化的分析结果和生成的图表路径
"""

# 定义 LangGraph 状态图的节点
def analyze(state: SubAgentState) –> SubAgentState:
"""分析任务并决定执行步骤"""
response = llm_with_tools.invoke([
{"role": "system", "content": system_prompt},
{"role": "user", "content": state["task"]}
])
state["tool_calls"] = response.tool_calls
return state

def execute(state: SubAgentState) –> SubAgentState:
"""在沙箱中执行工具调用"""
for tool_call in state["tool_calls"]:
result = tools_map[tool_call["name"]].invoke(
tool_call["args"]
)
state["result"] = result
state["iteration"] += 1
return state

# 构建状态图
graph = StateGraph(SubAgentState)
graph.add_node("analyze", analyze)
graph.add_node("execute", execute)
graph.add_edge("analyze", "execute")
graph.add_conditional_edges(
"execute",
lambda s: "analyze" if s["iteration"] < 3 and has_error(s) else END
)
graph.set_entry_point("analyze")

return graph.compile()

# 在 DeerFlow 中注册自定义 Sub-Agent
# Lead Agent 可以根据任务自动调度此 Sub-Agent

这个示例揭示了 Sub-Agent 的几个关键设计特点：每个 Sub-Agent 拥有独立的 LangGraph 状态图（State Graph），具备自己的迭代循环（分析→执行→检查→重试），并且通过沙箱工具实现安全的代码执行。Lead Agent 在调度时会为每个 Sub-Agent 分配独立的线程 ID，确保沙箱环境的隔离。

3.3 Sandbox 沙箱：让 AI 安全地"动手做事"

Sandbox（沙箱）是 DeerFlow 2.0 最具差异化的能力之一，也是从"聊天"到"干活"的关键桥梁。

3.3.1 三层沙箱架构

DeerFlow 提供了三个级别的沙箱隔离方案，适应不同的部署场景：

Docker 沙箱 是最常用的模式，也是 DeerFlow 的核心设计。它采用 Docker-outside-of-Docker（DooD） 架构：

#mermaid-svg-W0aoG1pMbesKcjbz{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-W0aoG1pMbesKcjbz .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-W0aoG1pMbesKcjbz .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-W0aoG1pMbesKcjbz .error-icon{fill:#552222;}#mermaid-svg-W0aoG1pMbesKcjbz .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-W0aoG1pMbesKcjbz .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-W0aoG1pMbesKcjbz .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-W0aoG1pMbesKcjbz .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-W0aoG1pMbesKcjbz .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-W0aoG1pMbesKcjbz .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-W0aoG1pMbesKcjbz .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-W0aoG1pMbesKcjbz .marker{fill:#333333;stroke:#333333;}#mermaid-svg-W0aoG1pMbesKcjbz .marker.cross{stroke:#333333;}#mermaid-svg-W0aoG1pMbesKcjbz svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-W0aoG1pMbesKcjbz p{margin:0;}#mermaid-svg-W0aoG1pMbesKcjbz .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-W0aoG1pMbesKcjbz .cluster-label text{fill:#333;}#mermaid-svg-W0aoG1pMbesKcjbz .cluster-label span{color:#333;}#mermaid-svg-W0aoG1pMbesKcjbz .cluster-label span p{background-color:transparent;}#mermaid-svg-W0aoG1pMbesKcjbz .label text,#mermaid-svg-W0aoG1pMbesKcjbz span{fill:#333;color:#333;}#mermaid-svg-W0aoG1pMbesKcjbz .node rect,#mermaid-svg-W0aoG1pMbesKcjbz .node circle,#mermaid-svg-W0aoG1pMbesKcjbz .node ellipse,#mermaid-svg-W0aoG1pMbesKcjbz .node polygon,#mermaid-svg-W0aoG1pMbesKcjbz .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-W0aoG1pMbesKcjbz .rough-node .label text,#mermaid-svg-W0aoG1pMbesKcjbz .node .label text,#mermaid-svg-W0aoG1pMbesKcjbz .image-shape .label,#mermaid-svg-W0aoG1pMbesKcjbz .icon-shape .label{text-anchor:middle;}#mermaid-svg-W0aoG1pMbesKcjbz .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-W0aoG1pMbesKcjbz .rough-node .label,#mermaid-svg-W0aoG1pMbesKcjbz .node .label,#mermaid-svg-W0aoG1pMbesKcjbz .image-shape .label,#mermaid-svg-W0aoG1pMbesKcjbz .icon-shape .label{text-align:center;}#mermaid-svg-W0aoG1pMbesKcjbz .node.clickable{cursor:pointer;}#mermaid-svg-W0aoG1pMbesKcjbz .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-W0aoG1pMbesKcjbz .arrowheadPath{fill:#333333;}#mermaid-svg-W0aoG1pMbesKcjbz .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-W0aoG1pMbesKcjbz .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-W0aoG1pMbesKcjbz .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-W0aoG1pMbesKcjbz .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-W0aoG1pMbesKcjbz .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-W0aoG1pMbesKcjbz .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-W0aoG1pMbesKcjbz .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-W0aoG1pMbesKcjbz .cluster text{fill:#333;}#mermaid-svg-W0aoG1pMbesKcjbz .cluster span{color:#333;}#mermaid-svg-W0aoG1pMbesKcjbz div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-W0aoG1pMbesKcjbz .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-W0aoG1pMbesKcjbz rect.text{fill:none;stroke-width:0;}#mermaid-svg-W0aoG1pMbesKcjbz .icon-shape,#mermaid-svg-W0aoG1pMbesKcjbz .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-W0aoG1pMbesKcjbz .icon-shape p,#mermaid-svg-W0aoG1pMbesKcjbz .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-W0aoG1pMbesKcjbz .icon-shape .label rect,#mermaid-svg-W0aoG1pMbesKcjbz .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-W0aoG1pMbesKcjbz .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-W0aoG1pMbesKcjbz .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-W0aoG1pMbesKcjbz :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

宿主机

通过 docker.sock创建子容器

通过 docker.sock创建子容器

沙箱容器 2Thread B

Python/Node 代码执行

/mnt/user-data/线程隔离文件系统

沙箱容器 1Thread A

Python/Node 代码执行

/mnt/user-data/线程隔离文件系统

DeerFlow 主容器

docker.sock

核心机制是：DeerFlow 主容器通过挂载宿主机的 docker.sock，动态创建独立的沙箱容器。每个沙箱容器拥有独立的 PID 命名空间、网络命名空间和文件系统，彼此完全隔离。

3.3.2 虚拟路径映射

沙箱内部使用虚拟路径 /mnt/user-data/ 映射到宿主机上按线程 ID 隔离的目录。这意味着：

• Thread A 的代码只能看到和操作 Thread A 的文件。
• Thread B 的代码无法访问 Thread A 的数据。
• 宿主机的文件系统完全不受影响。

3.3.3 Guardrails 安全护栏

除了容器级别的隔离，DeerFlow 还在代码执行前设置了 Guardrails（安全护栏）。系统会对即将执行的代码进行静态分析，拦截高危命令（如 rm -rf /、sudo 提权、网络端口扫描等）。这相当于在沙箱的门口加了一道安检，即使 Agent 被诱导生成恶意代码，也无法执行破坏性操作。

3.3.4 代码执行的完整流程

一次代码执行的完整流程如下：

3.4 MCP 工具协议：连接无限外部能力

DeerFlow 2.0 集成了 MCP（Model Context Protocol） 工具协议。MCP 是由 Anthropic 提出的开放标准，旨在为 AI Agent 提供一个统一的工具调用接口——类似于 AI 世界的"USB 协议"。

通过 MCP，DeerFlow 可以无缝接入各种外部工具和服务，而无需为每个工具编写定制化的集成代码。只需在 extensions_config.json 中配置 MCP Server 的连接信息，Agent 就能调用该工具：

{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"]
},
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": { "GITHUB_TOKEN": "your-token" }
},
"puppeteer": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-puppeteer"]
}
}
}

MCP 工具的一个关键特性是异步执行：Agent 可以同时调用多个 MCP 工具，而不是串行等待每个工具返回。这在需要同时查询多个数据源的场景中，能显著提升效率。

3.5 Skill 技能系统：用 Markdown 定义 Agent 的能力

Skill（技能）系统是 DeerFlow 2.0 最具创新性的设计之一。它回答了一个关键问题：如何以最低成本、最高可维护性的方式给 Agent 添加新能力？

DeerFlow 的答案是：用 Markdown 文件定义技能。

3.5.1 技能的结构

一个 Skill 本质上就是一个 SKILL.md 文件，包含 YAML frontmatter 和 Markdown 正文：

—
name: deep-research
description: 执行深度研究任务，包括多轮搜索、分析和报告生成
version: 1.0.0
tags: [research, analysis, report]
—

# Deep Research Skill

## 工作流程

1. 理解用户的研究问题，拆解为 3-5 个子问题
2. 对每个子问题执行搜索-阅读-摘要循环
3. 交叉验证多个信息源
4. 综合分析，生成结构化报告

## 最佳实践

– 优先使用权威信息源
– 对关键数据进行交叉验证
– 报告中明确标注信息来源
– 对不确定的结论标注置信度

## 参考资源

– [研究报告模板](./templates/research-report.md)

YAML frontmatter 定义技能的元数据（名称、描述、版本、标签），Markdown 正文定义工作流、最佳实践和参考资源。

3.5.2 内置技能

DeerFlow 2.0 内置了多个核心技能，覆盖从研究到执行的全场景。以下列出最主要的技能（完整列表随版本持续扩展）：

3.5.3 自定义技能

你可以在 skills/custom/ 目录下创建自定义技能，也可以通过 API 动态安装技能。自定义技能遵循相同的 SKILL.md 格式，Lead Agent 会根据用户的任务自动匹配和加载合适的技能。

这种设计的优势在于：技能的定义和代码逻辑解耦。你不需要修改 Agent 的核心代码，也不需要重新部署系统，只需要添加一个 Markdown 文件就能赋予 Agent 新的能力。这大大降低了扩展 Agent 能力的门槛。

3.6 Memory 记忆系统：跨会话的持久化知识

DeerFlow 2.0 内置了 Memory（记忆）系统，使 Agent 能够在多次会话之间保持上下文和知识积累。

记忆系统基于 SQLite 实现本地持久化存储，支持以下几类记忆：

会话记忆（Session Memory）：记录当前会话的对话历史，支持上下文摘要压缩，确保长会话不会因为 Token 限制而丢失关键信息。

长期记忆（Long-term Memory）：跨会话持久化的知识。当用户告诉 Agent"我使用 Python 3.11"或"我的项目部署在 AWS 上"这类偏好信息时，Agent 会将其存储到长期记忆中，后续会话自动使用这些信息。

任务记忆（Task Memory）：记录历史任务的执行计划和结果摘要，使 Agent 在面对类似任务时能够参考过去的经验。

3.6.1 记忆系统的工作原理与 API

DeerFlow 的记忆系统并非简单的"聊天记录存储"，而是一套结构化的知识提取和注入机制。它的工作流程如下：

Memory 存储

中间件层

Lead Agent

用户

Memory 存储

中间件层

Lead Agent

用户

#mermaid-svg-1HpOjVSiImdxHMab{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-1HpOjVSiImdxHMab .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-1HpOjVSiImdxHMab .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-1HpOjVSiImdxHMab .error-icon{fill:#552222;}#mermaid-svg-1HpOjVSiImdxHMab .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-1HpOjVSiImdxHMab .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-1HpOjVSiImdxHMab .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-1HpOjVSiImdxHMab .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-1HpOjVSiImdxHMab .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-1HpOjVSiImdxHMab .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-1HpOjVSiImdxHMab .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-1HpOjVSiImdxHMab .marker{fill:#333333;stroke:#333333;}#mermaid-svg-1HpOjVSiImdxHMab .marker.cross{stroke:#333333;}#mermaid-svg-1HpOjVSiImdxHMab svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-1HpOjVSiImdxHMab p{margin:0;}#mermaid-svg-1HpOjVSiImdxHMab .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-1HpOjVSiImdxHMab text.actor>tspan{fill:black;stroke:none;}#mermaid-svg-1HpOjVSiImdxHMab .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-1HpOjVSiImdxHMab .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-svg-1HpOjVSiImdxHMab .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-svg-1HpOjVSiImdxHMab .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-svg-1HpOjVSiImdxHMab #arrowhead path{fill:#333;stroke:#333;}#mermaid-svg-1HpOjVSiImdxHMab .sequenceNumber{fill:white;}#mermaid-svg-1HpOjVSiImdxHMab #sequencenumber{fill:#333;}#mermaid-svg-1HpOjVSiImdxHMab #crosshead path{fill:#333;stroke:#333;}#mermaid-svg-1HpOjVSiImdxHMab .messageText{fill:#333;stroke:none;}#mermaid-svg-1HpOjVSiImdxHMab .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-1HpOjVSiImdxHMab .labelText,#mermaid-svg-1HpOjVSiImdxHMab .labelText>tspan{fill:black;stroke:none;}#mermaid-svg-1HpOjVSiImdxHMab .loopText,#mermaid-svg-1HpOjVSiImdxHMab .loopText>tspan{fill:black;stroke:none;}#mermaid-svg-1HpOjVSiImdxHMab .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-1HpOjVSiImdxHMab .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-1HpOjVSiImdxHMab .noteText,#mermaid-svg-1HpOjVSiImdxHMab .noteText>tspan{fill:black;stroke:none;}#mermaid-svg-1HpOjVSiImdxHMab .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-svg-1HpOjVSiImdxHMab .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-svg-1HpOjVSiImdxHMab .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-svg-1HpOjVSiImdxHMab .actorPopupMenu{position:absolute;}#mermaid-svg-1HpOjVSiImdxHMab .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-1HpOjVSiImdxHMab .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-1HpOjVSiImdxHMab .actor-man circle,#mermaid-svg-1HpOjVSiImdxHMab line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-svg-1HpOjVSiImdxHMab :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

"我使用 Python 3.11，项目部署在 AWS"

消息经过中间件链

Memory 注入层：检索相关长期记忆

返回匹配的长期记忆片段

将记忆注入 System Prompt

识别用户偏好信息

响应经过中间件链

Memory 更新层：提取并存储新偏好

确认存储成功

确认并记住偏好

在配置层面，记忆系统的行为通过 config.yaml 进行控制：

# config.yaml – Memory 系统配置
memory:
enabled: true # 是否启用记忆系统
storage: sqlite # 存储后端：sqlite / postgresql
db_path: ./data/memory.db # SQLite 数据库路径

session:
max_history: 50 # 会话历史最大条数
summary_threshold: 30 # 触发摘要压缩的阈值
summary_model: gpt–4o–mini # 用于摘要的模型（降低成本）

long_term:
enabled: true # 是否启用长期记忆
auto_extract: true # 自动从对话中提取关键信息
max_entries: 1000 # 长期记忆最大条目数
relevance_threshold: 0.7 # 记忆检索的相关性阈值

task:
enabled: true # 是否启用任务记忆
max_history: 20 # 保留最近 N 个任务记录
include_artifacts: true # 是否存储任务产出物摘要

3.6.2 记忆注入的实战效果

记忆系统的真正价值体现在跨会话场景中。假设你在第一次会话中告诉 DeerFlow：

“我们团队使用 Go 语言，数据库是 PostgreSQL，部署在 Kubernetes 上，代码托管在 GitHub。”

这些信息会被 Memory 更新层自动提取并存储为长期记忆。在后续的会话中，当你说"帮我写一个数据处理服务"时，Memory 注入层会将这些偏好注入到 Lead Agent 的 System Prompt 中，Agent 会自动使用 Go 语言编写代码，使用 PostgreSQL 作为数据库，生成 Kubernetes 部署清单，而不是默认使用 Python + SQLite。

这种"无需重复告知"的能力，使得 DeerFlow 在长期使用中的体验显著优于无状态的 Agent 框架。

3.6.3 生产环境的存储升级

在开发环境中，Memory 系统使用 SQLite 作为存储后端，简单且零配置。但在生产环境中，当并发用户数增加时，SQLite 的单写锁会成为瓶颈。DeerFlow 支持将存储后端升级为 PostgreSQL，只需修改配置：

# 生产环境 Memory 配置
memory:
storage: postgresql
postgresql:
host: localhost
port: 5432
database: deerflow_memory
user: deerflow
password: ${DB_PASSWORD} # 从环境变量读取
pool_size: 10 # 连接池大小

这种从 SQLite 到 PostgreSQL 的平滑升级路径，使得 DeerFlow 在开发和生产环境之间实现了无缝衔接。

3.7 18 层中间件链：Agent 执行的"安检通道"

中间件（Middleware）是 DeerFlow 2.0 架构中最体现"Harness"理念的设计。每次 Lead Agent 执行一个步骤（接收消息、调用 LLM、使用工具、返回结果），都会经过一条精心设计的中间件链。

这些中间件按固定顺序执行，每一层负责一个特定的横切关注点：

#mermaid-svg-o84MmR4OmEvDOyOn{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-o84MmR4OmEvDOyOn .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-o84MmR4OmEvDOyOn .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-o84MmR4OmEvDOyOn .error-icon{fill:#552222;}#mermaid-svg-o84MmR4OmEvDOyOn .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-o84MmR4OmEvDOyOn .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-o84MmR4OmEvDOyOn .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-o84MmR4OmEvDOyOn .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-o84MmR4OmEvDOyOn .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-o84MmR4OmEvDOyOn .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-o84MmR4OmEvDOyOn .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-o84MmR4OmEvDOyOn .marker{fill:#333333;stroke:#333333;}#mermaid-svg-o84MmR4OmEvDOyOn .marker.cross{stroke:#333333;}#mermaid-svg-o84MmR4OmEvDOyOn svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-o84MmR4OmEvDOyOn p{margin:0;}#mermaid-svg-o84MmR4OmEvDOyOn .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-o84MmR4OmEvDOyOn .cluster-label text{fill:#333;}#mermaid-svg-o84MmR4OmEvDOyOn .cluster-label span{color:#333;}#mermaid-svg-o84MmR4OmEvDOyOn .cluster-label span p{background-color:transparent;}#mermaid-svg-o84MmR4OmEvDOyOn .label text,#mermaid-svg-o84MmR4OmEvDOyOn span{fill:#333;color:#333;}#mermaid-svg-o84MmR4OmEvDOyOn .node rect,#mermaid-svg-o84MmR4OmEvDOyOn .node circle,#mermaid-svg-o84MmR4OmEvDOyOn .node ellipse,#mermaid-svg-o84MmR4OmEvDOyOn .node polygon,#mermaid-svg-o84MmR4OmEvDOyOn .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-o84MmR4OmEvDOyOn .rough-node .label text,#mermaid-svg-o84MmR4OmEvDOyOn .node .label text,#mermaid-svg-o84MmR4OmEvDOyOn .image-shape .label,#mermaid-svg-o84MmR4OmEvDOyOn .icon-shape .label{text-anchor:middle;}#mermaid-svg-o84MmR4OmEvDOyOn .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-o84MmR4OmEvDOyOn .rough-node .label,#mermaid-svg-o84MmR4OmEvDOyOn .node .label,#mermaid-svg-o84MmR4OmEvDOyOn .image-shape .label,#mermaid-svg-o84MmR4OmEvDOyOn .icon-shape .label{text-align:center;}#mermaid-svg-o84MmR4OmEvDOyOn .node.clickable{cursor:pointer;}#mermaid-svg-o84MmR4OmEvDOyOn .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-o84MmR4OmEvDOyOn .arrowheadPath{fill:#333333;}#mermaid-svg-o84MmR4OmEvDOyOn .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-o84MmR4OmEvDOyOn .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-o84MmR4OmEvDOyOn .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-o84MmR4OmEvDOyOn .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-o84MmR4OmEvDOyOn .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-o84MmR4OmEvDOyOn .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-o84MmR4OmEvDOyOn .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-o84MmR4OmEvDOyOn .cluster text{fill:#333;}#mermaid-svg-o84MmR4OmEvDOyOn .cluster span{color:#333;}#mermaid-svg-o84MmR4OmEvDOyOn div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-o84MmR4OmEvDOyOn .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-o84MmR4OmEvDOyOn rect.text{fill:none;stroke-width:0;}#mermaid-svg-o84MmR4OmEvDOyOn .icon-shape,#mermaid-svg-o84MmR4OmEvDOyOn .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-o84MmR4OmEvDOyOn .icon-shape p,#mermaid-svg-o84MmR4OmEvDOyOn .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-o84MmR4OmEvDOyOn .icon-shape .label rect,#mermaid-svg-o84MmR4OmEvDOyOn .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-o84MmR4OmEvDOyOn .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-o84MmR4OmEvDOyOn .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-o84MmR4OmEvDOyOn :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

用户输入

1. 输入验证

2. 认证鉴权

3. 速率限制

4. 上下文注入

5. Skill 加载

6. Memory 注入

7. Prompt 构建

8. Token 计数

9. LLM 调用

10. 输出解析

11. 工具调用拦截

12. 安全护栏检查

13. 沙箱路由

14. 上下文摘要

15. Memory 更新

16. LangSmith 追踪

17. 日志记录

18. 响应格式化

返回用户

关键中间件层说明：

Skill 加载（第 5 层）：根据用户意图自动匹配和注入相关 Skill 的工作流定义和最佳实践，让 Agent “知道该怎么做”。

工具调用拦截（第 11 层）：在 Agent 调用外部工具之前进行拦截，验证工具调用的合理性和安全性。

安全护栏检查（第 12 层）：对即将执行的代码和命令进行安全审查，拦截危险操作。

沙箱路由（第 13 层）：将代码执行请求路由到正确的沙箱容器。

上下文摘要（第 14 层）：当对话历史超过 Token 阈值时，自动触发上下文压缩。

LangSmith 追踪（第 16 层）：将每个执行步骤的详细信息发送到 LangSmith，实现全链路可观测。

这套中间件链的设计使得 DeerFlow 具备了极强的可定制性——你可以在任何一层插入自定义逻辑，而不影响其他层的运行。

3.7.1 自定义中间件：扩展示例

DeerFlow 的中间件遵循"洋葱模型"（Onion Model）：每个中间件在 Agent 执行前做前置处理（pre-processing），在执行后做后置处理（post-processing）。以下是一个自定义中间件的实现示例——成本监控中间件，用于追踪每次 LLM 调用的 Token 消耗和费用：

# middleware/cost_monitor.py – 自定义成本监控中间件
# 需要 DeerFlow 2.0+

import time
from dataclasses import dataclass
from typing import Callable, Any

@dataclass
class CostRecord:
"""成本记录数据结构"""
model: str
prompt_tokens: int
completion_tokens: int
total_tokens: int
estimated_cost_usd: float
timestamp: float
task_id: str

# 模型定价表（每百万 Token 的美元价格）
PRICING = {
"gpt-4o": {"input": 2.50, "output": 10.00},
"gpt-4o-mini": {"input": 0.15, "output": 0.60},
"claude-sonnet-4-20250514": {"input": 3.00, "output": 15.00},
}

def cost_monitor_middleware(next_handler: Callable) –> Callable:
"""
成本监控中间件
在 LLM 调用前后记录 Token 消耗，计算费用，
并在超出预算阈值时发出告警。
"""
async def handler(state: dict, config: dict) –> dict:
task_id = state.get("thread_id", "unknown")
budget_limit = config.get("budget_limit_usd", 5.0)

# === 前置处理：记录开始时间 ===
start_time = time.time()

# === 调用下一层中间件 / LLM ===
result = await next_handler(state, config)

# === 后置处理：计算成本 ===
usage = result.get("usage", {})
model = state.get("model", "gpt-4o")

prompt_tokens = usage.get("prompt_tokens", 0)
completion_tokens = usage.get("completion_tokens", 0)

# 根据模型定价计算费用
pricing = PRICING.get(model, {"input": 5.0, "output": 15.0})
cost = (
prompt_tokens * pricing["input"] / 1_000_000
+ completion_tokens * pricing["output"] / 1_000_000
)

# 记录成本数据
record = CostRecord(
model=model,
prompt_tokens=prompt_tokens,
completion_tokens=completion_tokens,
total_tokens=prompt_tokens + completion_tokens,
estimated_cost_usd=round(cost, 6),
timestamp=time.time(),
task_id=task_id,
)

# 持久化到数据库
await save_cost_record(record)

# 累加会话总成本
session_total = await get_session_cost(task_id)
if session_total >= budget_limit:
# 超出预算阈值：注入警告到状态中
state["budget_warning"] = (
f"当前会话成本 ${session_total:.2f} "
f"已超过预算 ${budget_limit:.2f}，"
f"请考虑使用更经济的模型或减少上下文长度。"
)

# 将成本信息注入到结果中，供 UI 展示
result["cost_info"] = {
"this_call_usd": round(cost, 6),
"session_total_usd": round(session_total, 4),
"model": model,
"tokens": prompt_tokens + completion_tokens,
"latency_ms": int((time.time() – start_time) * 1000),
}

return result

return handler

# 在 DeerFlow 中注册自定义中间件
# 在 config.yaml 中添加：
# middleware:
# custom:
# – path: middleware.cost_monitor.cost_monitor_middleware
# position: after:llm_call # 在 LLM 调用层之后执行
# config:
# budget_limit_usd: 5.0

这个中间件的工作方式是：每次 Lead Agent 调用 LLM 时，它会在调用完成后计算本次调用的 Token 消耗和预估费用，将记录持久化到数据库，并累加到当前会话的总成本。当总成本超过预设阈值时，它会在 Agent 的状态中注入一条预算警告，触发 Agent 在后续回复中主动告知用户成本情况。

你可以用类似的模式实现各种自定义中间件：速率限制中间件（限制单位时间内的 LLM 调用次数）、审计日志中间件（记录所有工具调用的输入输出用于合规审计）、A/B 测试中间件（对不同用户分组使用不同模型进行对比测试）等。

本节要点：DeerFlow 的七大核心能力——Lead Agent（任务理解与规划）、Sub-Agent（专业化执行）、Sandbox（安全隔离执行）、MCP（外部工具连接）、Skill（Markdown 定义能力）、Memory（跨会话记忆）、Middleware（全链路控制）——共同构成了一个完整的 Super Agent Harness。

第四部分：快速上手与实战演练

章节导读：理论讲完了，这一部分我们动手。从环境搭建到运行第一个深度研究任务，手把手带你走通 DeerFlow 的完整使用流程。

4.1 环境准备

DeerFlow 2.0 提供两种启动方式：Docker 一键部署和本地开发部署。

4.1.1 前置条件

无论哪种方式，你都需要以下前置环境：

# 必需
– Git
– Docker & Docker Compose (v24.0+)
– Make

# 本地开发模式额外需要
– Python 3.11+
– Node.js 18+
– pnpm 8+

4.1.2 Docker 一键部署（推荐）

这是最快速的启动方式，适合想要快速体验的用户：

# 克隆项目
git clone https://github.com/bytedance/deer-flow.git
cd deer-flow

# 配置 API Key
cp .env.example .env
# 编辑 .env 文件，填入你的 LLM API Key
# 支持 OpenAI、Anthropic、Azure OpenAI 等

# 一键启动（Docker Compose 编排所有服务）
make docker-start

启动后，访问 http://localhost:3000 即可看到 DeerFlow 的 Web UI。

4.1.3 本地开发部署

适合需要二次开发或深度调试的用户：

# 克隆项目
git clone https://github.com/bytedance/deer-flow.git
cd deer-flow

# 后端依赖安装
cd backend
python -m venv .venv
source .venv/bin/activate # Windows: .venv\\Scripts\\activate
pip install -e ".[dev]"

# 前端依赖安装
cd ../frontend
pnpm install

# 启动开发服务器
cd ..
make dev

本地开发模式会启动三个服务：

4.2 核心配置

DeerFlow 的配置主要通过两个文件完成：

4.2.1 config.yaml — 主配置文件

# config.yaml 核心配置示例
llm:
provider: openai # LLM 提供商：openai / anthropic / azure
model: gpt–4o # 默认模型
temperature: 0.7 # 生成温度
max_tokens: 4096 # 最大 Token 数

sandbox:
mode: docker # 沙箱模式：local / docker / k8s
image: python:3.11–slim # 沙箱基础镜像
timeout: 300 # 执行超时时间（秒）
memory_limit: 512m # 内存限制

research:
search_engine: tavily # 搜索引擎：tavily / duckduckgo
max_results: 10 # 每次搜索最大结果数
max_iterations: 5 # 深度研究最大迭代轮数

memory:
enabled: true # 是否启用记忆系统
storage: sqlite # 存储后端
db_path: ./data/memory.db # 数据库路径

4.2.2 extensions_config.json — MCP 工具配置

{
"mcpServers": {
"tavily": {
"command": "npx",
"args": ["-y", "tavily-mcp-server"],
"env": {
"TAVILY_API_KEY": "your-tavily-api-key"
}
},
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/data"]
}
}
}

4.2.3 .env — 敏感信息配置

# LLM API Keys
OPENAI_API_KEY=sk-xxx
ANTHROPIC_API_KEY=sk-ant-xxx

# Search Engine
TAVILY_API_KEY=tvly-xxx

# LangSmith (可观测性)
LANGCHAIN_API_KEY=lsv2-xxx
LANGCHAIN_PROJECT=deerflow-dev
LANGCHAIN_TRACING_V2=true

4.3 实战：运行一个深度研究任务

让我们通过一个实际的任务来体验 DeerFlow 的完整工作流程。

任务：请帮我研究 2025-2026 年全球大模型推理优化的技术趋势，生成一份深度研究报告。

Step 1：任务输入与计划生成

在 Web UI 中输入任务描述后，Lead Agent 进入 Plan Mode，生成执行计划：

执行计划：
1. [Research] 搜索"大模型推理优化"相关的最新论文和技术博客
2. [Research] 搜索主要厂商（OpenAI、Google、Anthropic）的推理优化方案
3. [Research] 搜索开源推理优化框架和工具的最新进展
4. [Browser] 爬取 arXiv 和主要技术博客的详细文章内容
5. [Code] 整理数据，生成技术趋势对比分析表
6. [Lead] 综合分析，生成结构化深度研究报告

Step 2：多 Sub-Agent 并行执行

用户确认计划后，Lead Agent 开始调度：

• Research Sub-Agent 1 和 Research Sub-Agent 2 并行启动，分别搜索不同维度的信息。
• 每个 Research Sub-Agent 执行"搜索→阅读→摘要"的循环，通常需要 3-5 轮迭代才能收集到足够的信息。
• Browser Sub-Agent 在搜索阶段完成后启动，爬取特定文章的详细内容。

Step 3：沙箱代码执行

Code Sub-Agent 在沙箱中执行数据分析代码：

# 在 Docker 沙箱中执行
import pandas as pd
import matplotlib.pyplot as plt

# 整理搜索结果中的技术数据
data = {
"技术方向": ["KV Cache 优化", "投机解码", "量化推理", "MoE 架构", "Distillation"],
"代表方案": ["vLLM PagedAttention", "Medusa", "GPTQ/AWQ", "Mixtral", "Phi 系列"],
"加速比": [2.5, 2.0, 3.0, 1.8, 2.2],
"适用场景": ["长上下文", "自回归加速", "显存优化", "稀疏计算", "端侧部署"]
}

df = pd.DataFrame(data)
print(df.to_markdown(index=False))

# 生成对比图
fig, ax = plt.subplots(figsize=(10, 6))
ax.barh(data["技术方向"], data["加速比"])
ax.set_xlabel("推理加速比")
ax.set_title("2025-2026 大模型推理优化技术对比")
plt.tight_layout()
plt.savefig("/mnt/user-data/optimization_comparison.png")
print("图表已保存")

Step 4：报告生成

Lead Agent 汇总所有子任务的结果，生成最终的 Markdown 格式深度研究报告，包含摘要、技术趋势分析、对比表格、可视化图表和参考来源。

Step 5：结果交付

报告、图表、数据来源等全部输出在 Web UI 中展示，用户可以下载或继续追问。

4.4 输出格式的多样性

DeerFlow 不仅能生成 Markdown 报告，还支持多种输出格式：

• Markdown 报告：结构化的深度研究报告，带目录和引用。
• PPT / 幻灯片：通过 document-generation 技能自动生成演示文稿。
• 播客脚本：将研究结果转化为对话式的播客脚本。
• 数据表格：结构化的对比分析表格。
• 可视化图表：通过沙箱中的 Python 代码生成 matplotlib/plotly 图表。

4.5 进阶实战：自定义 Skill + MCP 工具的组合任务

让我们看一个更复杂的实战场景——将自定义 Skill 和 MCP 工具组合起来完成一个端到端的自动化任务。

任务：每周五自动生成"本周 GitHub 热门开源项目周报"，包含项目介绍、Star 增长趋势、技术栈分析和社区活跃度评估。

Step 1：创建自定义 Skill

在 skills/custom/ 目录下创建 github-weekly-report/SKILL.md：

—
name: github-weekly-report
description: 每周自动生成 GitHub 热门开源项目分析报告
version: 1.0.0
tags: [github, report, weekly, open-source]
—

# GitHub 周报生成技能

## 工作流程

1. 使用 GitHub MCP 工具获取本周 Trending 项目列表（前 20 名）
2. 对每个项目收集：Star 数、Fork 数、主要语言、最近一周的 Commit 数量
3. 筛选出 Star 增长最快的 10 个项目
4. 对每个入选项目进行深度分析：
– 项目的核心功能和技术栈
– 社区活跃度（Issue 响应时间、PR 合并率）
– 与同类项目的差异化定位
5. 按类别分组（AI/ML、DevTools、Web、Data 等）
6. 生成可视化图表：Star 增长趋势、语言分布饼图
7. 输出 Markdown 格式的周报

## 数据源

– GitHub Trending API（通过 MCP 工具）
– 项目 README 和 Release Notes（通过 Web 搜索）

## 输出要求

– 每个项目分析控制在 200-300 字
– 报告总长度不超过 5000 字
– 必须包含至少 2 张可视化图表
– 所有数据必须标注获取时间

Step 2：配置 GitHub MCP 工具

在 extensions_config.json 中添加 GitHub MCP Server：

{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
}
}
}
}

Step 3：触发任务

在 DeerFlow Web UI 中输入：“请使用 github-weekly-report 技能，生成本周的 GitHub 热门项目分析报告。”

Lead Agent 会自动加载 github-weekly-report 技能，按照 Skill 中定义的工作流执行：先通过 GitHub MCP 工具获取 Trending 数据，然后调度 Research Sub-Agent 搜索项目详情，Code Sub-Agent 在沙箱中执行数据分析代码并生成图表，最终汇总生成完整的周报。

这个案例展示了 DeerFlow 的核心设计理念：通过 Skill 定义"做什么"和"怎么做"，通过 MCP 连接外部数据源，通过 Sub-Agent 和 Sandbox 执行实际工作。 你只需要编写一个 Markdown 文件，就能把一套复杂的工作流程变成 Agent 的"标准化能力"。

4.6 常见问题与排错指南

在使用 DeerFlow 的过程中，以下是开发者最常遇到的问题及解决方案：

问题 1：沙箱容器创建失败。 这通常是因为 Docker 守护进程未运行，或者当前用户没有访问 docker.sock 的权限。在 Linux 上，确保将当前用户加入 docker 组：sudo usermod -aG docker $USER。在 macOS 上，确保 Docker Desktop 正在运行。

问题 2：LLM API 调用超时或限流。 当 Agent 执行需要大量 LLM 调用的长任务时，很容易触及 API 的速率限制。解决方案：在 config.yaml 中配置 API 调用的重试策略和退避时间；对于使用 OpenAI API 的用户，建议升级到 Tier 3 或更高的使用等级以获得更高的 RPM（每分钟请求数）限制。

问题 3：上下文溢出导致任务中断。 极长的对话历史可能超过 LLM 的上下文窗口限制。DeerFlow 的上下文摘要机制会自动压缩过长的历史，但如果摘要阈值设置过高（接近模型的上下文上限），压缩可能来不及。解决方案：在 config.yaml 中将 memory.session.summary_threshold 设置为模型上下文窗口的 60-70% 处。

问题 4：Skill 未被正确加载。 如果自定义 Skill 没有被 Agent 使用，检查以下事项：SKILL.md 文件是否放在正确的目录下（skills/custom/）；YAML frontmatter 是否格式正确（注意缩进和冒号后的空格）；name 字段是否与用户的任务描述有足够的语义匹配度。

本节要点：DeerFlow 提供 Docker 一键部署和本地开发两种启动方式，通过 config.yaml 和 extensions_config.json 完成核心配置。一个典型的深度研究任务会经历"计划→并行执行→沙箱代码→报告生成→交付"的完整流程。通过自定义 Skill 和 MCP 工具的组合，你可以将任何复杂的重复性工作流变成 Agent 的标准化能力。

第五部分：生产级部署与运维

章节导读：从开发环境到生产环境，还有一段路要走。这一部分我们聊 DeerFlow 在生产环境中的部署策略、安全加固和性能优化。

5.1 生产部署架构

在生产环境中，推荐使用 Docker Compose 或 Kubernetes 进行部署。一个典型的生产架构如下：

#mermaid-svg-xEAA6HtTuFr5OtYb{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-xEAA6HtTuFr5OtYb .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-xEAA6HtTuFr5OtYb .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-xEAA6HtTuFr5OtYb .error-icon{fill:#552222;}#mermaid-svg-xEAA6HtTuFr5OtYb .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-xEAA6HtTuFr5OtYb .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-xEAA6HtTuFr5OtYb .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-xEAA6HtTuFr5OtYb .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-xEAA6HtTuFr5OtYb .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-xEAA6HtTuFr5OtYb .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-xEAA6HtTuFr5OtYb .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-xEAA6HtTuFr5OtYb .marker{fill:#333333;stroke:#333333;}#mermaid-svg-xEAA6HtTuFr5OtYb .marker.cross{stroke:#333333;}#mermaid-svg-xEAA6HtTuFr5OtYb svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-xEAA6HtTuFr5OtYb p{margin:0;}#mermaid-svg-xEAA6HtTuFr5OtYb .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-xEAA6HtTuFr5OtYb .cluster-label text{fill:#333;}#mermaid-svg-xEAA6HtTuFr5OtYb .cluster-label span{color:#333;}#mermaid-svg-xEAA6HtTuFr5OtYb .cluster-label span p{background-color:transparent;}#mermaid-svg-xEAA6HtTuFr5OtYb .label text,#mermaid-svg-xEAA6HtTuFr5OtYb span{fill:#333;color:#333;}#mermaid-svg-xEAA6HtTuFr5OtYb .node rect,#mermaid-svg-xEAA6HtTuFr5OtYb .node circle,#mermaid-svg-xEAA6HtTuFr5OtYb .node ellipse,#mermaid-svg-xEAA6HtTuFr5OtYb .node polygon,#mermaid-svg-xEAA6HtTuFr5OtYb .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-xEAA6HtTuFr5OtYb .rough-node .label text,#mermaid-svg-xEAA6HtTuFr5OtYb .node .label text,#mermaid-svg-xEAA6HtTuFr5OtYb .image-shape .label,#mermaid-svg-xEAA6HtTuFr5OtYb .icon-shape .label{text-anchor:middle;}#mermaid-svg-xEAA6HtTuFr5OtYb .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-xEAA6HtTuFr5OtYb .rough-node .label,#mermaid-svg-xEAA6HtTuFr5OtYb .node .label,#mermaid-svg-xEAA6HtTuFr5OtYb .image-shape .label,#mermaid-svg-xEAA6HtTuFr5OtYb .icon-shape .label{text-align:center;}#mermaid-svg-xEAA6HtTuFr5OtYb .node.clickable{cursor:pointer;}#mermaid-svg-xEAA6HtTuFr5OtYb .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-xEAA6HtTuFr5OtYb .arrowheadPath{fill:#333333;}#mermaid-svg-xEAA6HtTuFr5OtYb .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-xEAA6HtTuFr5OtYb .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-xEAA6HtTuFr5OtYb .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-xEAA6HtTuFr5OtYb .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-xEAA6HtTuFr5OtYb .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-xEAA6HtTuFr5OtYb .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-xEAA6HtTuFr5OtYb .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-xEAA6HtTuFr5OtYb .cluster text{fill:#333;}#mermaid-svg-xEAA6HtTuFr5OtYb .cluster span{color:#333;}#mermaid-svg-xEAA6HtTuFr5OtYb div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-xEAA6HtTuFr5OtYb .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-xEAA6HtTuFr5OtYb rect.text{fill:none;stroke-width:0;}#mermaid-svg-xEAA6HtTuFr5OtYb .icon-shape,#mermaid-svg-xEAA6HtTuFr5OtYb .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-xEAA6HtTuFr5OtYb .icon-shape p,#mermaid-svg-xEAA6HtTuFr5OtYb .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-xEAA6HtTuFr5OtYb .icon-shape .label rect,#mermaid-svg-xEAA6HtTuFr5OtYb .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-xEAA6HtTuFr5OtYb .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-xEAA6HtTuFr5OtYb .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-xEAA6HtTuFr5OtYb :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

监控层

存储层

执行层

编排层

应用层

负载均衡

Nginx反向代理 & SSL

Next.js 前端x2 实例

Gateway APIx2 实例

LangGraph Serverx2 实例

Sandbox PoolWorker 1-10

Sandbox PoolWorker 11-20

PostgreSQL持久化存储

Redis会话缓存

对象存储文件 & 报告

LangSmith链路追踪

Prometheus + Grafana指标监控

关于存储层的设计选择：在开发环境中（如第三部分所述），DeerFlow 使用 SQLite 作为 Memory 系统的存储后端，零配置、开箱即用。但在生产环境中，SQLite 的单写锁和有限并发能力会成为瓶颈，因此建议升级为 PostgreSQL 以支持多实例并发读写。同时引入 Redis 作为会话缓存层，将活跃的 Thread 状态和短期记忆缓存在内存中，减少对 PostgreSQL 的查询压力，显著提升响应速度。文件类产出物（报告、图表、数据文件）则存储在对象存储（如 AWS S3、MinIO）中，实现计算与存储分离。

5.1.1 Kubernetes 部署配置示例

对于需要大规模部署的生产环境，以下是 Kubernetes 部署的核心配置示例：

# k8s/deerflow-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: deerflow–gateway
labels:
app: deerflow
component: gateway
spec:
replicas: 2
selector:
matchLabels:
app: deerflow
component: gateway
template:
metadata:
labels:
app: deerflow
component: gateway
spec:
containers:
– name: gateway
image: deerflow/gateway:2.0
ports:
– containerPort: 8001
env:
– name: OPENAI_API_KEY
valueFrom:
secretKeyRef:
name: deerflow–secrets
key: openai–api–key
– name: DATABASE_URL
valueFrom:
configMapKeyRef:
name: deerflow–config
key: database–url
– name: REDIS_URL
valueFrom:
configMapKeyRef:
name: deerflow–config
key: redis–url
resources:
requests:
memory: "512Mi"
cpu: "500m"
limits:
memory: "1Gi"
cpu: "1000m"
readinessProbe:
httpGet:
path: /health
port: 8001
initialDelaySeconds: 10
periodSeconds: 5
—
# LangGraph Server 部署
apiVersion: apps/v1
kind: Deployment
metadata:
name: deerflow–langgraph
labels:
app: deerflow
component: langgraph
spec:
replicas: 2
selector:
matchLabels:
app: deerflow
component: langgraph
template:
spec:
containers:
– name: langgraph–server
image: deerflow/langgraph:2.0
ports:
– containerPort: 2024
resources:
requests:
memory: "1Gi"
cpu: "1000m"
limits:
memory: "2Gi"
cpu: "2000m"
volumeMounts:
– name: docker–sock
mountPath: /var/run/docker.sock
volumes:
– name: docker–sock
hostPath:
path: /var/run/docker.sock

注意 LangGraph Server 的部署中挂载了 docker.sock，这是 Docker-outside-of-Docker 沙箱机制的核心——LangGraph Server 通过宿主机的 Docker 守护进程动态创建沙箱容器。在 Kubernetes 环境中，你需要确保 Node 上运行着 Docker 守护进程，并且 Pod 具有访问 docker.sock 的权限（通常通过 hostPath volume 实现）。

5.1.2 Docker Compose 快速生产部署

对于中小规模部署，Docker Compose 是更简单的选择：

# docker-compose.prod.yaml
version: '3.8'
services:
nginx:
image: nginx:alpine
ports:
– "80:80"
– "443:443"
volumes:
– ./nginx.conf:/etc/nginx/nginx.conf
– ./certs:/etc/nginx/certs
depends_on:
– frontend
– gateway

frontend:
image: deerflow/frontend:2.0
environment:
– NEXT_PUBLIC_API_URL=http://gateway:8001
deploy:
replicas: 2

gateway:
image: deerflow/gateway:2.0
ports:
– "8001:8001"
env_file:
– .env
environment:
– DATABASE_URL=postgresql://deerflow:${DB_PASSWORD}@postgres:5432/deerflow
– REDIS_URL=redis://redis:6379/0
– SANDBOX_MODE=docker
volumes:
– /var/run/docker.sock:/var/run/docker.sock
deploy:
replicas: 2
depends_on:
– postgres
– redis

langgraph:
image: deerflow/langgraph:2.0
ports:
– "2024:2024"
env_file:
– .env
volumes:
– /var/run/docker.sock:/var/run/docker.sock
deploy:
replicas: 2

postgres:
image: postgres:16–alpine
environment:
POSTGRES_DB: deerflow
POSTGRES_USER: deerflow
POSTGRES_PASSWORD: ${DB_PASSWORD}
volumes:
– pgdata:/var/lib/postgresql/data

redis:
image: redis:7–alpine
volumes:
– redisdata:/data

volumes:
pgdata:
redisdata:

5.2 安全加固清单

在生产环境中，需要特别关注以下安全事项：

API 认证：Gateway API 必须配置 JWT 或 OAuth 认证，防止未授权访问。

沙箱隔离：生产环境必须使用 Docker 或 K8s 沙箱模式，严禁使用 Local 模式。每个沙箱容器应设置 CPU 和内存限制，防止资源耗尽攻击。

网络隔离：沙箱容器应使用独立的 Docker 网络，限制其对外部网络的访问。如果 Agent 不需要联网执行任务，应完全禁止沙箱的网络访问。

密钥管理：所有 API Key 和敏感配置应通过环境变量或密钥管理服务（如 AWS Secrets Manager、HashiCorp Vault）注入，不要硬编码在配置文件中。

Guardrails 策略：根据业务场景定制安全护栏规则，明确哪些系统调用和代码模式应该被拦截。

日志与审计：开启详细的审计日志，记录每个 Agent 的每次工具调用、代码执行和文件操作。在金融、医疗等合规要求高的行业，这些审计日志是不可或缺的。建议将审计日志发送到独立的日志存储系统（如 Elasticsearch），防止被篡改。

沙箱资源限制：为每个沙箱容器设置明确的资源上限，防止单个任务耗尽系统资源：

# config.yaml – 沙箱资源限制配置
sandbox:
mode: docker
resource_limits:
cpu: "1.0" # 每个沙箱最多使用 1 个 CPU 核心
memory: "512m" # 每个沙箱最多使用 512MB 内存
pids: 100 # 每个沙箱最多运行 100 个进程
timeout: 300 # 单次执行超时 5 分钟
max_concurrent: 5 # 最多同时运行 5 个沙箱
network:
enabled: true # 是否允许网络访问
allowed_domains: # 白名单域名
– "api.openai.com"
– "api.tavily.com"
blocked_ports: # 禁止访问的端口
– 22 # SSH
– 3306 # MySQL

5.3 可观测性：LangSmith 全链路追踪

DeerFlow 与 LangSmith 的深度集成，提供了 Agent 领域的"分布式追踪"能力：

Trace（追踪）：每一次用户请求对应一个 Trace，记录了从用户输入到最终输出的完整执行链路。

Span（跨度）：每个 Trace 包含多个 Span，对应 Lead Agent 的每次 LLM 调用、每个 Sub-Agent 的执行、每次工具调用。每个 Span 记录了输入、输出、耗时、Token 消耗等详细信息。

Dashboard（仪表盘）：LangSmith 提供了可视化仪表盘，展示执行成功率、平均耗时、Token 消耗趋势、错误分布等关键指标。

Replay（回放）：可以回放任意一次执行的完整链路，用于调试和问题排查。

配置 LangSmith 非常简单，只需在 .env 文件中设置相关环境变量：

LANGCHAIN_API_KEY=lsv2-xxx
LANGCHAIN_PROJECT=deerflow-production
LANGCHAIN_TRACING_V2=true
LANGCHAIN_ENDPOINT=https://api.smith.langchain.com

5.4 性能优化建议

并行度调优：根据服务器资源调整 Sub-Agent 的最大并发数。过多的并发会导致 LLM API 限流，过少则无法充分利用资源。

上下文窗口管理：合理设置上下文摘要的触发阈值。阈值过低会丢失重要信息，过高则会导致 Token 浪费和推理延迟。

模型选择策略：不同复杂度的子任务使用不同的模型。简单的信息提取可以使用 GPT-4o-mini 或 Claude Haiku 降低成本，复杂的分析和推理使用 GPT-4o 或 Claude Sonnet。

缓存策略：对于重复性高的搜索查询，启用搜索结果缓存，减少 API 调用和等待时间。

沙箱池化：预热一批沙箱容器，避免每次代码执行都需要创建新容器的冷启动延迟。Docker 容器的创建通常需要 1-3 秒，对于需要频繁执行短代码片段的任务，这个延迟会累积成显著的等待时间。通过维护一个"预热池"，当 Sub-Agent 需要执行代码时，直接从池中获取已就绪的容器，执行完毕后回收而不是销毁，可以将代码执行的响应时间降低到毫秒级别。

日志级别调优：在生产环境中，将非关键组件的日志级别设置为 WARNING 或 ERROR，减少磁盘 IO 开销。仅在调试特定问题时，临时开启 DEBUG 级别日志。过多的日志不仅影响性能，还会增加存储成本。建议将日志发送到集中的日志管理系统（如 Loki 或 Elasticsearch），便于检索和分析。

本节要点：生产部署需要关注高可用（多实例 + 负载均衡）、安全加固（认证 + 隔离 + 密钥管理）、可观测性（LangSmith 全链路追踪）和性能优化（并行度 + 缓存 + 模型分级）。

第六部分：生态、对比与未来展望

章节导读：没有银弹。这一部分我们把 DeerFlow 放到更大的生态中，与主流框架进行客观对比，帮你判断什么时候该用它、什么时候不该用。

6.1 AI Agent 框架生态全景

2026 年，AI Agent 框架赛道已经形成了相对稳定的竞争格局。主要的开源框架可以分为几个类别：

基础编排层：LangGraph（LangChain 团队）、AG2/AutoGen（微软）

多智能体协作：CrewAI、Camel-AI

超级智能体运行时：DeerFlow

自主 Agent：AutoGPT、BabyAGI

低代码平台：Dify、Coze、FastGPT

DeerFlow 的定位明确在"超级智能体运行时"这一层——它不试图定义 Agent 的协作模式（像 CrewAI），也不试图成为最底层的编排引擎（像 LangGraph），而是在编排引擎之上，提供 Agent 在生产环境中运行所需的一切基础设施。

6.2 与主流框架的横向对比

DeerFlow vs LangGraph

选择建议：如果你需要从零构建自定义的 Agent 编排逻辑，LangGraph 是更好的底层选择。如果你需要一个开箱即用的、能安全运行 Agent 代码的生产级平台，DeerFlow 更合适。两者并不互斥——DeerFlow 底层就用了 LangGraph。

DeerFlow vs CrewAI

选择建议：如果你的场景需要 Agent 执行代码、操控浏览器、生成长报告等"动手做事"的能力，DeerFlow 更合适。如果你的场景侧重于多个 Agent 以不同角色协作完成流程化任务（如"产品经理→设计师→开发者"的模拟流程），CrewAI 更合适。

DeerFlow vs AutoGen (AG2)

选择建议：DeerFlow 更适合生产级应用，特别是需要安全代码执行和深度研究能力的场景。AutoGen/AG2 更适合学术研究和实验性项目，其对话式协作模式在多智能体研究领域有独特价值。

DeerFlow vs AutoGPT

选择建议：在生产环境中，DeerFlow 的可控性和安全性远优于 AutoGPT。AutoGPT 更适合作为概念验证和探索性项目。

DeerFlow vs 低代码平台（Dify / Coze）

除了与代码优先的 Agent 框架竞争，DeerFlow 还需要与低代码 Agent 平台做区分。Dify 和 Coze（扣子）是当前最流行的低代码 AI 应用平台，它们通过可视化拖拽的方式让用户构建 Agent 工作流，降低了使用门槛。

选择建议：如果你的团队没有开发资源，或者只需要构建简单的问答/对话类应用，Dify 和 Coze 是更务实的选择。但如果你需要深度定制 Agent 行为、安全的系统级代码执行、完全的数据自主控制，或者要将 Agent 集成到现有的工程体系中，DeerFlow 是更合适的底层选择。两者也不是完全互斥——你可以用 DeerFlow 构建核心 Agent 引擎，通过 API 将其能力暴露给低代码平台作为"增强插件"。

6.3 DeerFlow 的优势与局限

核心优势：

DeerFlow 最大的差异化优势在于"Harness"定位带来的工程完备性。它不只是让你定义 Agent 的行为，还解决了 Agent 在真实环境中运行所面临的安全、隔离、可观测、扩展性等工程问题。Skill 系统用 Markdown 定义能力的设计也极具创新性，大幅降低了扩展门槛。此外，内置的 Docker 沙箱是目前开源 Agent 框架中最完善的代码执行隔离方案。

当前局限：

DeerFlow 2.0 作为一个完全重写的新版本，仍然在快速迭代中，API 和配置格式可能会在版本间发生变化。对于不需要代码执行和深度研究能力的简单 Agent 场景，DeerFlow 的架构可能过于"重量级"。此外，其底层依赖 LangGraph 和 LangChain，如果这两个库出现破坏性更新，DeerFlow 也会受到影响。

6.4 适用场景判断指南

6.5 未来展望

从 DeerFlow 的发展轨迹和社区反馈来看，有几个值得关注的趋势：

Harness 成为标配：随着 AI Agent 从实验走向生产，"让 Agent 安全可控地运行"将不再是差异化优势，而是基本要求。DeerFlow 率先定义的 Harness 范式（沙箱 + Skill + 可观测性 + 中间件）很可能成为行业标准。

Skill 生态繁荣：Markdown 定义技能的方式极其友好，这为社区贡献技能降低了门槛。未来可能出现类似"Skill Marketplace"的生态，用户可以直接安装社区贡献的技能包。

从 Agent 到 Agent OS：DeerFlow 的架构越来越像一个"Agent 操作系统"——进程管理（Sub-Agent 编排）、文件系统（沙箱文件映射）、安全（Guardrails）、驱动（MCP 工具协议）。这个方向如果继续深化，DeerFlow 可能演化为真正的 Agent OS。

多模态 Agent：随着大模型多模态能力的增强，未来的 Agent 不仅处理文本和代码，还需要处理图片、视频、音频。DeerFlow 的 Vision Support 是一个起点，多模态 Agent 的执行环境将是下一个重要课题。

Agent 协作的"社会性"进化：当前的多智能体协作模式（无论是 DeerFlow 的任务委派还是 CrewAI 的角色扮演）还是比较初级的协作形式。未来可能出现更复杂的 Agent 协作模式——类似于人类社会的分工协作：Agent 之间能够进行谈判、交易、甚至组建临时的"Agent 公司"来完成复杂项目。DeerFlow 的 MCP 协议和 Skill 系统已经为这种跨 Agent 的能力共享奠定了基础。

Agent 安全与对齐的深化：随着 Agent 被赋予越来越多的实际操作权限（执行代码、访问数据库、操控浏览器），安全问题会从"最佳实践"升级为"硬性法规"。DeerFlow 的 Guardrails + Sandbox 模式是目前最务实的安全方案，但未来可能需要更形式化的安全证明——类似于操作系统领域的可信计算基（TCB）概念，确保 Agent 的行为在数学上可证明是安全的。

6.6 社区生态与贡献指南

DeerFlow 作为 MIT 协议开源项目，其社区生态正在快速发展。截至 2026 年第二季度，DeerFlow 已经拥有超过 70,000 GitHub Stars，数百位社区贡献者，以及日益丰富的第三方 Skill 和 MCP 工具生态。

对于希望参与贡献的开发者，有几个主要的切入点：

贡献 Skill：这是最低门槛的贡献方式。你只需要编写一个 SKILL.md 文件，描述某类任务的工作流程和最佳实践，就可以提交到 DeerFlow 的 Skill 仓库。例如，如果你擅长数据工程，可以编写一个 data-pipeline-design Skill，帮助 Agent 设计数据管道架构。

贡献 MCP Server：为 DeerFlow 适配更多的 MCP 工具服务器。比如，你可以为某个特定的 SaaS 产品（如 Notion、Jira、Figma）编写 MCP Server，让 Agent 能够直接操作这些工具。

贡献 Sub-Agent：开发专业化的 Sub-Agent，比如专门用于安全审计的 Security Sub-Agent、专门用于性能测试的 Performance Sub-Agent 等。

贡献核心代码：DeerFlow 的代码仓库结构清晰——backend/harness/ 是 Agent 框架核心，backend/app/ 是 FastAPI 应用层，frontend/ 是 Next.js 前端。项目有严格的导入规则（通过测试强制检查），确保 harness 层和 app 层之间的依赖方向是单向的。

本节要点：DeerFlow 在"超级智能体运行时"这一细分赛道上具备明显优势，特别适合需要安全代码执行和深度研究能力的生产场景。与 LangGraph 互补而非竞争，与 CrewAI 和 AutoGen 定位差异明显。Harness 范式和 Skill 生态是其最值得关注的前瞻性价值。

附录

附录 A：核心术语表

附录 B：关键端口与服务说明

附录 C：配置文件速查

附录 D：常用命令速查

# 克隆项目
git clone https://github.com/bytedance/deer-flow.git

# Docker 一键启动
make docker-start

# 本地开发启动
make dev

# 停止所有服务
make docker-stop

# 查看日志
make docker-logs

# 重新构建
make docker-build

# 运行测试
make test

附录 E：学习路线图

入门阶段
├── 1. 理解 AI Agent 基本概念（什么是 Agent、LLM、Tool Calling）
├── 2. 了解 LangChain 基础（Chain、Agent、Tool）
├── 3. 了解 LangGraph 基础（状态图、节点、边）
└── 4. Docker 一键部署 DeerFlow，运行第一个研究任务

进阶阶段
├── 5. 深入理解 DeerFlow 的四层架构和 Gateway-Worker 模式
├── 6. 学习 Skill 系统，编写自定义 Skill
├── 7. 配置 MCP 工具，扩展 Agent 的外部能力
├── 8. 理解 Sandbox 沙箱机制，掌握安全代码执行原理
└── 9. 使用 LangSmith 进行 Agent 行为分析和调试

高级阶段
├── 10. 自定义 Sub-Agent，实现专业化执行单元
├── 11. 编写自定义中间件，扩展执行链路
├── 12. 生产环境部署：高可用、安全加固、性能优化
├── 13. 阅读 DeerFlow 源码，理解核心实现
└── 14. 参与 DeerFlow 开源社区，贡献代码或 Skill

附录 F：参考资料

写在最后：DeerFlow 2.0 的意义不仅在于它是一个开源项目，更在于它定义了 AI Agent 从"玩具"走向"生产力工具"的工程范式。当行业还在争论"Agent 应该有多自主"时，DeerFlow 给出了一个务实的答案：让 Agent 像员工一样工作——有能力、有约束、有流程、可考核。 这或许就是 2026 年 AI Agent 最需要的东西。

如何从今天开始使用 DeerFlow

如果你读到这里已经跃跃欲试，以下是最精简的"三步上手"路径：

第一步：克隆并启动。 执行 git clone https://github.com/bytedance/deer-flow.git && cd deer-flow && make docker-start，三分钟后你就能在 http://localhost:3000 看到 DeerFlow 的 Web UI。

第二步：配置你的 LLM。 在 .env 文件中填入你的 OpenAI API Key（或其他支持的 LLM 提供商），在 config.yaml 中选择默认模型。建议从 GPT-4o 开始，它在 DeerFlow 的各类任务中表现最为稳定。

第三步：运行你的第一个深度研究任务。 在对话框中输入一个你真正关心的问题——比如"分析 2025-2026 年 AI Agent 框架的技术演进趋势"——然后观察 Lead Agent 制定计划、调度 Sub-Agent、在沙箱中执行代码、最终生成一份完整的研究报告。这个过程通常需要 5-15 分钟，取决于任务的复杂度和搜索深度。

当你完成了这三步，你就已经体验了 DeerFlow 最核心的价值。接下来，你可以开始探索 Skill 自定义、MCP 工具集成、以及生产环境部署——这些进阶内容在本文的前五个部分中都有详细讲解。

DeerFlow 的 GitHub 仓库地址是 https://github.com/bytedance/deer-flow ，社区正在快速增长，欢迎贡献你的 Skill、MCP Server 或核心代码。