This 79k-star GitHub project lets AI carry your multi-hour long-haul work

1. Intro: why you need this tool

It's 2 a.m., and developer Zhang is staring at an 80-page industry research report draft on his screen, stuck. The report needs 12 authoritative sources merged in, 200+ data analyses run, visualizations generated, and a PowerPoint built from the company template. By hand, that's three days minimum.

This isn't an isolated case. A 2025 Gartner survey found knowledge workers spend an average of 6.3 hours a week on long-chain tasks like "research — organize — produce," and over 41% of respondents said such tasks "badly squeeze out core creative work." Once a task stretches from a few minutes to a few hours, the conventional chat-style AI assistant falls short: context gets lost, sub-tasks can't run in parallel, long flows run unattended with no supervision, and no memory or skills accumulate.

If you're also stuck at the "AI can chat but can't carry the work" stage, DeerFlow 2.0 is worth 10 minutes of your time. It hit #1 on GitHub Trending on February 28, 2026, has since gathered 79,465 stars, and is ByteDance's open-source "long-chain SuperAgent orchestration framework."

2. Project overview in one sentence

DeerFlow stands for Deep Exploration and Efficient Research Flow, and it bills itself as an "open-source long-chain SuperAgent orchestration base." Through sandboxes, memory, tools, skills, sub-agents and a message gateway working together, it autonomously handles complex tasks ranging from minutes to hours.

Four keywords: Python 3.12+ / Node.js 22+ dual-language stack, MIT license, a full 2.0 rewrite (no code shared with 1.x), community-driven. Compared with the 1.x "deep research framework," 2.0 is a full upgrade to a "SuperAgent base" — more general architecture, more complete capabilities.

3. Core features in depth

1. Skills & Tools — an extensible capability hub

DeerFlow treats skills as first-class citizens. A skill is a version-managed Markdown/YAML resource that loads dynamically like a plugin; a tool is the code function that actually executes commands behind a skill. With the two decoupled, an ops person can add capability without writing code.

It has native Claude Code integration: just say the following to a coding agent such as Claude Code, Codex, Cursor or Windsurf — Help me clone DeerFlow if needed, then bootstrap it for local development by following https://raw.githubusercontent.com/bytedance/deer-flow/main/Install.md — and the agent clones the repo and gets it running locally for you.

2. Sub-Agents — an execution network that splits work in parallel

Complex tasks can be decomposed across multiple concurrent sub-agents — "one handles retrieval, one writes code, one draws diagrams." Each sub-agent gets its own context window and tool set, and results are aggregated back into the main agent. The design idea is similar to Claude Multi-Agent and AutoGen, but DeerFlow exposes finer runtime control through parameters such as subagents.max_total_per_run, preventing infinite recursion or resource exhaustion.

3. Sandbox & File System — a safe execution environment

DeerFlow supports three sandbox modes: local direct execution, Docker container isolation, and K8s Pod isolation. All code execution is confined to a sandbox, and file reads and writes go through restricted paths, avoiding the "AI formatted my hard drive" disaster. Docker mode is recommended in production; local direct execution is faster in development; when several users share an instance, Redis-backed sandbox ownership management stops "the colleague next door's code from deleting the container I'm using."

4. Long-Term Memory & Session Goals — an assistant that doesn't forget

Traditional chatbots forget the moment the conversation ends. DeerFlow makes memory a persistent module: user preferences, project background and past experience are all callable across sessions. Nicer still are "session goals" — you can tell it "help me do competitor analysis over the next 30 minutes," and it keeps tracking completion and reminds you when time is up. Paired with manual context compaction, old turns in a long task can be explicitly archived, freeing window space for new content.

5. Context Engineering & IM Channels — end-to-end engineering

DeerFlow treats context engineering as a module in its own right: what enters the context, how it's ordered, when it's compacted, and how it's traced back all follow explicit policies. IM Channels let it receive tasks directly on Telegram, Slack, Feishu, WeCom and DingTalk with no public IP — set bot_token and your AI assistant lives in the team chat.

4. Technical highlights and performance data

