书籍是巨大的力量。——列宁

DeerFlow 2.0：一只会“研究、写代码、创造内容”的长航程 SuperAgent，带着沙盒、记忆和一支子代理小队来了

DeerFlow 不是那种只会在聊天框里“想一想”的 Agent。

它更像一只披着工程外套的鹿：
一边抬头闻风向（Research），一边低头把活干完（Code），最后还能把成果打包成你能直接交付的东西（Create）。

它的自我介绍很明确：

An open-source long-horizon SuperAgent harness that researches, codes, and creates.
With the help of sandboxes, memories, tools, skill, subagents and message gateway, it handles different levels of tasks that could take minutes to hours.

一句话：它不是短跑机器人，它是能跑“长航程任务”的开源 SuperAgent harness，而且还带全套基础设施。

官网也在这：https://deerflow.tech
（上面有更多介绍和真实 demo。）

DeerFlow 2.0 的性格：它不是框架，它是“带电池的 harness”

DeerFlow 曾经从 Deep Research framework 起步，然后社区把它用出了更野的姿势：

  • 建数据管道
  • 生成 slide deck
  • 拉 dashboards
  • 自动化内容工作流

这些用法给了它一个清晰的信号：
它不是一个“研究工具”，它是一个能让 Agent 真正干活的运行时（runtime），一个 harness。

于是 DeerFlow 2.0 选择了“重生”：

DeerFlow 2.0 is a ground-up rewrite. It shares no code with v1.
If you’re looking for the original Deep Research framework, it’s maintained on the main-1.x branch.

2.0 不背历史包袱，直接从地基重写，目标就是让你开箱即用、随时扩展、可以跑长任务。

它最想做的事：把“分钟到小时”的任务拆开、跑完、交付

你把任务扔给 DeerFlow，它不会只给你一段建议，然后说“祝你好运”。

它会像一个有组织的项目负责人那样做事：
能拆就拆，能并行就并行，能落地就落地。

  • 任务会被分解
  • 子代理会被派出去
  • 沙盒里会真正执行命令、读写文件
  • 结果会被汇总成一个可交付的输出

这就是“长航程”的含义：
不是多聊几句，而是能把一个复杂任务从头跑到尾。

一句话交给 Coding Agent：One-Line Agent Setup

如果你在用 Claude Code、Codex、Cursor、Windsurf 或其他 coding agent，DeerFlow 甚至给你准备了“一句话交接说明”：

1
Help me clone DeerFlow if needed, then bootstrap it for local development by following https://raw.githubusercontent.com/bytedance/deer-flow/main/Install.md

它像个很会带人的工程负责人：
“你不用问我怎么装，按这个安装文档跑，优先用 Docker。缺啥配置你再告诉我。”

快速启动：把 DeerFlow 拉到本地，让它跑起来

DeerFlow 的 Quick Start 非常“工程味”：先 clone，然后生成配置，然后选择 Docker 或本地开发两条路。

1）克隆仓库

1
2
git clone https://github.com/bytedance/deer-flow.git
cd deer-flow

2）生成本地配置

在项目根目录（deer-flow/）运行：

1
make config

这会根据提供的 example templates 生成本地配置文件。

3）配置你要用的模型（至少一个）

编辑 config.yaml，写入至少一个 model 配置。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
models:
  - name: gpt-4                      # Internal identifier
    display_name: GPT-4              # Human-readable name
    use: langchain_openai:ChatOpenAI # LangChain class path
    model: gpt-4                     # Model identifier for API
    api_key: $OPENAI_API_KEY         # API key (recommended: use env var)
    max_tokens: 4096                 # Max tokens per request
    temperature: 0.7                 # Sampling temperature

  - name: openrouter-gemini-2.5-flash
    display_name: Gemini 2.5 Flash (OpenRouter)
    use: langchain_openai:ChatOpenAI
    model: google/gemini-2.5-flash-preview
    api_key: $OPENAI_API_KEY
    base_url: https://openrouter.ai/api/v1

  - name: gpt-5-responses
    display_name: GPT-5 (Responses API)
    use: langchain_openai:ChatOpenAI
    model: gpt-5
    api_key: $OPENAI_API_KEY
    use_responses_api: true
    output_version: responses/v1

4）设置 API Key（推荐写到 .env）

1
2
3
4
5
TAVILY_API_KEY=your-tavily-api-key
OPENAI_API_KEY=your-openai-api-key
# OpenRouter also uses OPENAI_API_KEY when your config uses langchain_openai:ChatOpenAI + base_url.
# Add other provider keys as needed
INFOQUEST_API_KEY=your-infoquest-api-key

当然也支持直接 export：

1
export OPENAI_API_KEY=your-openai-api-key

运行：Docker（推荐） or 本地开发

DeerFlow 很像一个“体贴但严格”的系统：
你可以走它最稳的 Docker 路线，也可以走本地开发路线，但前提都要把配置准备好。

方案 A：Docker（推荐）

开发模式（热更新、挂载源码）：

