DeerFlow
2.0
DeerFlow gives agents tools and a workspace for work that takes several steps to finish.
What DeerFlow does
DeerFlow gives an AI agent tools, a workspace, memory and helper agents so it can carry multi-step work through to a usable result.
Stay on task
Break a broad job into smaller steps and keep useful context as the work continues.
Use a computer
Search, run commands, inspect files and create outputs inside an isolated sandbox.
Leave an artefact
Produce a report, analysis, code change or other file that a person can inspect.
Why use it
It gives teams a starting runtime, so they can focus on their task instead of wiring every agent capability from scratch.
An agent can gather information, delegate a focused subtask, work with files and assemble a result. DeerFlow puts those steps in one runtime.
That suits work a single prompt cannot finish. You still need to choose the model, set tool permissions and run the service safely.
Example workloads
Market scan
Collect sources, ask focused subagents to investigate separate themes, then compile an evidence-linked brief.
Dataset review
Load a dataset, run exploratory analysis in the sandbox and return charts plus a written summary.
Prototype asset
Research a concept, write or run code, then produce a small demo or file for human review.
Examples draw on DeerFlow’s documented features and project demos. They don’t promise a particular result.
1. Mental model
Think of DeerFlow as the agent’s work environment.
The model reasons about the request. The harness gives it tools and a place to work.
The system has three layers
The project provides a reusable Harness runtime and a reference DeerFlow App.
How a task moves through the harness
“Long-horizon” means coordinating several steps, rather than waiting longer for one answer.
What each part does
- Skills provide task-specific instructions and resources when needed.
- Tools let the agent search, inspect, edit or act through connected capabilities.
- Subagents take focused tasks with scoped context, then return findings.
- Sandbox gives file and command work an isolated execution space.
- Memory carries selected useful context across sessions.
- Context management summarises and scopes information to keep long tasks workable.
Skills carry workflow knowledge
A skill gives the agent task-specific steps and reference material when it needs them.
The base agent stays general. A skill adds the steps and checks for a job such as deep research, data analysis or content creation.
DESIGN IMPLICATION
Treat skills as product logic. Version them, test them on real tasks, and keep instructions separate from credentials and access rules.
Delegation helps with parallel work
A lead agent can assign a focused question to a subagent, pass the context it needs, then review what comes back.
This helps when research splits into separate threads. The lead agent still has to compare evidence, resolve conflicts and check the sources.
Parallel agents can broaden coverage. Check every claim they return.
The sandbox sets an execution boundary
The sandbox gives an agent a place to run commands and work with files. Your deployment still decides what data, tools and network paths it can reach.
Set the permissions
- Which tools can run?
- Can the agent write files or use a shell?
- What data and network paths are reachable?
Review consequential work
- Review consequential outputs.
- Use least privilege for credentials.
- Test hostile or ambiguous inputs.
Where it fits, and what it adds
Works well when
- Multi-step work with a clear deliverable.
- Repeatable task families that benefit from specialist skills.
- Teams willing to operate a model-backed agent service.
Costs and risks
- More moving parts than a simple prompt or script.
- Provider cost and latency can grow with tool and agent calls.
- Sandbox and permissions need deployment-specific review.
Cost, reliability and security depend on the models, tools, task and deployment you choose.
2. Local setup
Try the reference app before building on the Harness.
A local run lets you test the task loop, inspect outputs and discover which parts you actually need.
Set it up locally
- Check prerequisites
Use a supported development machine, Git, and Docker Desktop or Engine with Docker Compose v2.24+ for the Docker route.
- Clone and enter the repository
Start from the official bytedance/deer-flow repository.
- Run the setup wizard
make setupasks for a model provider and optional search, plus sandbox and tool preferences. It writesconfig.yamland.env. - Review keys and permissions
Keep secrets in your local environment file. Choose the narrowest tool access that still supports your test.
Start a local run
git clone https://github.com/bytedance/deer-flow.git cd deer-flow make setup make docker-init make docker-start
Open http://localhost:2026. Give it a small task that should create a file. Check the file and the steps the agent took.
If setup fails, run make doctor for checks and fix hints. Read the current Install.md before you start, since commands can change.
Choose a first task you can judge
- Pick one narrow job
For example, compare a few public sources in a short table.
- Say what done looks like
Name the reader, output file, source standard and anything the agent must leave alone.
- Enable the tools it needs
Give it web search or file access only if the job calls for them.
- Run it and inspect the work
Check the sources, tool calls, time taken and final file. Turn failures into test cases.
- Turn repeatable steps into a skill
Write the workflow, constraints and quality checks so the next run starts from a tested process.
Before you share it
Operate the service
- Set a deployment target and resource budget.
- Separate dev credentials from shared service credentials.
- Choose sandbox mode and review network exposure.
- Limit concurrency and observe provider spend.
Then evaluate
- Build a small set of representative tasks.
- Measure task completion and citation quality.
- Track tool errors, retries and output edits.
- Require review where errors carry real consequences.
The first task is your test
Check whether the agent can finish one realistic task, show what it did and leave an output you can review. Keep the workflow narrow until those pieces hold up.
Project sources
Checked 28 September 2026
This deck summarises project claims and documentation. Setup steps and capabilities can change with the repository.
DeerFlow 2.0 is a ground-up rewrite. The project maintains the original 1.x line separately.