deer-flow

Overview

deer-flow reframes the agent problem: instead of making a single agent smarter, it gives agents better infrastructure. The framework’s core abstraction is a lead agent that plans at the task level — decomposing complex requests into sub-tasks that can run concurrently — while sub-agents handle execution within Docker-isolated environments with real compute access. The design targets tasks that “take minutes to hours”: research pipelines, multi-step code generation, content workflows, and autonomous data processing.

At 62,800+ stars and #1 on GitHub Trending when version 2 launched in February 2026, deer-flow is one of the largest agent frameworks available. The ByteDance engineering team has produced production-deployment documentation that is notably serious for an open-source project: minimum hardware specifications, Docker-based deployment modes, and explicit network isolation recommendations.

How It Works

Task decomposition: The lead agent receives a complex task and produces a decomposed execution plan — a directed graph of sub-tasks with dependency relationships. Sub-tasks that don’t depend on each other are marked for concurrent execution.

Sub-agent spawning: Each sub-task spawns a sub-agent with a scoped context window containing only what it needs. This prevents context bloat that degrades reasoning quality in long-horizon tasks.

Isolated execution: Sub-agents execute within Docker containers. They have access to a bash terminal and filesystem — they run commands, install packages, write files, and call APIs. The agent does not suggest a bash command; it runs it.

Memory persistence: An asynchronous debounced queue tracks user preferences, project state, and discovered facts across sessions. Sub-agents can read from and write to this shared memory, enabling continuity across multi-session tasks.

Convergent synthesis: The lead agent aggregates sub-agent outputs into a coherent final result, resolving conflicts and filling gaps where sub-tasks produced inconsistent results.

Use Cases

• Research automation: Decompose a research question into parallel web searches, document retrieval, and synthesis passes — each handled by a dedicated sub-agent
• Multi-step code generation: Separate sub-agents for spec interpretation, implementation, test generation, and code review, running concurrently where dependencies allow
• Content pipelines: Parallel research, drafting, fact-checking, and formatting sub-agents for long-form content production
• Data processing: Fan-out sub-agents for concurrent data extraction, each writing results to shared memory for a synthesis pass

Considerations

ByteDance provenance: VentureBeat noted that “ByteDance provenance may trigger organizational review processes.” Regulated industries and US government-adjacent environments should route procurement review before deploying. The codebase is MIT-licensed and fully auditable — but organizational origin matters for some compliance frameworks.

Security posture: The Docker sandbox is the primary security boundary. deer-flow’s own documentation warns against untrusted network exposure and recommends IP allowlisting and VLAN isolation for server deployments. Sub-agent spawning rates should be monitored; an unconstrained lead agent can generate significant compute load.

Resource requirements: 8+ vCPU and 16GB RAM minimum for server deployment. The parallel execution model is compute-intensive by design.

Who It’s For

Engineering teams building long-horizon autonomous workflows — research pipelines, content automation, multi-step code generation — who need the infrastructure layer to run agents reliably at scale. Teams already using LangGraph for orchestration will find deer-flow’s architecture immediately familiar. Not recommended for customer-facing deployments where adversarial users could reach agents with untrusted input without additional input sanitization.