• GitHub Trending #1: on February 28, 2026, DeerFlow 2.0 topped the chart on launch day, and its single-day star curve set a record for ByteDance open-source projects.
• Clear deployment tiers: the docs give three recommended configurations — local development from 4 vCPU/8 GB RAM, Docker development likewise 4 vCPU/8 GB RAM, long-running services from 8 vCPU/16 GB RAM, with 16 vCPU/32 GB RAM recommended.
• Broad LLM compatibility: native support for a dozen-plus providers including OpenAI, Anthropic, OpenRouter, vLLM (local models such as Qwen3), Codex CLI and Claude Code OAuth, all switchable in a single config.yaml; ByteDance Volcano Engine recommends Doubao-Seed-2.0-Code, DeepSeek v3.2 and Kimi 2.5.
• Mature multi-worker architecture: Gateway defaults to a single worker; multi-worker deployments with Postgres + Redis Stream Bridge enable cross-instance SSE delivery, resume after disconnection and orphan task reclamation, while lease heartbeats make sure crashed tasks aren't lost.
• Full observability: native support for three tracing platforms — LangSmith, Langfuse and Monocle — so debugging long tasks is no longer guesswork in the dark.
• TUI terminal workbench: beyond the Web UI, a built-in Terminal Workbench lets developers talk to DeerFlow straight from an SSH session.

5. Use cases and who it's for

Case 1: long-chain research reports. Type "write me a 2025 China new-energy vehicle market report" and DeerFlow decomposes the sub-tasks itself (find data sources, scrape data, run analysis, draw charts, write the summary) and outputs PDF/PPTX.

Case 2: automated code workflows. Have DeerFlow watch GitHub issues continuously, then reproduce, fix and open a PR automatically — combined with Claude Code integration, that's an "AI programmer on duty" pattern.

Case 3: team IM assistant. Wire DeerFlow into Feishu/WeCom/Slack and it looks things up, books meeting rooms and writes weekly reports in the group, with no extra public webhook development.

Who it suits: teams that need to move "AI writes docs / does research / runs code" from one-off demos to everyday productivity; mid-level and backend engineers who want a private agent platform without building the wheels from scratch; enterprises with data compliance requirements that need local deployment.

Who it doesn't suit: lightweight users who just want a few chat turns; absolute beginners who can't tolerate a command line (the minimum bar is running make).

6. Comparison with alternatives

By comparison, DeerFlow's differentiator is all-in-one delivery: orchestration, memory, sandbox, IM, observability and a terminal UI in one package, saving you the cost of gluing code together yourself.

7. Getting started fast

Prerequisites: Python 3.12+, Node.js 22+, pnpm, uv, Docker (optional).

One-line start (recommended for Claude Code/Codex users): paste this into your coding agent

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

The agent clones the repo, picks Docker and gives you the next command.

Manual start:

git clone https://github.com/bytedance/deer-flow.git
cd deer-flow
make setup       # interactive wizard, generates config.yaml and .env in about 2 minutes
make doctor      # self-check
make docker-start  # one-command startup in Docker mode

Then visit http://localhost:2026 for the Web UI. If something breaks, run make support-bundle to generate a diagnostic bundle you can paste straight into a GitHub issue.

Advanced tips: for production, use make up to build production images; in multi-worker setups be sure to configure Postgres + Redis Stream Bridge + run_ownership.heartbeat_enabled: true; on mainland China networks, set UV_INDEX_URL=https://pypi.tuna.tsinghua.edu.cn/simple and NPM_REGISTRY=https://registry.npmmirror.com to speed things up.

8. Summary and next steps

DeerFlow 2.0 isn't another chatbot framework. It takes long-chain agents from concept to production as a complete base: skills are extensible, sub-agents run in parallel, sandboxes isolate execution, memory persists, and IM channels reach your team. It already has nearly 80k stars, topped GitHub Trending, and has been battle-tested at scale inside ByteDance.

If you're evaluating agent platforms, spend an afternoon running the official Quick Start, then pick one real business pain point for a PoC — for example, "have DeerFlow track competitor blogs and generate a weekly digest."

Project links:

• Repository: https://github.com/bytedance/deer-flow
• Website: https://deerflow.tech
• Docs: https://github.com/bytedance/deer-flow/blob/main/backend/docs/CONFIGURATION.md
• Recommended models: Volcano Engine Coding Plan (Doubao-Seed-2.0-Code / DeepSeek v3.2 / Kimi 2.5)

One-line pitch: when your tasks grow from "a few minutes" to "a few hours," let DeerFlow carry the load.