Deer Flow
Open-source long-horizon SuperAgent harness that researches, codes, and creates autonomously.
An open-source long-horizon SuperAgent harness from ByteDance that researches, codes, and creates. With sandboxes, persistent memory, tools, skills, subagents, and a message gateway, it handles complex tasks that take minutes to hours.
+ Pros
- Backed by ByteDance — enterprise-grade engineering and active development
- 69.9k GitHub stars — one of the fastest-growing AI repos
- Long-horizon task handling: from minutes to hours of autonomous work
- Sandboxed execution with Docker and Kubernetes support
- Persistent long-term memory across sessions
- Extensible skills and tools system with MCP server support
- Multi-channel: Telegram, Slack, Feishu, WeChat, DingTalk
- MIT licensed — fully open source
- Embedded Python client for in-process integration
- Built on LangGraph and LangChain — solid foundation
− Cons
- Requires Docker, Redis, and PostgreSQL for full deployment — significant infrastructure overhead
- Steep learning curve for custom skill development
- Best performance requires high-end GPUs or powerful cloud instances
- Version 2.0 was a complete rewrite — not backward compatible with v1
- Untrusted code execution requires careful network isolation and resource limits for sandbox security
Introduction
Deer Flow (Deep Exploration and Efficient Research Flow) is ByteDance's open-source long-horizon SuperAgent harness. It orchestrates sub-agents, persistent memory, sandboxed execution, and extensible skills to research, code, and create autonomously — handling tasks from minutes to hours without human intervention. With over a million Docker pulls and a growing community, it claimed the #1 spot on GitHub Trending after its 2.0 launch.
#1 on GitHub Trending after the 2.0 launch — one of the fastest-growing AI repos with 69.9k stars.
Key Features
Sub-Agent Orchestration
Deer Flow decomposes complex tasks into smaller sub-tasks, each handled by a dedicated sub-agent with scoped context, tools, and termination conditions. Sub-agents run in parallel when possible and report back structured results. The lead agent synthesizes everything into a coherent output — whether that's a research report, a slide deck, or a web application.
Sandboxed Execution Environment
Each task gets its own isolated execution environment with a full filesystem view — skills, workspace, uploads, outputs. The agent reads, writes, and edits files, views images, and executes shell commands in a secure sandbox. Docker and Kubernetes are supported for production deployments.
Persistent Long-Term Memory
Unlike most agents that forget everything after a session, Deer Flow builds persistent memory of user profiles, preferences, and accumulated knowledge across conversations. Memory is stored in a vector store (defaulting to PostgreSQL with pgvector) and stays under user control — organized by session and user profile for cross-session recall.
Skills & Tools System
Skills are structured capability modules — Markdown files that define workflows, best practices, and references. Deer Flow ships with built-in skills for research, report generation, slide creation, web pages, image generation, and more. Custom tools are supported via MCP servers and Python functions. Skills load progressively to keep context windows lean.
Embedded Python Client
Deer Flow ships with an embedded Python client that allows programmatic control from within Python scripts and applications. You can instantiate a Deer Flow agent, submit tasks, stream outputs, and retrieve results — all without leaving your Python environment. This makes it suitable for integration into larger data pipelines, automated workflows, and CI/CD processes.
MCP Server Support
Deer Flow acts as an MCP (Model Context Protocol) server, exposing its agent capabilities through the standard MCP interface. Any MCP-compatible client — including IDEs like Cursor and Windsurf — can interact with Deer Flow agents directly, extending its reach beyond the built-in web UI and CLI.
Tracing & Observability
Deer Flow integrates with LangSmith and Langfuse for full tracing of agent runs, sub-agent calls, tool executions, and LLM invocations. Every step of a task is recorded with timings, token counts, and outputs — giving developers deep visibility into agent behavior for debugging and optimization.
Architecture
Deer Flow 2.0 is built on LangGraph and LangChain with a modular architecture designed for extensibility. At its core is the Gateway API, which serves as the central orchestrator for all agent interactions.
Gateway API: The Gateway receives task requests from any surface (web UI, CLI, API, IM channels) and handles task decomposition, sub-agent spawning, and message routing. Each task goes through a lifecycle: intake → planning → decomposition → execution → synthesis → output. The Gateway manages concurrency, retries, and error handling across sub-agents.
Sub-Agent Lifecycle: When a complex task arrives, the lead agent (powered by LangGraph) analyzes it and creates a task graph — a directed acyclic graph where each node represents a sub-task. Sub-agents are spawned per node with scoped context (relevant files, tools, and termination conditions). They execute in parallel where dependencies allow, writing results back to shared state. The lead agent monitors progress and synthesizes outputs once all sub-tasks complete.
Memory Layer: Persistent memory uses a vector store (defaulting to PostgreSQL with pgvector) to embed and index conversation history, user preferences, and accumulated knowledge. Memory is organized by session and user profile, enabling cross-session recall. Users retain full control — memory is stored locally and can be exported or deleted.
Sandbox Manager: Each sub-agent execution runs in an isolated Docker container with a mounted workspace. The sandbox manager configures CPU/memory limits, network access policies, and filesystem permissions per task. Kubernetes support allows scaling across clusters for production workloads.
Channel Gateway: A message gateway abstraction normalizes incoming requests from different channels (Telegram, Slack, Feishu, WeChat, DingTalk) into a unified agent interface. Each channel adapter handles authentication, message formatting, and bidirectional streaming.
Task Request → Gateway API → Task Graph → Sub-Agents (parallel) → Synthesis → Output
│ │ │
Channel Adapter LangGraph Sandbox
(IM / Web / CLI) Engine (Docker/K8s)Multi-Channel Support
Deer Flow can receive tasks from Telegram, Slack, Feishu/Lark, WeChat, WeCom, and DingTalk — no public IP required for any channel. Each channel supports the same agent capabilities: research, coding, content creation, and automation.
Getting Started
The fastest way to try Deer Flow is with Docker:
git clone https://github.com/bytedance/deer-flow
cd deer-flow
docker compose upOpen http://localhost:3000 to access the web UI. You can also use the CLI:
pip install deer-flow-client
deer-flow run "Research the impact of agentic AI on software development"For production deployments, refer to the deployment guide which covers Kubernetes, environment variables, and scaling configuration.
Verdict
Deer Flow is one of the most ambitious open-source agent projects available today. ByteDance's backing, 69.9k GitHub stars, and the comprehensive 2.0 rewrite signal a serious commitment to building production-grade agent infrastructure. What sets it apart is its long-horizon capabilities, multi-channel support, and extensible skills system. The trade-off is operational complexity: running Deer Flow requires Docker, Redis, PostgreSQL, and significant compute resources. For teams that need a powerful, self-hosted SuperAgent harness, Deer Flow is an excellent choice.
Further Reading
- GitHub Repository — Source code, releases, issues, and community contributions
- Official Documentation — Getting started guides, deployment, and API reference
- GitHub Releases — Changelog and version history for all releases
Version History
Major ground-up rewrite with LangGraph, modular architecture, sandboxed execution, persistent memory, and multi-channel support
Initial release — Deep Research framework for long-horizon research tasks
git clone https://github.com/bytedance/deer-flow
cd deer-flow
docker compose up
# Access the web UI at http://localhost:3000
# Or use the API: curl http://localhost:8000/api/v1/health
# Minimal Python integration:
from deer_flow import DeerFlow
agent = DeerFlow()
result = agent.run("Research the latest advances in agentic AI and create a slide deck")More in this Space
Sourcery
AI code review platform for the AI era. Automated code reviews, security scanning, and team analytics across GitHub, GitLab, VS Code, and JetBrains. Used by 300,000+ developers.
What The Diff
AI-powered PR description generator and code review assistant. Automatically writes pull request descriptions, sends stakeholder notifications, creates changelogs, and provides inline code refactoring.
Blackbox AI
Multi-agent AI coding platform with 12+ agents and 24+ models, featuring Chairman LLM for parallel multi-agent evaluation and end-to-end encrypted inference. Ships across six surfaces: CLI, IDE, Cloud, API, Mobile, and Builder.