DeerFlow 2.0 深度拆解：当字节跳动决定「给 AI 造一台带沙箱的电脑」——从 LangGraph 图引擎到 Docker 隔离执行，一个 70K Star 的超级智能体框架如何用「Lead Agent + Sub-Agent」架构重新定义复杂任务自动化的终极形态

一、引言：为什么你的 AI Agent 总是「半途而废」？

2023 年 AutoGPT 横空出世，让人们第一次见识到 AI Agent 的潜力——一个能自主规划、执行任务的智能系统。然而两年过去，绝大多数 Agent 框架依然停留在「能聊天但不能做事」的阶段。核心痛点只有一个：AI 没有一台属于自己的「电脑」。

传统 Agent 框架的困境可以归结为四个字：说而不做。你让它分析一份 CSV 文件，它给你生成一段 Python 代码，然后……没了。你让它搭建一个 Web 应用，它写了一堆代码，但没有地方运行。更糟糕的是，当任务复杂度上升，Agent 会在长对话中「失忆」——早期的关键信息被淹没在上下文窗口里，任务执行到中途就偏离了初始目标。

2026 年 2 月 28 日，字节跳动开源了 DeerFlow 2.0，一个彻底重写的超级智能体框架。它不是又一个聊天机器人套壳，而是一个真正能让 AI「动手做事」的运行时基础设施。上线一周即登顶 GitHub Trending，目前 Star 数突破 70K。

本文将从架构设计、核心原理、代码实战三个维度，深入拆解 DeerFlow 2.0 如何用「Lead Agent + Sub-Agent + Docker Sandbox」的三层架构，解决 Agent 开发中最棘手的执行、记忆和安全问题。

二、DeerFlow 2.0 是什么？——从研究工具到超级智能体的蜕变

2.1 项目定位

DeerFlow（Deep Exploration and Efficient Research Flow）的定位不是又一个 Agent 框架，而是一个 SuperAgent Harness（超级智能体装备系统）。打个比方：如果 LangChain 是引擎，DeerFlow 就是整辆车——带方向盘、带刹车、带安全气囊，甚至带了一台笔记本电脑在副驾驶座上。

核心理念极其简洁：给 AI 一台带沙箱的「电脑」，让它自己完成从研究到执行的完整项目。

2.2 版本演进

关键信息：DeerFlow 2.0 与 v1 版本没有共用一行代码。这不是增量升级，而是一次从零开始的彻底重写。

2.3 核心特性一览

DeerFlow 2.0 通过六个核心组件支撑其超级智能体的运行：

三、架构深度剖析：四层分离的「全栈智能体」

3.1 整体架构

DeerFlow 2.0 采用经典的四层分离架构，从上到下依次为接入层、网关层、运行时层和执行层：

┌─────────────────────────────────────────────────────────────┐
│                    接入层（Access Layer）                     │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐   │
│  │ Web UI   │  │ Telegram │  │  Slack   │  │  飞书    │   │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘   │
└───────┼─────────────┼─────────────┼─────────────┼──────────┘
        └─────────────┴──────┬──────┴─────────────┘
                             ▼
┌─────────────────────────────────────────────────────────────┐
│                    网关层（Gateway Layer）                    │
│            nginx 反向代理（2026 端口）                        │
│  ┌──────────────────────────────────────────────────────┐   │
│  │              FastAPI Gateway API                      │   │
│  │  - 文件上传/下载  - 技能管理  - 记忆查询  - 配置管理  │   │
│  └──────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘
                             ▼
┌─────────────────────────────────────────────────────────────┐
│                  运行时层（Runtime Layer）                    │
│              LangGraph Server + LangChain                   │
│  ┌──────────────────────────────────────────────────────┐   │
│  │                    Lead Agent                         │   │
│  │     - 任务规划    - 子代理调度    - 结果整合          │   │
│  └──────────────────────────────────────────────────────┘   │
│         │                │                │                  │
│         ▼                ▼                ▼                  │
│  ┌──────────────┐ ┌──────────────┐ ┌──────────────┐        │
│  │ Sub-Agent 1  │ │ Sub-Agent 2  │ │ Sub-Agent N  │        │
│  │  (专项任务)  │ │  (专项任务)  │ │  (专项任务)  │        │
│  └──────────────┘ └──────────────┘ └──────────────┘        │
└─────────────────────────────────────────────────────────────┘
                             ▼
