DeerFlow 2.0 深度实战：字节跳动开源 SuperAgent 全栈框架——从 LangGraph 架构、沙箱隔离、子代理编排到生产级部署的完整指南（2026）

2026年2月28日，DeerFlow 2.0 发布当天登顶 GitHub Trending 榜首。这个来自字节跳动的开源项目，正在重新定义 AI Agent 的开发范式——它不再只是一个调用 API 的薄封装，而是一个真正的 SuperAgent Harness：把子代理、记忆系统、Docker 沙箱、可扩展技能链和 IM 渠道连接全部整合进一个统一的运行时。

一、背景：从 Deep Research 到 SuperAgent Harness 的演进

1.1 DeerFlow 的诞生与定位

DeerFlow（Deep Exploration and Efficient Research Flow）最初是字节跳动内部用于深度研究的框架。但它的社区演化远远超出了最初的设想。

上线之后，开发者拿它做的事情早已不止"研究"：搭建数据流水线、生成演示文稿、快速起 Dashboard、自动化内容流程……很多方向连团队自己都没预料到。

这促使核心团队意识到一个关键事实：

DeerFlow 不只是一个研究工具。它更像一个 harness（ harness 这里是"全套执行框架"的意思），一个真正让 Agents 把事情做完的运行时基础设施。

于是，2.0 来了——一次彻底的从头重写（ground-up rewrite），与 1.x 分支零代码共享。

1.2 为什么需要 SuperAgent Harness？

当前 AI Agent 开发面临几个核心痛点：

DeerFlow 2.0 的设计目标就是系统性地解决这些问题。

二、核心架构解析

2.1 技术栈概览

DeerFlow 2.0 技术栈
├── 语言层
│   ├── Python 3.12+   (Backend)
│   └── Node.js 22+    (Frontend + Build)
├── Agent 框架层
│   ├── LangGraph 1.0   (Agent 编排)
│   └── LangChain       (工具链、模型适配)
├── 运行时层
│   ├── Gateway API      (FastAPI / Uvicorn)
│   ├── RunManager      (运行状态管理)
│   └── Stream Bridge   (SSE 流式传输)
├── 执行层
│   ├── Local Sandbox   (宿主机执行)
│   ├── Docker Sandbox  (容器隔离)
│   └── K8s Sandbox    (Provisioner + Pod)
├── 存储层
│   ├── 长期记忆（向量存储）
│   └── 运行时状态（.deer-flow/）
└── 接入层
    ├── Web UI (React + TUI)
    └── IM Channels (Telegram/Slack/Feishu/WeCom/DingTalk)

2.2 LangGraph 驱动的 Agent 编排

DeerFlow 2.0 基于 LangGraph 1.0 重构，这是整个架构的核心决策。

LangGraph 提供了几个关键能力：

1. 有状态的图执行

# LangGraph 核心概念示意（非 DeerFlow 源码）
from langgraph.graph import StateGraph, END

class AgentState(TypedDict):
    messages: list
    plan: list
    current_step: int

workflow = StateGraph(AgentState)
workflow.add_node("planner", planner_node)
workflow.add_node("executor", executor_node)
workflow.add_node("reviewer", reviewer_node)

workflow.add_edge("planner", "executor")
workflow.add_conditional_edges(
    "executor",
    should_continue,
    {"continue": "executor", "review": "reviewer", "end": END}
)

2. 递归限制与可控执行

config.yaml 中的 recursion_limit 控制最大执行步数：

channels:
  session:
    assistant_id: lead_agent
    config:
      recursion_limit: 100  # 防止无限循环

3. Sub-Agent 路由

Lead Agent 可以通过 agent_name 路由到不同的专业子 Agent：

# 自定义 Agent 配置（概念示意）
agents:
  - name: code-agent
    system_prompt: "你是一个专注于代码生成的 Agent"
    tools: [bash, file_write, python_execute]
  - name: research-agent
    system_prompt: "你是一个专注于信息研究的 Agent"
    tools: [web_search, web_scrape, memory_read]

2.3 Gateway：统一 API 网关

DeerFlow 的 Gateway 是整个系统的枢纽，负责：

