Most “deep research” agents die at the ten-minute mark. They fan out a few web searches, dump a summary, and call it a day. The moment you ask for something that takes an hour — scrape forty sources, write code to crunch the data, produce a slide deck, then verify the numbers — the single-shot agent loses its thread, blows its context window, and hallucinates the last third.

DeerFlow is ByteDance’s answer to the long-horizon problem. It started life in mid-2025 as a modular deep-research framework and, on February 28th 2026, hit the #1 spot on GitHub Trending after a ground-up 2.0 rewrite. The pitch for 2.0 is bigger than research: it’s a super-agent harness that orchestrates sub-agents, sandboxes, long-term memory, and pluggable skills to handle tasks that “could take minutes to hours.”

Key stats: GitHub Trending #1 (Feb 2026) | 2.0 is a full rewrite (shares no code with 1.x) | Built on LangGraph | MIT-licensed core | Docker or local install | Python client + TUI + IM channels

TL;DR for Developers

Product:     DeerFlow 2.0 (bytedance/deer-flow)
What it is:  Long-horizon "super agent" harness (research + code + create)
License:     Open source (MIT); 1.x maintained on a separate branch
Built on:    LangGraph (stateful graph orchestration + checkpointing)
Deploy:      Docker (recommended) or local dev; one-line setup wizard
Interfaces:  Web UI, Terminal Workbench (TUI), Python client, IM channels, MCP
Best for:    Multi-step autonomous jobs that outlast a single context window
Weak spot:   Heavyweight footprint; sandbox/security config is on you

If your problem is “I need an agent that can run for an hour, remember what it did, execute code in a sandbox, and not fall over halfway,” DeerFlow is one of the few open-source harnesses purpose-built for it. If you just want a quick RAG chatbot or a single-turn search summary, it’s overkill — reach for something lighter.

From Deep Research to Super Agent Harness

DeerFlow 1.x was a focused thing: a multi-agent deep research pipeline. You gave it a question, and a planner agent broke it into steps, a researcher agent ran web search and crawling, a coder agent executed Python, and a reporter agent wrote the final document. It even shipped a text-to-speech path so you could turn a report into a podcast. That was enough to get it noticed.

The community, though, took it further than the creators planned — people were using it to build data pipelines, generate slide decks, spin up dashboards, and automate content workflows. So ByteDance rewrote it. The README is blunt about this:

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 1.x branch.

The acronym stayed (Deep Exploration and Efficient Research Flow), but the scope changed. 2.0 is no longer “a research bot” — it’s a harness with the primitives you’d expect from a serious agent runtime: sub-agents, sandboxes, memory, skills, session goals, context compaction, and scheduled tasks.

What DeerFlow 2.0 Actually Gives You

Under the hood it’s built on LangGraph, so the orchestration is a stateful graph rather than a naive while-loop. That matters for long tasks: the graph has built-in checkpointing, so a run that takes an hour can be resumed, inspected, and replayed instead of restarted from zero. The pieces that make it a “harness” rather than a script:

  • Sub-agents. The main agent can spawn specialized child agents for parallel or isolated work, then collect their results — the same pattern you see in Claude Code and other modern harnesses.
  • Sandbox & file system. Code and shell commands run inside a sandbox (an “AIO sandbox” container in provisioner mode), with a scratch file system the agent can read and write.
  • Long-term memory. State survives beyond a single session, so the agent can recall earlier work across runs.
  • Skills & tools. Behavior is extended through pluggable skills, plus web search, crawling, Python execution, RAG retrieval, and MCP tool invocation.
  • Context engineering + manual compaction. You can compact context deliberately instead of praying the window holds — critical for hour-long jobs.
  • Session goals. A run can be pinned to an explicit objective the harness tracks.
  • Scheduled tasks. Recurring or deferred work, not just one-shot prompts.
  • Multiple interfaces. A web UI, a Terminal Workbench (TUI), an embedded Python client, IM channels (chat-driven agents), and an MCP server.

Getting Started: One-Line Setup

The fastest path is the setup wizard, which walks you through provider choice and safety settings:

# Clone and run the interactive setup wizard
git clone https://github.com/bytedance/deer-flow.git
cd deer-flow
make setup   # ~2 minutes: pick LLM provider, web search, sandbox/bash/file-write prefs

The wizard generates a minimal config.yaml and writes your API keys to .env. It explicitly asks about execution and safety preferences — sandbox mode, bash access, and file-write tools — which is the right instinct for a tool that runs arbitrary code.

For anything beyond a quick local try, Docker is the recommended route:

# Docker path (recommended for shared use / heavier sandbox workloads)
make docker-init    # Pull the sandbox image (first run only)
make docker-start   # Start services; auto-detects sandbox mode from config.yaml
make docker-logs    # Tail logs

A minimal config.yaml for provisioner-mode sandboxing looks roughly like this:

# config.yaml (excerpt)
llm:
  provider: openai          # or your chosen provider
sandbox:
  use: deerflow.community.aio_sandbox:AioSandboxProvider
  provisioner_url: http://localhost:8080
database:
  # checkpointing is what makes long runs resumable
  checkpoint_delta:
    snapshot_frequency: 10

One sizing note the docs are upfront about: image builds, bind mounts, and sandbox containers need more headroom than pure local dev. If CPU or memory pins during a run, the recommended fix is to reduce concurrent runs first, then step up a sizing tier. This is not a laptop-background toy — plan for real RAM if you’re doing multi-agent runs or heavy sandbox work.

Driving It from Python

Beyond the UI and TUI, DeerFlow ships an embedded Python client so you can invoke the harness programmatically — handy for wiring it into your own pipeline:

from deerflow import DeerFlowClient

client = DeerFlowClient(config_path="config.yaml")

# Kick off a long-horizon task with an explicit session goal
run = client.run(
    goal="Research the top 5 open-source vector databases, "
         "benchmark ingestion speed with a Python script, "
         "and produce a comparison report with citations.",
    max_minutes=60,
)

for event in run.stream():
    print(event.type, event.summary)  # inspect each harness step

print(run.result.report)

The checkpoint settings (checkpoint_channel_mode, checkpoint_delta.snapshot_frequency) are frozen when the process first builds an agent — including through DeerFlowClient — so changing them requires a process restart. Worth knowing before you tune throughput in production.

The README nudges you toward specific models for best results: Doubao-Seed-2.0-Code (ByteDance’s own), DeepSeek v3.2, and Kimi 2.5. That’s a China-model-first lineup, which makes sense given the sponsor, but the LangGraph foundation means you can point it at other providers — the docs cover multi-provider setups and both LangSmith and Langfuse tracing. If you’re already running local or Western frontier models, expect to spend a little time on provider config rather than taking the defaults.

Community Reactions

The 2.0 launch was genuinely a moment: #1 on GitHub Trending the day it shipped, and coverage across MarkTechPost, SitePoint, and a raft of tutorial blogs. The praise clusters around a few themes:

  • “Finally, an agent that doesn’t forget.” The checkpointing + memory story is what people latch onto — the ability to run a task for an hour and inspect/replay it is rare in open source.
  • Modularity. The LangGraph supervisor-orchestration pattern gets credit for being genuinely extensible rather than a monolith.
  • The podcast/report outputs from 1.x won it a lot of early goodwill; people liked that it produced artifacts, not just chat.

The skepticism is just as real:

  • “Do I trust a ByteDance-sponsored agent runtime?” The model recommendations and BytePlus/Volcengine promotion in the README rub some contributors the wrong way, and geopolitics colors adoption for Western enterprises.
  • Setup weight. Several users note the Docker/sandbox path is not trivial, and the resource footprint surprised people expecting a lightweight tool.
  • v1-vs-v2 confusion. Because 2.0 shares no code with 1.x, tutorials written for the old framework simply don’t apply — a recurring source of “why doesn’t this work” threads.

Honest Limitations