┌─────────────────────────────────────────────────────────────┐
│                  执行层（Execution Layer）                   │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │   Sandbox    │  │    Tools     │  │    Skills    │      │
│  │   (Docker)   │  │ (MCP/内置)   │  │  (Markdown)  │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
└─────────────────────────────────────────────────────────────┘

这种分层设计的核心优势是各组件独立演进。你可以替换底层的 Docker 沙箱为 Kubernetes Pod，而不影响上层的 Lead Agent 逻辑；你可以把前端从 Web UI 换成移动端 App，而不需要改动后端任何代码。

3.2 Lead Agent：超级智能体的「大脑」

Lead Agent 是 DeerFlow 的决策中枢，它的设计体现了几个关键考量：

任务分解算法：采用基于 LLM 的动态任务分解策略，根据任务复杂度自动决定是否启用子代理。简单任务（如「帮我搜索 XX」）直接由 Lead Agent 完成；复杂任务（如「研究 2026 年 AI Agent 发展趋势并生成报告」）则分解为多个子任务并行执行。

上下文管理：实现了创新的「记忆压缩」技术，将长对话中的关键信息提取为结构化摘要。这不是简单的截断，而是语义级别的信息蒸馏——保留关键决策、丢弃冗余细节。

错误恢复机制：当子代理执行失败时，Lead Agent 能够自动尝试替代方案或调整任务分解策略。比如某个搜索 API 返回错误，它会自动切换到备选搜索引擎。

3.3 Sub-Agent：并行执行的「工人军团」

DeerFlow 的子代理系统是其性能优势的核心来源。每个子代理都在独立的上下文中运行：

# 伪代码示例：子代理创建与执行
sub_agent = create_sub_agent(
    task="搜索关于 AI Agent 的最新研究进展",
    tools=["web_search", "fetch_webpage"],
    context_isolation=True,  # 上下文隔离
    max_iterations=10
)
result = await sub_agent.run()

上下文隔离机制带来两个关键好处：

1. 专注性：子代理只聚焦当前子任务，不被无关信息干扰
2. 安全性：子代理的错误不会影响主代理或其他子代理

性能提升：通过并行执行，DeerFlow 的任务处理效率相比串行执行提升 3-5 倍。

四、核心原理深入：五大技术亮点

4.1 Docker 沙箱：给 AI 一台真正的「电脑」

这是 DeerFlow 最核心的创新。它不只是「会说它能做」，而是真的有一台自己的「电脑」。

┌─────────────────────────────────────────────────────────┐
│                    Host Machine                         │
│  ┌─────────────────────────────────────────────────┐   │
│  │           DeerFlow Core Runtime                  │   │
│  │  ┌─────────────┐  ┌─────────────┐  ┌────────┐  │   │
│  │  │ Lead Agent  │  │ Sub-Agent 1 │  │Sub-Agt │  │   │
│  │  │   (规划)    │  │   (执行A)   │  │(执行B) │  │   │
│  │  └──────┬──────┘  └──────┬──────┘  └───┬────┘  │   │
│  │         └────────────────┴─────────────┘        │   │
│  │                      │                          │   │
│  │              ┌───────┴───────┐                  │   │
│  │              │ Sandbox       │                  │   │
│  │              │ Manager       │                  │   │
│  │              └───────┬───────┘                  │   │
│  └──────────────────────┼──────────────────────────┘   │
│                         │                              │
│                 ┌───────┴───────┐                      │
│                 │  Docker API   │                      │
│                 └───────┬───────┘                      │
│                         │                              │
│         ┌───────────────┼───────────────┐              │
│         ▼               ▼               ▼              │
│  ┌─────────┐     ┌─────────┐     ┌─────────┐          │
│  │Container│     │Container│     │Container│          │
│  │   #1    │     │   #2    │     │   #3    │          │
│  │(Task A) │     │(Task B) │     │(Task C) │          │
│  └─────────┘     └─────────┘     └─────────┘          │
└─────────────────────────────────────────────────────────┘

每个 Docker 容器内都有完整的文件系统：

/mnt/user-data/
├── uploads/       ← 用户上传的文件
├── workspace/     ← Agent 的工作目录
├── outputs/       ← 最终交付物
└── skills/        ← 技能文件（只读挂载）

