Deer-flow Release History: From v0.1.0 Open Source Launch to the Deer-Flow 2.0 Roadmap

ByteDance open-sourced Deer-Flow in May 2025 at version 0.1.0, rapidly iterating through 2025 Q3–Q4 with MCP integration and multi-engine search capabilities, while the February 2026 roadmap announces a major Deer-Flow 2.0 architectural upgrade.

Deer-Flow is ByteDance's multi-agent research automation framework released under the MIT license. The current stable release is defined in backend/pyproject.toml as v0.1.0, though the repository has evolved significantly through continuous updates targeting improved sandbox management and tool integrations. Understanding the Deer-flow release history helps developers track breaking changes, leverage new skills, and prepare for the upcoming 2.0 transition.

Deer-flow Release Timeline and Version History

The repository maintains version metadata in backend/pyproject.toml, with the release evolution tracked through GitHub tags and commit history.

May 2025 Initial Open Source Release (v0.1.0)

On May 7, 2025, ByteDance publicly released Deer-Flow under the MIT license. The initial launch established the core multi-agent graph architecture built on LangGraph and LangChain, featuring five specialized agents: Coordinator, Planner, Researcher, Coder, and Reporter. The version string in pyproject.toml was set to:

version = "0.1.0"

This release included the foundational sandbox provider pattern defined in backend/src/sandbox/sandbox_provider.py and the local implementation in backend/src/sandbox/local/local_sandbox_provider.py.

2025 Q3–Q4 Feature Expansion

The third and fourth quarters of 2025 introduced substantial tooling upgrades without incrementing the minor version number. Key additions included:

• MCP (Model Context Protocol) integration for standardized agent communication
• Text-to-speech and podcast generation capabilities
• Multi-engine web search supporting Tavily, InfoQuest, Brave, DuckDuckGo, and Arxiv APIs
• Enhanced PDF parsing and document ingestion skills

During this period, the repository grew to 19,000 stars and 2,400 forks, reflecting rapid community adoption of the v0.1.0 baseline.

Early 2026 Stability Releases

January and February 2026 focused on bug-fix releases addressing:

• JSON repair handling for malformed agent outputs
• Sandbox port cleanup improvements in backend/src/utils/network.py
• Memory leak patches in the local sandbox provider

The release_port function in backend/src/utils/network.py received particular attention to prevent port exhaustion during high-concurrency research tasks.

Deer-Flow 2.0 Roadmap (February 2026)

The February 2026 roadmap announcement details Deer-Flow 2.0, promising upgraded architecture and new UI capabilities. While the current pyproject.toml still declares version = "0.1.0", the repository's README.md displays a "#1 on GitHub Trending (Feb 2026)" badge, indicating active development toward the 2.0 milestone.

Core Architecture Supporting Release Evolution

Each Deer-flow release maintains backward compatibility through stable interfaces while expanding capabilities via the skills system and sandbox management layer.

Sandbox Lifecycle Management

The sandbox provider pattern enables safe code execution across releases. The abstract interface in backend/src/sandbox/sandbox_provider.py defines three critical operations:

1. acquire() – Allocate an isolated environment
2. get() – Retrieve a running sandbox instance
3. release() – Terminate and clean up resources

Concrete implementations in backend/src/sandbox/local/local_sandbox_provider.py handle the container lifecycle, while backend/src/utils/network.py manages dynamic port allocation through get_free_port() and release_port().

Modular Skills Architecture

New features arrive as modular "skills" in the skills/public/ directory. For example, the github-deep-research skill in skills/public/github-deep-research/scripts/github_api.py demonstrates how release querying capabilities were added post-launch without modifying core agent code.

How to Check Your Current Deer-flow Version

Verify your installation matches the latest stable release by inspecting the project configuration:

import tomllib

with open("backend/pyproject.toml", "rb") as f:
    config = tomllib.load(f)
    
print(f"Deer-flow version: {config['project']['version']}")

This reads the canonical version string defined in backend/pyproject.toml. The SECURITY.md file advises running the latest available version to receive security patches.

Working with Release Data Programmatically

Deer-Flow includes built-in utilities for querying GitHub release history, useful for generating research reports or automation scripts.

Querying Repository Releases

Use the github-deep-research skill's API client to fetch release metadata:

from skills.public.github-deep-research.scripts.github_api import GitHubAPI

api = GitHubAPI()
releases = api.get_releases("bytedance", "deer-flow", limit=5)

for release in releases:
    print(f"Tag: {release['tag_name']}, Date: {release['published_at']}")

This script extracts tag_name, name, and published_at fields from the GitHub Releases endpoint, returning structured data about the Deer-flow release history.

Running Research Workflows

The high-level client in backend/src/client.py orchestrates multi-round research:

from backend.src.client import DeerFlowClient

client = DeerFlowClient()
skill = client.load_skill("github-deep-research")

result = skill.run(
    owner="bytedance",
    repo="deer-flow",
    steps=["summary", "releases", "issues"]
)
print(result)

This executes the complete research pipeline while automatically managing sandbox allocation through the LocalSandboxProvider.

Direct Sandbox Execution

For low-level sandbox interaction across any release version:

from backend.src.sandbox.local.local_sandbox_provider import LocalSandboxProvider

provider = LocalSandboxProvider()
sandbox_id = provider.acquire()
sandbox = provider.get(sandbox_id)

output = sandbox.exec("print('Deer-flow sandbox execution')")
print(output)

provider.release(sandbox_id)

The release() call triggers port cleanup via release_port() in backend/src/utils/network.py, ensuring resources return to the global allocator pool.

Summary

• Deer-flow v0.1.0 launched May 7, 2025, as ByteDance's open-source multi-agent framework under the MIT license.
• 2025 Q3–Q4 updates added MCP integration, podcast generation, and multi-engine search without version bumps.
• Early 2026 brought stability fixes for JSON handling and sandbox port management in backend/src/utils/network.py.
• Deer-Flow 2.0 is scheduled for 2026 with architectural upgrades and UI enhancements.
• Verify installed versions via backend/pyproject.toml and query release history programmatically using skills/public/github-deep-research/scripts/github_api.py.

Frequently Asked Questions

What is the current stable version of Deer-flow?

The current stable version is v0.1.0, defined in backend/pyproject.toml. While the repository has received numerous updates since the May 2025 launch, the maintainers have not incremented the minor version, instead releasing features as modular skills and architectural improvements. Monitor the GitHub Releases page for official tag announcements.

When was Deer-flow first released?

Deer-flow was first open-sourced on May 7, 2025. The initial public release established the LangGraph-based agent orchestration system and the sandbox provider pattern found in backend/src/sandbox/sandbox_provider.py. The release history is documented through Git tags and the project's README.md badge history.

What major features were added after the initial release?

Post-launch updates through 2025 Q3–Q4 introduced MCP (Model Context Protocol) support, text-to-speech capabilities, podcast generation, and multi-engine web search integrating Tavily, Brave, DuckDuckGo, InfoQuest, and Arxiv. Early 2026 releases focused on stability, improving JSON repair handling and sandbox port cleanup in backend/src/utils/network.py.

How do I upgrade to the latest Deer-flow version?

Upgrade by pulling the latest main branch commits and reinstalling dependencies. Check backend/pyproject.toml to confirm you are running version = "0.1.0" or newer. The SECURITY.md file recommends using the most recent commit for security patches. For programmatic version checking, use the github-deep-research skill or inspect pyproject.toml directly via Python's tomllib module.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}