DeerFlow 2.0: Deep Exploration and Efficient Research Flow (Super Agent Harness)

TL;DR

DeerFlow 2.0 is ByteDance’s open-source “super agent harness” — a ground-up rewrite (shares no code with v1) of what started as a Deep Research framework. It bundles a LangGraph/LangChain agent runtime with sandboxed code execution, long-term memory, a progressively-loaded skill system, sub-agent spawning, an MCP/skills extension surface, and IM-channel adapters (Slack/Telegram/Feishu/WeCom/DingTalk/WeChat). The thesis is that off-the-shelf agents fail because they lack infrastructure — filesystem, sandbox, memory, skill loader, gateway — and that this is the missing primitive Layer between LangGraph and a usable product. It hit GitHub Trending #1 on launch (2026-02-28) and is one of the most opinionated open harnesses currently shipping.

Key claims

DeerFlow 2.0 ships a complete harness, not a framework: LangGraph-based runtime, filesystem-backed sandbox, long-term memory, progressively-loaded skills, sub-agent orchestration, and a unified gateway translating public LangGraph-compatible paths to internal routers [README §From Deep Research to Super Agent Harness, §Core Features].
Skills are structured as Markdown SKILL.md files with optional frontmatter (version, author, compatibility) and are loaded on-demand by the agent rather than eagerly, keeping the context window lean and enabling token-sensitive base models [README §Skills & Tools].
The sandbox has three execution modes — local-on-host, Docker per-task containers, and Kubernetes pods via a provisioner service — selectable from config.yaml and auto-detected at startup [README §Sandbox Mode].
IM channels (Slack Socket Mode, Telegram long-poll, Feishu/Lark WebSocket, WeChat iLink, WeCom WebSocket, DingTalk Stream Push) all attach to the same gateway via the internal LangGraph-compatible API; none require a public IP [README §IM Channels].
The integration recommends mixing Doubao-Seed-2.0-Code, DeepSeek v3.2, and Kimi 2.5 as the model trio at runtime, but supports any langchain_openai-compatible endpoint plus CLI-backed providers (Codex CLI, Claude Code OAuth) and vLLM for self-hosted reasoning models [README §Coding Plan, §Configuration manual model config examples].
Tracing is first-class: LangSmith and Langfuse can both be enabled simultaneously; Langfuse traces are annotated with session_id = thread_id, user_id, trace_name = assistant_id, and tags = [env:..., model:...] so Sessions/Users views light up automatically [README §LangSmith Tracing, §Langfuse Tracing].
Deployment-sizing guidance is documented: 4 vCPU / 8 GB RAM is the floor; 8 vCPU / 16 GB recommended for Docker dev; 8 vCPU / 16 GB minimum and 16 vCPU / 32 GB recommended for long-running shared servers — a number rarely surfaced in agent-framework READMEs [README §Deployment Sizing].
A claude-to-deerflow skill lets Claude Code drive a running DeerFlow instance over its localhost gateway with four execution modes (flash / standard / pro / ultra) corresponding to single-call → planning → sub-agent fan-out [README §Claude Code Integration].

Method

DeerFlow’s runtime is a LangGraph agent whose execution graph is invoked via the Gateway’s /api/langgraph/* paths (which it translates to internal /api/* routers behind nginx). The agent’s action space is the union of (a) a core toolset — web search, web fetch, file ops, bash — and (b) any number of skills, where each skill is a Markdown document under /mnt/skills/public/*/SKILL.md (or /mnt/skills/custom/... for user-added ones) that describes a workflow, references supporting files, and is loaded only when the planner decides it’s relevant. Built-in skills cover research, report generation, slide creation, web-page building, and image/video generation.

Sub-agents are spawned by the lead agent when planning indicates the task benefits from decomposition; each sub-agent runs in the same harness but with a scoped context and its own conversation thread. Sandbox execution is pluggable (sandbox.use: in config.yaml): the default deerflow.community.aio_sandbox:AioSandboxProvider supports a provisioner_url that points at a Kubernetes-backed sandbox service, while local and Docker modes skip it. Memory is persisted across threads via a long-term memory store reviewable from Settings > Memory in the UI.

Model providers are wired through LangChain ChatOpenAI for any OpenAI-compatible endpoint, a custom VllmChatModel for vLLM self-hosted Qwen-style reasoning models (with extra_body.chat_template_kwargs.enable_thinking toggled per request), and two CLI-backed providers — CodexChatModel (reads ~/.codex/auth.json) and ClaudeChatModel (CLAUDE_CODE_OAUTH_TOKEN or ~/.claude/.credentials.json) — that let agents drive the user’s local Codex/Claude Code subscriptions.

Results

DeerFlow 2.0 went live on 2026-02-28 and claimed GitHub Trending #1 the same day per the maintainers [README §header]. No benchmark numbers are published in the README — this is a harness release, not a model release. The most concrete capability claim is the four-tier execution mode exposed via claude-to-deerflow (flash / standard / pro / ultra), where ultra enables the sub-agent fan-out path. The runtime is integrated with ByteDance’s Volcengine “Coding Plan” promoting Doubao-Seed-2.0-Code + DeepSeek v3.2 + Kimi 2.5 as the production model mix, and with BytePlus’s InfoQuest as a search/crawl toolset.

Why it’s interesting

DeerFlow 2.0 sits in Tool-Use Agents not as a model recipe but as a fully-packaged harness — the layer that the filed parameter-space (MiroThinker, InfTool, OpenResearcher) and context-space (Training-Free GRPO) papers all assume exists but rarely supply themselves. The contrast with OpenResearcher: A Fully Open Pipeline for Long-Horizon Deep Research Trajectory Synthesis is direct: OpenResearcher releases weights + trajectories + retriever + training code for a single research-agent model and explicitly notes MiroThinker “lacks the environment” — DeerFlow is precisely that environment, with sandboxed execution, long-term memory, skill loading, and multi-IM front-ends, but without the trained-from-scratch agent weights. It complements MiroThinker: Pushing the Performance Boundaries of Open-Source Research Agents via Model, Context, and Interactive Scaling in the same way: MiroThinker pushes interaction depth to ~600 tool calls per task as a training axis, while DeerFlow’s ultra mode + Kubernetes sandbox + 256K-class context routing supplies the inference-time substrate to actually execute trajectories of that length under a single gateway. The skill-as-Markdown design choice (progressively-loaded SKILL.md files) is also a cleaner version of the “skill / prompt library” pattern that shows up implicitly in the closed deep-research products (OpenAI Deep Research, Anthropic’s research preview) — worth tracking as the open community converges on a shared format.