安全特性：

• 资源隔离（CPU/内存/网络限制）
• 状态快照与恢复
• 安全监控与异常检测
• 不同 Session 之间完全隔离

配置示例：

# config.yaml
sandbox:
  use: deerflow.docker_sandbox:DockerSandboxProvider
  resources:
    cpu_limit: "2.0"
    memory_limit: "4g"
    network_mode: "bridge"
    timeout: 300  # 5 分钟超时

4.2 分层记忆系统：模仿人类的记忆机制

DeerFlow 的记忆系统模仿人类记忆的分层机制：

上下文工程是 DeerFlow 的核心竞争力之一：

class ContextManager:
    def __init__(self):
        self.memory = VectorStoreMemory()  # 向量化记忆存储
        self.context = ContextWindow(
            max_tokens=8192,
            compression_strategy="semantic"  # 语义压缩
        )
    
    async def compress_context(self, messages: list) -> list:
        """
        语义压缩策略：
        1. 自动总结已完成的子任务
        2. 将中间结果转存到文件系统
        3. 压缩暂时不重要的信息
        4. 按需加载技能文档
        """
        compressed = []
        for msg in messages:
            if self._is_key_decision(msg):
                compressed.append(msg)  # 保留关键决策
            elif self._is_intermediate_result(msg):
                self._archive_to_filesystem(msg)  # 转存到文件系统
            else:
                summary = self._summarize(msg)  # 语义摘要
                compressed.append(summary)
        return compressed

这种设计确保在长链路、多步骤任务中，上下文窗口始终保持「干净」，不会因为累积过多历史信息而影响性能。

4.3 Skills 技能系统：用 Markdown 定义「能力」

Skills 是 DeerFlow 能做「几乎任何事」的关键。它采用「Skill 元数据注入提示词 + LLM 按需读取 SKILL.md + 沙箱 Terminal 指令调用工具」的模式。

Skill 文件结构：

---
name: research
version: 1.0.0
author: DeerFlow Team
description: 深度研究技能，支持多角度资料搜集和分析
---

# 研究技能

## 工作流

1. 明确研究主题和目标
2. 使用 web_search 工具搜集资料
3. 使用 fetch_webpage 工具获取详细内容
4. 分析整理信息
5. 生成研究报告

## 最佳实践

- 每次搜索使用不同的关键词组合
- 验证信息来源的可靠性
- 交叉验证关键数据点

Skill 发现与加载机制：

# 1. 扫描目录
skills = scan_skills_directory("skills/public")

# 2. 解析元数据
for skill_file in skills:
    metadata = parse_yaml_frontmatter(skill_file)
    skill = Skill(
        name=metadata["name"],
        description=metadata["description"],
        version=metadata["version"],
        path=skill_file
    )
    register_skill(skill)

# 3. 注入提示词
enabled_skills = get_enabled_skills()
prompt = generate_prompt_with_skills(enabled_skills)

设计优势：

• 声明式工作流：技能作为文档而非硬编码流程
• 按需加载：节省上下文长度，提高效率
• 渐进式扩展：可以动态添加、替换技能
• 版本管理：支持技能版本控制和兼容性检查

4.4 MCP 协议集成：AI 领域的「USB-C」

DeerFlow 完整支持 MCP（Model Context Protocol）协议，这是 Anthropic 开源的 AI 工具调用标准，被誉为 AI 领域的「USB-C 接口」。

配置示例：

# config.yaml
mcp_servers:
  - name: filesystem
    transport: stdio
    command: npx
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/files"]
    
  - name: github
    transport: sse
    url: https://api.github.com/mcp/sse
    headers:
      Authorization: Bearer $GITHUB_TOKEN
    
  - name: database
    transport: sse
    url: http://localhost:8001/mcp
    env:
      DB_HOST: localhost
      DB_PORT: 5432

MCP 的核心价值在于标准化——无论底层是什么工具，只要实现了 MCP Server，就能无缝接入 DeerFlow 生态。

4.5 多渠道接入：统一的消息网关

DeerFlow 支持从多种 IM 渠道接收任务，真正实现了「随时随地」的 AI 助手体验：

# Telegram 配置
channels:
  telegram:
    enabled: true
    bot_token: $TELEGRAM_BOT_TOKEN
    allowed_users: []