• LangGraph Compatible API (/api/langgraph/*)：兼容 LangGraph 生态工具
• RunManager：管理所有运行中的 Agent 任务
• Stream Bridge：SSE 流式传输，支持断点重连
• IM Channel 接入：统一处理来自各渠道的消息

客户端请求
    │
    ▼
┌─────────────────────────────┐
│        Nginx ( :2026)      │
│  统一入口，CORS 处理       │
└─────────────┬───────────────┘
              │
              ▼
┌─────────────────────────────┐
│     Gateway API ( :8001)   │
│  ┌─────────────────────┐   │
│  │    RunManager        │   │
│  │  (运行态、SSE桥)   │   │
│  └─────────────────────┘   │
│  ┌─────────────────────┐   │
│  │  LangGraph Runtime   │   │
│  │  (Agent 执行引擎)   │   │
│  └─────────────────────┘   │
└─────────────┬───────────────┘
              │
              ▼
┌─────────────────────────────┐
│      Sandbox / Tools        │
│  (Docker / Local / K8s)   │
└─────────────────────────────┘

⚠️ 重要设计约束：Gateway 将运行态（RunManager 和 Stream Bridge）保存在进程内，因此生产环境默认 GATEWAY_WORKERS=1。多 Worker 需要共享的跨 Worker Stream Bridge（尚未实现），否则会导致运行取消、SSE 重连、请求去重和 IM 渠道功能异常。

三、核心特性深度解析

3.1 Skills 系统：让 Agent 做"几乎任何事"

Skills 是 DeerFlow 能力的核心扩展机制。一个 Skill 本质上是一个结构化的 Markdown 文件（SKILL.md），定义了工作流、最佳实践和参考资源。

内置 Skills 结构：

/mnt/skills/public/
├── research/
│   └── SKILL.md          # 深度研究技能
├── report-generation/
│   └── SKILL.md          # 报告生成技能
├── slide-creation/
│   └── SKILL.md          # 演示文稿制作技能
├── web-page/
│   └── SKILL.md          # 网页生成技能
├── image-generation/
│   └── SKILL.md          # 图像生成技能
└── video-generation/
    └── SKILL.md          # 视频生成技能

自定义 Skill 示例：

创建 .agent/skills/code-review/SKILL.md：

---
name: code-review
version: 1.0
description: 深度代码审查技能，支持多种语言
compatiblity: deerflow >= 2.0
---

# Code Review Skill

## 工作流程

1. 接收代码片段或仓库 URL
2. 分析代码风格、潜在 Bug、性能问题
3. 检查安全漏洞（SQL 注入、XSS 等）
4. 生成结构化审查报告

## 最佳实践

- 先运行静态分析工具（pylint / eslint / go vet）
- 重点关注错误处理和边界条件
- 对性能关键路径给出优化建议

## 参考资料

- OWASP Top 10 2026
- Google Style Guides

Skills 的按需加载机制

DeerFlow 不会一次性把所有 Skills 加载进上下文，而是根据任务需求渐进式加载。这显著减少了 token 消耗，尤其是对于上下文窗口较小的模型。

3.2 Sub-Agents：复杂任务的分解与编排

DeerFlow 的 Lead Agent 可以将复杂任务分解为子任务，并委派给 Sub-Agents 执行。

Sub-Agent 的典型协作模式：

# 概念示意：Lead Agent 规划并委派子任务
# 实际由 LangGraph 驱动，无需手写此逻辑

lead_agent_plan = """
任务：分析竞品技术栈并生成对比报告

子任务分解：
1. [research-agent] 收集竞品公开技术信息
2. [code-agent] 分析竞品开源组件和架构
3. [report-agent] 整合分析结果，生成对比报告
"""

# 每个 Sub-Agent 独立运行，拥有自己的：
# - 工具集（Tools）
# - 上下文窗口（Context）
# - 沙箱环境（Sandbox）
# Lead Agent 负责聚合结果

Sub-Agent 的隔离性优势：

3.3 Sandbox：安全的代码执行环境

DeerFlow 支持三种沙箱模式，适应不同的安全需求和部署场景。

模式对比：

Docker 沙箱配置示例：

# config.yaml
sandbox:
  use: docker
  docker:
    image: deerflow/sandbox:latest
    network_mode: none      # 禁用网络（白名单方式开放）
    memory: 512m           # 单容器内存限制
    timeout: 300           # 执行超时（秒）
    allowed_hosts:          # 网络白名单
      - api.github.com
      - raw.githubusercontent.com

沙箱内的文件系统挂载：

Sandbox 容器内路径映射：
/mnt/workspace/     ←→ 宿主机 .deer-flow/workspaces/{run_id}/
/mnt/skills/public/ ←→ 项目根目录 skills/public/
/mnt/skills/custom/←→ 项目根目录 skills/custom/
/mnt/tmp/           ←→ 临时文件（容器销毁时自动清理）

3.4 长期记忆系统

DeerFlow 的记忆系统支持跨会话的信息持久化，让 Agent 能够"记住"之前的对话和任务结果。

记忆系统的核心设计：

# 概念架构（非源码）

class MemorySystem:
    """
    长期记忆系统架构
    - 向量存储：嵌入模型 + 向量数据库
    - 记忆检索：语义搜索 + 时间衰减
    - 记忆写入：异步、去重、摘要压缩
    """
    
    def store(self, content: str, metadata: dict):
        """存储记忆（异步）"""
        embedding = self.embedding_model.encode(content)
        self.vector_store.upsert(embedding, content, metadata)
    
    def retrieve(self, query: str, top_k: int = 5) -> list[str]:
        """检索相关记忆"""
        query_embedding = self.embedding_model.encode(query)
        results = self.vector_store.search(query_embedding, top_k)
        return [r["content"] for r in results]

记忆的使用场景：

1. 用户偏好记忆：记住用户的编码风格偏好、常用工具
2. 任务历史记忆：避免重复执行相同的调研任务
3. 错误经验记忆：记住之前的错误和解决方案

加载示例记忆数据（开发测试用）：

python scripts/load_memory_sample.py

这会将示例记忆复制到默认的本地运行时记忆文件，方便在 Settings > Memory 中测试记忆功能。

3.5 Context Engineering：精细控制上下文窗口

DeerFlow 2.0 引入了精细的上下文工程控制，通过 context 配置块管理：

channels:
  session:
    context:
      thinking_enabled: true    # 启用思考链（Reasoning）
      is_plan_mode: false      # 是否启用规划模式
      subagent_enabled: false  # 是否启用子代理
      max_context_tokens: 8000 # 上下文窗口上限

思考链（Thinking/Reasoning）支持：

对于支持推理的模型（如 Qwen3、DeepSeek R1），DeerFlow 会自动处理推理内容的解析和展示：

models:
  - name: qwen3-32b-vllm
    display_name: Qwen3 32B (vLLM)
    use: deerflow.models.vllm_provider:VllmChatModel
    model: Qwen/Qwen3-32B
    api_key: $VLLM_API_KEY
    base_url: http://localhost:8000/v1
    supports_thinking: true
    when_thinking_enabled:
      extra_body:
        chat_template_kwargs:
          enable_thinking: true

四、代码实战：从零部署到复杂任务执行

4.1 快速部署（Docker 方式）

环境要求：

• Docker 20.10+
• 4 vCPU / 8 GB RAM（最低）；推荐 8 vCPU / 16 GB RAM

部署步骤：

# 1. 克隆仓库
git clone https://github.com/bytedance/deer-flow.git
cd deer-flow

# 2. 运行交互式配置向导（推荐）
make setup
# 向导会引导你选择：
# - LLM Provider（OpenAI / DeepSeek / Doubao / 本地 vLLM）
# - Web 搜索 Provider（Tavily / InfoQuest / 无）
# - 沙箱模式（Local / Docker / Provisioner）
# - 安全选项（Bash 访问 / 文件写入）

# 3. 拉取沙箱镜像（Docker 模式需要）
make docker-init

# 4. 启动服务
make docker-start

# 5. 访问
# 浏览器打开 http://localhost:2026

配置向导生成的 config.yaml 示例：

# config.yaml（由 make setup 生成）
models:
  - name: doubao-seed-2.0-code
    display_name: Doubao Seed 2.0 Code
    use: langchain_openai:ChatOpenAI
    model: Doubao-Seeding-2.0-Code
    api_key: $DOUBAO_API_KEY
    base_url: https://ark.cn-beijing.volces.com/api/v3

  - name: deepseek-v3.2
    display_name: DeepSeek V3.2
    use: langchain_openai:ChatOpenAI
    model: deepseek-chat
    api_key: $DEEPSEEK_API_KEY
    base_url: https://api.deepseek.com/v1

sandbox:
  use: docker
  docker:
    image: deerflow/sandbox:latest
    network_mode: bridge

web_search:
  use: tavily
  api_key: $TAVILY_API_KEY

4.2 本地开发模式

如果你需要在本地修改 DeerFlow 源码，使用本地开发模式：

# 1. 检查依赖
make check
# 需要：Node.js 22+、pnpm、uv、nginx

# 2. 安装依赖
make install
# 安装 backend (Python uv) + frontend (Node.js pnpm)

# 3. 启动开发服务（支持热更新）
make dev

# 4. 访问 http://localhost:2026

make dev 启动的服务：

4.3 实战：用 DeerFlow 完成一个端到端的研究任务

任务描述：调研"2026 年云原生数据库技术趋势"，生成一份包含图表的结构化报告。

Step 1：通过 Web UI 提交任务

用户输入：
请帮我调研 2026 年云原生数据库技术趋势，重点包括：
1. 主要厂商和产品（MongoDB、CockroachDB、TiDB 等）
2. 核心技术趋势（存算分离、Serverless、AI 集成）
3. 性能基准对比
4. 未来展望

请生成一份结构化报告，包含图表。

Step 2：DeerFlow 的执行流程（内部）

Lead Agent 规划：
│
├── [research-agent] 子任务1：收集各产品官方文档和博客
│   ├── 调用 web_search("MongoDB 2026 new features")
│   ├── 调用 web_search("CockroachDB 2026 release")
│   ├── 调用 web_scrape("https://www.mongodb.com/docs/...")
│   └── 结果写入 /mnt/workspace/research_data.json
│
├── [research-agent] 子任务2：收集性能基准数据
│   ├── 调用 web_search("cloud native database benchmark 2026")
│   └── 结果追加到 research_data.json
│
├── [code-agent] 子任务3：生成对比图表
│   ├── Python 代码：用 matplotlib 生成对比柱状图
│   ├── 在 Sandbox 中执行 Python 代码
│   └── 图表保存到 /mnt/workspace/comparison.png
│
└── [report-agent] 子任务4：生成最终报告
    ├── 读取 research_data.json
    ├── 嵌入 comparison.png
    └── 输出 Markdown 格式报告

Step 3：查看执行结果

在 Web UI 的对话界面中，可以看到：

• 每个子任务的执行状态
• 工具调用的详细日志
• 中间结果（可在 Sandbox 文件系统中查看）
• 最终生成的报告

4.4 Claude Code 集成实战

DeerFlow 提供了 claude-to-deerflow Skill，让你可以在 Claude Code 中直接操控 DeerFlow 实例。

安装方式：

npx skills add https://github.com/bytedance/deer-flow \
  --skill claude-to-deerflow

在 Claude Code 中使用：

Claude Code 会话：

> /claude-to-deerflow

🔗 已连接到 DeerFlow (http://localhost:2026)

> 帮我研究一下 Rust 在 2026 年的生态发展情况，重点看 WebAssembly、异步运行时和嵌入式三个方向

[DeerFlow 正在执行...]
[子任务1：研究 Rust + WASM 2026]
[子任务2：研究 Rust 异步运行时（Tokio/async-std）]
[子任务3：研究 Rust 嵌入式生态]
[生成报告...]

✅ 研究完成！报告已保存到 /workspace/rust-ecosystem-2026.md

五、生产部署与性能优化

5.1 生产部署架构建议

推荐的生产部署拓扑：

                    ┌─────────────────────────────────┐
                    │        Load Balancer             │
                    │      (可选，多实例场景)          │
                    └──────────────┬──────────────────┘
                                   │
                    ┌──────────────▼──────────────────┐
                    │     DeerFlow Gateway             │
                    │     (单 Worker，无状态外置)      │
                    │     GATEWAY_WORKERS=1           │
                    └──────────────┬──────────────────┘
                                   │
              ┌────────────────────┼────────────────────┐
              │                    │                    │
    ┌─────────▼─────────┐ ┌─────▼──────┐ ┌─────────▼─────────┐
    │  Sandbox Cluster    │ │  Vector DB  │ │  Redis (可选)     │
    │  (Docker/K8s)     │ │  (记忆)     │ │  (分布式状态)     │
    └─────────────────────┘ └─────────────┘ └────────────────────┘

关键配置参数：

# config.yaml (生产环境)
gateway:
  workers: 1              # 单 Worker（进程内状态）
  cors_origins: ""        # 同源部署可不配置，或填写前端域名
  stream_timeout: 300      # SSE 流式超时（秒）

sandbox:
  use: docker
  docker:
    image: deerflow/sandbox:latest
    memory: 1g             # 单容器内存上限
    timeout: 600           # 执行超时
    max_concurrent: 5      # 最大并发沙箱容器数

# 如果使用外部 LLM API，注意并发限制
models:
  - name: prod-model
    # ... 模型配置
    max_concurrent_requests: 10  # 控制并发请求数

5.2 性能优化清单

1. 模型层优化

models:
  - name: fast-model
    # 使用响应速度快的模型处理简单任务
    use: langchain_openai:ChatOpenAI
    model: gpt-4o-mini  # 或 doubao-lite
    
  - name: smart-model
    # 使用能力强的模型处理复杂任务
    use: langchain_openai:ChatOpenAI
    model: gpt-4o
    # Lead Agent 用强模型，Sub-Agents 用快模型

2. 上下文窗口优化

# 在 Skill 中控制上下文大小
# 避免把大文件直接塞进上下文

# ❌ 不推荐
with open("large_file.csv") as f:
    content = f.read()  # 可能几千行
    agent.chat(f"分析这个文件：\n{content}")

# ✅ 推荐
# 先用代码处理，只传摘要/统计结果
import pandas as pd
df = pd.read_csv("large_file.csv")
summary = df.describe().to_string()
agent.chat(f"这个数据集的统计摘要：\n{summary}\n请告诉我需要重点分析哪些列")

3. 沙箱资源限制

# 防止单个任务耗尽资源
sandbox:
  docker:
    memory: 512m        # 单容器内存
    cpu_quota: 50000    # CPU 配额（微秒/100000）
    timeout: 300         # 执行超时
    max_concurrent: 3    # 全局并发限制

4. 记忆系统优化

# 定期压缩/归档旧记忆
# 避免向量检索变慢

from deerflow.memory import MemoryManager

memory = MemoryManager()
# 获取记忆统计
stats = memory.get_stats()
print(f"记忆总数：{stats['total_memories']}")
print(f"存储大小：{stats['storage_size_mb']} MB")

# 归档 30 天前的低重要性记忆
memory.archive_old_memories(days=30, min_importance=0.3)

5.3 可观测性：LangSmith 集成

DeerFlow 内置 LangSmith 集成，用于追踪所有 LLM 调用和 Agent 运行。

.env 配置：

LANGSMITH_TRACING=true
LANGSMITH_ENDPOINT=https://api.smith.langchain.com
LANGSMITH_API_KEY=lsv2_pt_xxxxxxxxxxxxxxxx
LANGSMITH_PROJECT=deerflow-prod

LangSmith 仪表盘可以看到：

• 每次 LLM 调用的延迟、token 消耗、费用
• Agent 执行的完整链路（哪个节点调用了哪个工具）
• 错误堆栈和调试信息

六、IM 渠道集成：让 Agent 无处不在

DeerFlow 支持从多种即时通讯应用接收任务，且不需要公网 IP（全部使用长轮询或 WebSocket 长连接）。

6.1 支持的渠道

6.2 Telegram 集成实战

Step 1：创建 Bot

1. 在 Telegram 中打开 @BotFather
2. 发送 /newbot
3. 按提示设置 Bot 名称和用户名
4. 复制生成的 HTTP API Token（格式：123456789:ABCdefGHIjklMNOpqrSTUvwxYZ）

Step 2：配置 DeerFlow

在 .env 中设置：

TELEGRAM_BOT_TOKEN=123456789:ABCdefGHIjklMNOpqrSTUvwxYZ

在 config.yaml 中启用：

channels:
  telegram:
    enabled: true
    bot_token: $TELEGRAM_BOT_TOKEN
    allowed_users: []   # 留空允许所有人；或填写 Telegram User ID 列表

Step 3：与 Bot 交互

在 Telegram 中：

/new
开启新对话

帮我调研一下 Go 1.24 的 Swiss Table 特性，生成一份技术分析报告

[DeerFlow 正在处理...]
[约 2-5 分钟后]

✅ 报告生成完成！
标题：Go 1.24 Swiss Table 深度分析
内容已保存到：/workspace/go124-swiss-table.md

你可以下载完整报告，也可以让我继续修改。

6.3 企业微信集成（国内企业场景）

企业微信的智能机器人支持文本、图片和文件消息，且 Agent 生成的最终图片/文件可以回传到企业微信会话。

.env 配置：

WECOM_BOT_ID=your_bot_id
WECOM_BOT_SECRET=your_bot_secret

config.yaml：

channels:
  wecom:
    enabled: true
    bot_id: $WECOM_BOT_ID
    bot_secret: $WECOM_BOT_SECRET

企业微信渠道通过 WebSocket 长连接接收消息，无需公网回调地址，适合内网部署场景。

七、MCP Server 集成：无限扩展工具链

DeerFlow 支持通过 MCP（Model Context Protocol）Server 扩展工具链。

7.1 配置 MCP Server

在 config.yaml 中配置：

mcp_servers:
  - name: filesystem
    transport: stdio
    command: ["npx", "-y", "@modelcontextprotocol/server-filesystem", "/allowed/path"]
    
  - name: fetch
    transport: stdio
    command: ["npx", "-y", "@modelcontextprotocol/server-fetch"]
    
  - name: remote-api
    transport: http
    url: https://api.example.com/mcp
    # 支持 OAuth token flows（client_credentials、refresh_token）

7.2 HTTP/SSE MCP Server 的 OAuth 支持

对于需要认证的远程 MCP Server：

mcp_servers:
  - name: authenticated-api
    transport: http
    url: https://api.example.com/mcp
    oauth:
      grant_type: client_credentials
      token_url: https://api.example.com/oauth/token
      client_id: $MCP_CLIENT_ID
      client_secret: $MCP_CLIENT_SECRET
      scope: "tools:read"

八、DeerFlow 与同类项目对比

九、迁移与升级

9.1 从 1.x 迁移到 2.0

DeerFlow 2.0 是彻底重写，与 1.x 不共享代码。如果你正在使用 1.x（原 Deep Research 框架）：

• 1.x 分支（main-1.x）继续维护，欢迎贡献
• 主要开发已转向 2.0
• 没有自动迁移工具，需要重新部署

9.2 配置文件迁移

1.x 的 config.yaml 示例：

# 1.x 格式（已废弃）
llm:
  provider: openai
  model: gpt-4o

2.0 的 config.yaml 示例：

# 2.0 格式
models:
  - name: gpt-4o
    display_name: GPT-4o
    use: langchain_openai:ChatOpenAI
    model: gpt-4o
    api_key: $OPENAI_API_KEY

使用 make setup 向导可以自动生成 2.0 格式的配置，无需手动迁移。

十、总结与展望

10.1 DeerFlow 2.0 的核心价值

1. 开箱即用的 SuperAgent 运行时：不是框架，是可直接部署运行的完整系统
2. 生产级安全隔离：Docker/K8s 沙箱，代码执行默认隔离
3. 可扩展的技能体系：Markdown 技能包，低门槛扩展能力
4. 多渠道无缝接入：6+ IM 渠道，无需公网 IP
5. 完整的可观测性：LangSmith 集成，全链路追踪

10.2 适用场景

• 技术研究自动化：替代人工调研，自动生成技术报告
• 内容生成流水线：报告、演示文稿、网页的自动化生产
• 代码辅助：结合 Claude Code，实现研究→编码→测试的闭环
• 企业知识助手：接入企业微信/钉钉，打造内部技术助手
• 教育培训：自动生成学习材料和代码示例

10.3 未来展望

根据 DeerFlow 的路线图和社区讨论，值得关注的未来方向：

1. 多 Worker 支持：解决 Gateway 单 Worker 限制，支持水平扩展
2. 更多内置 Skills：社区驱动的技能包生态
3. 更强的 Planning 能力：集成 Tree Search、Monte Carlo 等高级规划算法
4. 多模态支持增强：更好的图像/视频生成和 understanding 能力
5. 企业级特性：SSO、权限管理、审计日志

参考资源

• 官方 GitHub：https://github.com/bytedance/deer-flow
• 官方网站：https://deerflow.tech
• 中文文档：https://www.deerflow.one
• LangGraph 文档：https://langchain-ai.github.io/langgraph/
• InfoQuest（智能搜索工具）：https://docs.byteplus.com/en/docs/InfoQuest/What_is_Info_Quest
• 字节跳动火山引擎 Coding Plan：https://www.volcengine.com/activity/codingplan

本文基于 DeerFlow 2.0（2026年2月发布）撰写，代码示例为概念示意，具体实现请参考官方文档和源码。

作者备注：DeerFlow 项目在 GitHub Trending 登顶，体现了开发者对"真正能跑完复杂任务的 Agent 框架"的强烈需求。字节跳动这次开源的贡献，不仅在于代码本身，更在于为社区提供了一个可扩展、可部署、可观测的 SuperAgent 完整参考实现。