1
2
make docker-init    # Pull sandbox image (only once or when image updates)
make docker-start   # Start services (auto-detects sandbox mode from config.yaml)

生产模式（本地 build 镜像、挂载运行时配置和数据）：

1
2
make up     # Build images and start all production services
make down   # Stop and remove containers

启动后访问：

（当前 LangGraph agent server 通过 langgraph dev 运行。）

方案 B：本地开发

前置：先完成上面的 make config + 模型 key 配置。

1）检查依赖：

1
make check   # Verifies Node.js 22+, pnpm, uv, nginx

2）安装依赖：

1
make install # Install backend + frontend dependencies

3）（可选）预拉取 sandbox 镜像：

1
make setup-sandbox

4）启动：

1
make dev

启动后访问：

DeerFlow 的“装备栏”：Skills & Tools（它为什么能“几乎干任何事”）

DeerFlow 的能力不靠一句“我很强”，靠的是一整套模块化能力体系。

Skills：像给 Agent 装“结构化能力模块”

README 说得很直白：

Skills are what make DeerFlow do almost anything.

一个标准 Agent Skill 是一个结构化能力模块（Markdown 文件），里面定义：

  • workflow
  • best practices
  • supporting references

DeerFlow 自带一批内置 skills：research、report generation、slide creation、web pages、image/video generation……
但真正的重点是：可扩展。

你可以加自己的 skills、替换内置 skills、或者把多个 skills 组合成更复杂的工作流。

它甚至还强调了一个很“长任务友好”的设计：
skills 是 progressive loading ——只有任务需要的时候才加载，不会一次性塞满上下文窗口。

在沙盒里，skills 的路径组织也给你摆好了：

1
2
3
4
5
6
7
8
9
10
# Paths inside the sandbox container
/mnt/skills/public
├── research/SKILL.md
├── report-generation/SKILL.md
├── slide-creation/SKILL.md
├── web-page/SKILL.md
└── image-generation/SKILL.md

/mnt/skills/custom
└── your-custom-skill/SKILL.md         ← yours

Tools：像它的“手脚”，能搜、能抓、能读写、能跑命令

DeerFlow 内置 core toolset，包括：

  • web search
  • web fetch
  • file operations
  • bash execution

同时也支持通过 MCP servers 和 Python functions 扩展工具能力。
它的态度也很明确：Swap anything. Add anything.

子代理（Sub-Agents）：它的“并行分身小队”

复杂任务很少一次做完。DeerFlow 直接把这句话写进行为模型里：
Complex tasks rarely fit in a single pass. DeerFlow decomposes them.

Lead agent 可以随时 spawn 子代理：

  • 每个子代理有自己的 scope、context、tools、终止条件
  • 能并行就并行
  • 子代理回传结构化结果
  • lead agent 汇总成一个 coherent output

DeerFlow 用这种方式处理“分钟到小时”的任务：
一个研究任务可能拆成十几个子代理分别探索不同角度，然后收敛成一份报告 / 一个网站 / 一套 slide deck / 带视觉素材的交付件。

沙盒与文件系统：它不是“会说”，它是真的“能做”

DeerFlow 有一个很关键的气质：它有自己的电脑。

Each task runs inside an isolated Docker container with a full filesystem…

它能：

  • 读写、编辑文件
  • 执行 bash 命令与代码
  • 查看图片
  • 输出交付物

并且是 sandboxed、auditable、session 之间零污染。

沙盒里工作目录也很清晰：

1
2
3
4
5
# Paths inside the sandbox container
/mnt/user-data/
├── uploads/        ← your files
├── workspace/      ← agents' working directory
└── outputs/        ← final deliverables

这也是为什么它能跑长任务：
它不需要靠“记住所有细节”，它会把中间产物卸载到文件系统里继续推进。

上下文工程（Context Engineering）与总结（Summarization）

DeerFlow 的长任务能力不只来自“能干活”，还来自“会管理上下文”：

  • 子代理上下文隔离：互不干扰，避免主代理被噪声淹没
  • session 内 aggressive summarization：已完成子任务会被总结、结果写入文件系统
  • 让它在长、多步任务里保持清醒

长期记忆（Long-Term Memory）：它会越来越懂你

大多数 agent 会在会话结束后“清空人格”。DeerFlow 不。

它会跨 session 建立持久化记忆：

  • 你的 profile
  • 你的偏好
  • 你常用的技术栈
  • 你重复出现的工作流

并且记忆存本地、由你控制。
更像一只逐渐熟悉你习惯的“长期搭档”，用得越久越顺手。

推荐模型：它不挑食，但它知道什么更适合长航程

DeerFlow 是 model-agnostic（只要实现 OpenAI-compatible API 都能接），但它更喜欢：

  • long context windows（10k+ tokens）
  • reasoning capabilities（用于规划与分解）
  • multimodal inputs（图像/视频理解）
  • strong tool-use（可靠函数调用与结构化输出）

另外 README 里还提到一个来自 Bytedance Volcengine 的 Coding Plan，并推荐使用：

  • Doubao-Seed-2.0-Code
  • DeepSeek v3.2
  • Kimi 2.5