# 飞书配置
channels:
  feishu:
    enabled: true
    app_id: $FEISHU_APP_ID
    app_secret: $FEISHU_APP_SECRET

# Slack 配置
channels:
  slack:
    enabled: true
    bot_token: $SLACK_BOT_TOKEN
    app_token: $SLACK_APP_TOKEN

五、代码实战：从零搭建你的超级智能体

5.1 环境准备

# 硬件要求
# CPU: 4 核及以上
# 内存: 8GB 及以上（推荐 16GB）
# 磁盘: 20GB 可用空间

# 安装 Docker
curl -fsSL https://get.docker.com | sh

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

# 生成配置文件
make config

5.2 配置模型

编辑 config.yaml，至少配置一个模型：

models:
  - name: gpt-4
    display_name: GPT-4
    use: langchain_openai:ChatOpenAI
    model: gpt-4
    api_key: $OPENAI_API_KEY
    max_tokens: 4096
    temperature: 0.7
    
  - name: deepseek-v3
    display_name: DeepSeek V3
    use: langchain_openai:ChatOpenAI
    model: deepseek-chat
    api_key: $DEEPSEEK_API_KEY
    base_url: https://api.deepseek.com/v1
    
  - name: qwen-max
    display_name: Qwen Max
    use: langchain_openai:ChatOpenAI
    model: qwen-max
    api_key: $DASHSCOPE_API_KEY
    base_url: https://dashscope.aliyuncs.com/compatible-mode/v1

5.3 启动服务

# 首次运行：拉取沙箱镜像
make docker-init

# 启动所有服务
make docker-start

# 访问界面
open http://localhost:2026

5.4 编写自定义 Skill

创建一个自定义数据分析技能：

---
name: data-analysis
version: 1.0.0
author: Your Name
description: 数据分析技能，支持 CSV/Excel 文件的清洗、分析和可视化
---

# 数据分析技能

## 工作流

1. 接收用户上传的数据文件
2. 分析数据结构和质量
3. 执行数据清洗
4. 进行统计分析
5. 生成可视化图表
6. 输出分析报告

## 工具依赖

- pandas: 数据处理
- matplotlib/seaborn: 数据可视化
- openpyxl: Excel 文件读写

## 代码模板

```python
import pandas as pd
import matplotlib.pyplot as plt

def analyze_data(file_path: str) -> dict:
    # 读取数据
    df = pd.read_csv(file_path)
    
    # 基础统计
    stats = {
        "rows": len(df),
        "columns": len(df.columns),
        "missing_values": df.isnull().sum().to_dict(),
        "dtypes": df.dtypes.astype(str).to_dict()
    }
    
    return stats

输出格式

分析报告应包含：

• 数据概览（行数、列数、数据类型）
• 缺失值分析
• 关键指标统计
• 可视化图表
• 结论与建议

### 5.5 实际使用示例

通过 Web UI 发送任务：

用户：研究 2026 年主流 AI Agent 框架的技术架构差异，重点关注
LangGraph、CrewAI 和 AutoGPT 三个框架，生成一份对比分析报告，
包含架构图和性能基准数据。

DeerFlow 的执行流程：

1. **Lead Agent 分析任务** → 分解为 4 个子任务
2. **创建子代理并行执行**：
   - Sub-Agent 1: 搜集 LangGraph 架构信息
   - Sub-Agent 2: 搜集 CrewAI 架构信息
   - Sub-Agent 3: 搜集 AutoGPT 架构信息
   - Sub-Agent 4: 搜集性能基准数据
3. **子代理调用工具** → web_search、fetch_webpage
4. **子代理在沙箱中处理数据** → 生成中间文件
5. **Lead Agent 整合结果** → 调用 report-generation Skill
6. **生成最终报告** → 保存到 outputs 目录
7. **返回给用户** → 含报告下载链接

## 六、性能优化与生产部署

### 6.1 性能调优策略

**上下文压缩**：对于长任务，启用语义压缩避免上下文窗口溢出：

```yaml
context:
  compression:
    enabled: true
    strategy: semantic  # 语义压缩
    threshold: 0.7      # 相似度阈值
    max_history: 50     # 最大保留消息数

子代理并发控制：根据任务复杂度动态调整并行度：