No sugar-coating — here’s where DeerFlow will bite you:

  1. You own the security. The README ships a dedicated security notice warning that improper deployment may introduce security risks. An agent that runs arbitrary bash and code inside a sandbox is a liability if you expose it carelessly. Treat the sandbox and network config as production security, not an afterthought.
  2. Heavyweight. Between LangGraph, checkpoint storage, sandbox containers, and (optionally) a local LLM, this is a multi-service deployment. The docs literally publish sizing tiers because people hit resource limits.
  3. Config surface is large. Frozen-at-startup checkpoint settings, provisioner vs. local sandbox modes, proxy behavior for internal vs. external hosts — there are sharp edges that only reveal themselves under load.
  4. China-model-first defaults. The recommended models are Doubao, DeepSeek, and Kimi. They work well and are cheap, but if compliance or data-residency rules push you to other providers, budget time for it.
  5. Long tasks still fail sometimes. Checkpointing makes failures recoverable, not impossible. Hour-long autonomous runs will still occasionally wander; the value is that you can replay from a checkpoint instead of the top.

How It Compares

DeerFlow isn’t the only harness chasing long-horizon autonomy, so it helps to place it. OpenHands and Goose are terminal-native coding agents — excellent at editing a repo and running commands, but their center of gravity is software development, not multi-modal research-plus-reporting. Dify, Langflow, and Flowise are visual builders: great for wiring RAG pipelines and simple agent flows through a drag-and-drop UI, but they aren’t built for a single agent that runs autonomously for an hour with checkpointed state. Raw LangGraph gives you the same orchestration primitives DeerFlow uses, but you assemble the sub-agents, sandbox, memory, and skills yourself.

DeerFlow’s niche is the middle: it’s a finished harness that bundles those primitives around the long-running, artifact-producing job. The closest philosophical cousin is a general assistant runtime like Claude Code’s harness — sub-agents, session goals, context compaction, scheduled tasks — but pointed at research and content generation rather than pure coding. If your task is “produce a real deliverable that takes real time,” that’s the gap DeerFlow is trying to fill.

Who Should Use It

Reach for DeerFlow if: you need autonomous jobs that outlast a single context window — deep research with code execution, data pipelines, report/deck generation, or chat-driven agents in an IM channel — and you’re comfortable running a multi-service Docker deployment.

Skip it if: you want a lightweight single-turn search summarizer, a simple RAG chatbot, or a tool you can run in the background on a laptop without thinking about sandboxes. In those cases a smaller framework (or even a plain LangGraph script) will get you there faster.

FAQ

Is DeerFlow free and open source? Yes. The core is open source under an MIT-style license, and the 1.x deep-research framework is still maintained on a separate branch. There’s no paywall to run it yourself, though the recommended cloud models and any hosted infra cost money.

What’s the difference between DeerFlow 1.x and 2.0? 1.x is a focused multi-agent deep research pipeline (planner → researcher → coder → reporter, plus podcast output). 2.0 is a ground-up rewrite into a general super-agent harness with sub-agents, sandboxes, long-term memory, skills, and scheduled tasks. They share no code, so 1.x tutorials don’t apply to 2.0.

What is DeerFlow built on? LangGraph — a stateful, graph-based orchestration framework from the LangChain ecosystem. That’s what gives it checkpointing, resumable long runs, and a supervisor-style multi-agent pattern.

Which models does DeerFlow recommend? The README recommends Doubao-Seed-2.0-Code, DeepSeek v3.2, and Kimi 2.5. Because it runs on LangGraph, you can configure other providers too, with LangSmith or Langfuse for tracing.

Is it safe to deploy? Only if you configure it carefully. DeerFlow runs code and shell commands in a sandbox, and the docs include an explicit security notice that improper deployment introduces risk. Isolate the sandbox, lock down network exposure, and treat it like any system that executes untrusted code.

The Bottom Line

DeerFlow 2.0 is one of the most serious open-source attempts at the long-horizon agent problem: not “answer my question,” but “go do this multi-step job for an hour and don’t fall apart.” The LangGraph foundation, checkpointing, sandboxes, and memory are the right primitives, and the #1 Trending spot wasn’t an accident. The tradeoffs are real — it’s heavy, the config surface is broad, security is your job, and the defaults lean toward ByteDance’s own model stack. But if you’ve been frustrated watching single-shot agents lose the plot halfway through real work, DeerFlow is worth cloning and running against a task that actually takes an hour.