IM Channels：它还会“接消息干活”，不需要公网 IP

DeerFlow 支持从消息应用接任务，并且通道配置后可自动启动，不需要公网 IP。

支持的通道包括：

Channel Transport Difficulty
Telegram Bot API (long-polling) Easy
Slack Socket Mode Moderate
Feishu / Lark WebSocket Moderate

配置示例（config.yaml）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
channels:
  langgraph_url: http://localhost:2024
  gateway_url: http://localhost:8001

  session:
    assistant_id: lead_agent
    config:
      recursion_limit: 100
    context:
      thinking_enabled: true
      is_plan_mode: false
      subagent_enabled: false

  feishu:
    enabled: true
    app_id: $FEISHU_APP_ID
    app_secret: $FEISHU_APP_SECRET

  slack:
    enabled: true
    bot_token: $SLACK_BOT_TOKEN
    app_token: $SLACK_APP_TOKEN
    allowed_users: []

  telegram:
    enabled: true
    bot_token: $TELEGRAM_BOT_TOKEN
    allowed_users: []

连上通道后，它在聊天里也有命令：

Command Description
/new Start a new conversation
/status Show current thread info
/models List available models
/memory View memory
/help Show help

LangSmith Tracing：它不怕你看它“怎么干活”

DeerFlow 内置 LangSmith 集成用于可观测性。启用后：

  • 所有 LLM calls
  • agent runs
  • tool executions

都能在 LangSmith dashboard 里被 trace。

在 .env 里加：

1
2
3
4
LANGSMITH_TRACING=true
LANGSMITH_ENDPOINT=https://api.smith.langchain.com
LANGSMITH_API_KEY=lsv2_pt_xxxxxxxxxxxxxxxxx
LANGSMITH_PROJECT=xxx

Claude Code Integration：从 Claude Code 直接“遥控”一只 DeerFlow

DeerFlow 提供 claude-to-deerflow skill，让你在 Claude Code 里直接跟运行中的 DeerFlow 实例交互。

安装：

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

确保 DeerFlow 在跑（默认 http://localhost:2026），然后在 Claude Code 里用 /claude-to-deerflow。

它能做的事包括：

  • 发消息并拿到 streaming responses
  • 选择执行模式：flash（快）、standard、pro（规划）、ultra（子代理）
  • 查健康状态，列出 models/skills/agents
  • 管理 threads / conversation history
  • 上传文件做分析

可选环境变量（自定义 endpoint）：

1
2
3
DEERFLOW_URL=http://localhost:2026
DEERFLOW_GATEWAY_URL=http://localhost:2026
DEERFLOW_LANGGRAPH_URL=http://localhost:2026/api/langgraph

Embedded Python Client：它还愿意当你的库，而不是只能当服务

你也可以不跑完整 HTTP 服务，直接在 Python 里嵌入使用 DeerFlowClient，并且接口 schema 与 Gateway 保持对齐。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from deerflow.client import DeerFlowClient

client = DeerFlowClient()

# Chat
response = client.chat("Analyze this paper for me", thread_id="my-thread")

# Streaming (LangGraph SSE protocol: values, messages-tuple, end)
for event in client.stream("hello"):
    if event.type == "messages-tuple" and event.data.get("type") == "ai":
        print(event.data["content"])

# Configuration & management — returns Gateway-aligned dicts
models = client.list_models()          # {"models": [...]}
skills = client.list_skills()          # {"skills": [...]}
client.update_skill("web-search", enabled=True)
client.upload_files("thread-1", ["./report.pdf"])  # {"success": True, "files": [...]}

并且它强调：CI 里有 TestGatewayConformance 来保证 embedded client 与 HTTP API schema 同步。

安全提醒：它能力很大，所以默认只建议跑在本地可信环境

DeerFlow 明确写了安全提示：它具有高权限能力（系统命令执行、资源操作、业务逻辑调用）。
默认设计为部署在 本地可信环境（仅 127.0.0.1 loopback 可访问）。

如果你要跑在不可信网络环境（LAN、公网云主机、多端可访问），必须做严格安全措施，例如：

  • IP allowlist（iptables / ACL）
  • 反向代理预认证（nginx 等）
  • 网络隔离（专用 VLAN）
  • 持续跟进安全更新

它的出身：从 Deep Research 到 SuperAgent Harness（2.0 的意义）

DeerFlow 2.0 的叙事很像一位“从研究员转成工程总包”的角色：

  • 以前：一个研究框架
  • 后来：社区把它当万能工具用
  • 于是：它干脆变成一个真正的 harness，把 agent 需要的一切都带上

它让你可以：

  • 直接用（Use it as-is）
  • 或拆开改造（Tear it apart and make it yours）

License

MIT License。

Acknowledgements

DeerFlow built upon the open-source community, with explicit acknowledgements to:

  • LangChain
  • LangGraph

并向核心作者致谢：

  • Daniel Walnut
  • Henry Li

Star History

README 提供了 Star History 图表入口（star-history.com）。