# 动态并发控制
concurrency_config = {
    "simple_task": 1,      # 简单任务：单线程
    "medium_task": 3,      # 中等任务：3 个子代理
    "complex_task": 5,     # 复杂任务：5 个子代理
    "max_concurrent": 10   # 最大并发数
}

沙箱资源优化：

sandbox:
  resources:
    cpu_limit: "4.0"        # 4 核 CPU
    memory_limit: "8g"      # 8GB 内存
    timeout: 600            # 10 分钟超时
    max_containers: 20      # 最大容器数

6.2 生产环境部署

Docker Compose 生产模式：

# docker-compose.prod.yml
version: '3.8'

services:
  deerflow:
    image: deerflow/deerflow:latest
    ports:
      - "2026:2026"
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - DEEPSEEK_API_KEY=${DEEPSEEK_API_KEY}
    volumes:
      - ./config.yaml:/app/config.yaml
      - ./data:/app/data
    deploy:
      resources:
        limits:
          cpus: '4'
          memory: 8G
    
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./certs:/etc/nginx/certs
    depends_on:
      - deerflow

Kubernetes 部署：

# k8s/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: deerflow
spec:
  replicas: 3
  selector:
    matchLabels:
      app: deerflow
  template:
    metadata:
      labels:
        app: deerflow
    spec:
      containers:
      - name: deerflow
        image: deerflow/deerflow:latest
        ports:
        - containerPort: 2026
        resources:
          requests:
            memory: "4Gi"
            cpu: "2"
          limits:
            memory: "8Gi"
            cpu: "4"
        env:
        - name: OPENAI_API_KEY
          valueFrom:
            secretKeyRef:
              name: deerflow-secrets
              key: openai-api-key

6.3 监控与可观测性

集成 Prometheus + Grafana 监控：

# metrics.py
from prometheus_client import Counter, Histogram, Gauge

# 定义指标
task_counter = Counter('deerflow_tasks_total', 'Total tasks processed', ['status'])
task_duration = Histogram('deerflow_task_duration_seconds', 'Task execution duration')
active_agents = Gauge('deerflow_active_agents', 'Number of active agents')

# 在 Lead Agent 中埋点
async def execute_task(task):
    with task_duration.time():
        try:
            result = await lead_agent.run(task)
            task_counter.labels(status='success').inc()
            return result
        except Exception as e:
            task_counter.labels(status='failure').inc()
            raise

七、竞品对比：DeerFlow 凭什么脱颖而出？

7.1 全面对比

7.2 关键差异分析

vs OpenAI Deep Research：DeerFlow 的核心优势是数据主权——所有数据完全本地存储，不经过任何第三方服务器。对于企业用户来说，这是不可妥协的底线。

vs AutoGPT：DeerFlow 基于 LangGraph 架构清晰，Docker 沙箱提供完整隔离。AutoGPT 虽然早期热门，但架构复杂且缺乏生产级安全保障。

vs CrewAI：CrewAI 擅长角色扮演和团队模拟场景，但在复杂长任务和代码执行方面不如 DeerFlow。DeerFlow 的 Docker 沙箱是其不可替代的护城河。

vs LangChain：DeerFlow 实际上是基于 LangChain 构建的上层应用。如果你需要快速搭建 AI Agent 应用，选 DeerFlow；如果你需要深度定制底层逻辑，选 LangChain。

八、实战案例：用 DeerFlow 搭建企业级研究系统

8.1 场景：竞品分析自动化

某互联网公司需要每周生成一份竞品分析报告，涉及 10+ 个竞品的产品动态、技术架构变化、用户反馈等信息。

传统方式：2-3 个研究员花费 2-3 天手动搜集和整理信息。

DeerFlow 方式：

# research-workflow.yaml
name: weekly-competitor-analysis
description: 每周竞品分析自动化工作流

workflow:
  - step: collect_news
    agent: news_collector
    tools: [web_search, rss_reader]
    parallel: true
    targets:
      - "竞品A 动态"
      - "竞品B 动态"
      - "竞品C 动态"
      
  - step: analyze_tech
    agent: tech_analyst
    tools: [github_search, tech_radar]
    depends_on: collect_news
    
  - step: gather_feedback
    agent: feedback_collector
    tools: [app_store_scraper, social_monitor]
    depends_on: collect_news
    
  - step: generate_report
    agent: report_writer
    tools: [template_engine, chart_generator]
    depends_on: [analyze_tech, gather_feedback]
    output: weekly_report.pdf

执行结果：

• 耗时：约 30 分钟（传统方式 2-3 天）
• 成本：仅模型 API 费用（约 $0.5/次）
• 准确率：95%+（交叉验证机制保障）

8.2 场景：技术文档自动生成

# 自动化技术文档生成
from deerflow.client import DeerFlowClient

client = DeerFlowClient()

# 任务：分析 GitHub 仓库并生成技术文档
response = client.chat(
    """
    分析 https://github.com/bytedance/deer-flow 这个仓库：
    1. 分析项目架构和核心模块
    2. 生成 API 文档
    3. 编写开发者指南
    4. 制作架构图
    输出为完整的 Markdown 文档集。
    """,
    thread_id="doc-gen-001",
    context={
        "thinking_enabled": True,
        "subagent_enabled": True
    }
)

# 结果保存在 /mnt/user-data/outputs/
# 包含：架构分析.md, API文档.md, 开发者指南.md, 架构图.svg

九、常见问题与解决方案

9.1 部署问题

问题：Docker 启动失败

# 检查 Docker 状态
sudo systemctl status docker

# 拉取沙箱镜像
make docker-init

# 查看日志
docker-compose logs -f

问题：端口冲突

# 检查端口占用
lsof -i :2026

# 修改 config.yaml 中的端口
server:
  port: 2027  # 改为其他端口

9.2 性能问题

问题：长任务执行超时

# 调整超时时间
sandbox:
  resources:
    timeout: 1200  # 20 分钟

问题：内存不足

# 监控资源使用
docker stats

# 增加 Docker 内存限制
# Docker Desktop -> Settings -> Resources -> Memory: 8GB

9.3 模型相关问题

问题：API 调用失败

# 配置多个模型作为备选
models:
  - name: primary
    model: gpt-4
    api_key: $OPENAI_API_KEY
    
  - name: fallback
    model: deepseek-v3
    api_key: $DEEPSEEK_API_KEY
    base_url: https://api.deepseek.com/v1

# Lead Agent 会自动在主模型失败时切换到备选模型

十、总结与展望

DeerFlow 2.0 的出现标志着 AI Agent 开发进入了一个新阶段：从「能聊天」到「能做事」，从「单线程」到「并行执行」，从「裸奔」到「沙箱隔离」。

核心价值总结：

1. 真正的执行能力：Docker 沙箱让 AI 拥有了属于自己的「电脑」
2. 并行效率：子代理系统将任务处理效率提升 3-5 倍
3. 安全隔离：容器化执行环境杜绝了代码执行的安全风险
4. 可扩展性：Markdown Skills 系统让功能扩展变得极其简单
5. 生产就绪：完善的错误处理、重试机制、监控体系

未来展望：

• 多模态能力增强：支持图像、视频、音频的生成和处理
• 边缘计算部署：在 IoT 设备上运行轻量级 Agent
• 协作式 Agent：多个 DeerFlow 实例之间的协作和知识共享
• 行业垂直化：针对金融、医疗、法律等行业的专用 Agent 模板

如果你正在寻找一个能真正「动手做事」的 AI Agent 框架，DeerFlow 2.0 值得你投入时间去探索。它不仅是一个工具，更是一种全新的 AI 工程化范式——让 AI 从「回答问题」进化为「完成任务」。

参考资源：

• GitHub: https://github.com/bytedance/deer-flow
• 官方文档: https://deerflow.tech
• LangGraph 文档: https://langchain-ai.github.io/langgraph/
• MCP 协议规范: https://modelcontextprotocol.io

标签：DeerFlow|AI Agent|LangGraph|Docker沙箱|超级智能体|字节跳动|开源|Python|MCP|Agent编排
关键词：DeerFlow 2.0, 超级智能体框架, LangGraph, Docker沙箱, AI Agent开发, 字节跳动开源, 子代理并行调度, Skills系统, MCP协议, Agent Harness
描述：深度拆解字节跳动开源的DeerFlow 2.0超级智能体框架：Lead Agent+Sub-Agent架构、Docker沙箱隔离执行、Markdown Skills系统、LangGraph图引擎集成、MCP协议支持，附完整代码实战与生产部署指南