ByteDance's 74K-Star AI Agent: Runs 3 Hours Without Crashing, Forgetting, or Getting Confused — I Used It for a Full Day of Work

If your AI Agent only lives for 5 minutes, it's not an assistant — it's a pop-up.

You ask it to "research competitors, write an analysis report, generate a PPT", and 5 minutes later it says "done" and hands you a 200-word summary. You ask it to "help me migrate this project from Python to Go", and it writes halfway before running out of context and starting from scratch. You ask it to "track the latest progress in this technical direction for a month", and it directly tells you, "I can't remember what happened before."

Crashing, forgetting, getting confused — these are the three terminal illnesses of current AI Agents.

ByteDance's open-source project DeerFlow 2.0, with 74K stars, is here to cure them.

Not a Framework, but a Harness

First, a key concept: DeerFlow 2.0 is not a framework — it's a harness, a runtime infrastructure that enables an Agent to truly complete tasks.

What's the difference?

A framework gives you parts to assemble yourself. A harness gives you a drivable car — just step on the gas.

DeerFlow 2.0 is a complete rewrite from v1 by ByteDance, sharing no lines of code with 1.x. v1 was a Deep Research framework; v2 is a Super Agent Harness. This upgrade is not a feature iteration — it's a species evolution.

It comes with key capabilities that Agents actually use: file system, memory, skills, sandbox execution environment, and sub-agent orchestration. It's built on LangGraph and LangChain, but you don't need to assemble anything — it's plug-and-play, yet sufficiently extensible.

Three Prescriptions to Cure the Three Terminal Illnesses

First Prescription: Sandbox Execution — Cures "Crashing"

Ordinary Agents crash every 5 minutes on complex tasks. Why? Because they share the same environment as your system — writing wrong files, exhausting memory, network timeouts — any of these can kill it.

Each task in DeerFlow runs in an independent Docker container. Full file system, independent network policies, controllable resource quotas. The Agent can do whatever inside without crashing your host.

/mnt/user-data/
├── uploads/          ← your uploaded files
├── workspace/        ← Agent's working directory
└── outputs/          ← final deliverables

What's more powerful is checkpoint resume. If a task is interrupted, it resumes from the checkpoint without starting over.

Three sandbox modes: local development, Docker container, Kubernetes Pod — covering everything from individual development to enterprise clusters.

Second Prescription: Three-Layer Memory — Cures "Forgetting"

You chatted with AI for 3 hours, and by the 4th hour it says, "What were we talking about?" — everyone has had that experience.

DeerFlow has a three-layer memory system:

• Short-term memory: context of the current conversation, ensuring immediate coherence
• Long-term memory: knowledge graph, remembering your preferences, knowledge background, and work habits across sessions
• Working memory: task execution state, so long tasks don't lose track of "what I was just doing"

Ordinary Agents lose information when the context window fills up. DeerFlow has a dedicated summary compression mechanism — summarizing completed sub-tasks, transferring intermediate results to the file system, compressing temporarily unimportant information. It's not about stuffing more tokens, but intelligently managing limited context space.

Memory data is stored locally, with control always in your hands.

Third Prescription: Sub-Agent Collaboration — Cures "Getting Confused"

What's the worst thing about complex tasks? Confusion.

A task like "research the AI market" requires searching, analyzing, writing a report, and making a PPT. One person doing it? Inefficient. Doing it sequentially? Too slow.

DeerFlow's approach: automatic decomposition, parallel execution.

The Lead Agent receives the task, plans it, and dynamically spins up Sub-Agents as needed. Each Sub-Agent has its own independent context, tools, and termination conditions. As long as conditions allow, they run in parallel, returning structured results, finally aggregated by the Lead Agent.

Key design detail: each Sub-Agent's context is fully isolated — it can't see the Lead Agent's context, nor other Sub-Agents' contexts. This means the intermediate state of one subtask doesn't pollute another, and parallel execution doesn't interfere.

Skills System: Adding Capabilities to the Agent Like Installing Apps

The secret to DeerFlow's ability to do "almost anything" lies in its Skills system.

A Skill is a Markdown file defining workflows, best practices, and reference resources. DeerFlow comes with built-in Skills:

/mnt/skills/public
├── research/SKILL.md           ← Deep research
├── report-generation/SKILL.md  ← Report generation
├── slide-creation/SKILL.md     ← PPT creation
├── web-page/SKILL.md           ← Web page generation
└── image-generation/SKILL.md   ← Image generation

You can also write your own:

/mnt/skills/custom
└── your-custom-skill/SKILL.md  ← Your Skill

On-demand progressive loading — not all Skills are stuffed into the context at once; only those needed are loaded.

Tools follow the same approach. Built-in web search, web scraping, file operations, bash execution; also supports extending custom tools via MCP Server and Python functions. Even Claude Code can be directly integrated — install a skill:

npx skills add https://github.com/bytedance/deer-flow --skill claude-to-deerflow

Five Major IM Channels: Chat Window as Agent Console

DeerFlow supports receiving tasks directly from instant messaging apps without a public IP:

Once configured, just send tasks in the chat window. It also supports several useful commands:

• /new — Start a new conversation
• /status — View current thread info
• /models — List available models
• /memory — View memory

From "open terminal and type commands" to "say one sentence in a Feishu group" — this experience gap is huge.

Python Client: Embedded Agent

If you don't want to start the full Gateway+Frontend+Nginx+Docker stack, DeerFlow also provides an embedded Python Client:

from deerflow.client import DeerFlowClient

client = DeerFlowClient()
response = client.chat("Help me analyze this paper", thread_id="my-thread")

# Stream output
for event in client.stream("hello"):
    if event.type == "messages-tuple" and event.data.get("type") == "ai":
        print(event.data["content"])

# Manage models and skills
models = client.list_models()
skills = client.list_skills()
client.update_skill("web-search", enabled=True)

There's even a Terminal UI (TUI), start with one command:

uv pip install 'deerflow-harness[tui]'
deerflow                    # Start terminal UI
deerflow --continue         # Resume most recent session
deerflow --resume THREAD    # Resume specific session by ID
deerflow --print "Summarize"  # Headless mode

Deployment: One Docker Command

git clone https://github.com/bytedance/deer-flow.git
cd deer-flow
make config         # Generate config file
make docker-init    # Pull sandbox image
make docker-start   # Start services

Visit http://localhost:2026 to use.

Models are not tightly bound — any LLM implementing the OpenAI-compatible API can be connected. Recommended: Doubao-Seed-2.0-Code, DeepSeek v3.2, Kimi 2.5, or GPT-4, Gemini 2.5 Flash — your choice.

From Deep Research to Super Agent: The Roadmap Debate

DeerFlow's evolution path is itself a microcosm of the industry.

In the 1.x era, it was a Deep Research framework — specialized for deep research. But after launch, developers used it for far more: building data pipelines, generating PPTs, quickly creating dashboards, automating content workflows. Many use cases even surprised ByteDance.

This exposed an industry truth: Agents should not be limited by scenarios. You make a research tool, and users use it for creation; you make a programming assistant, and users use it for operations. Demand always outpaces the product.

So v2 was rewritten from scratch, upgrading from a "research framework" to a "Super Agent Harness" — not giving you a hammer to find nails, but giving you a toolbox to hammer any nail.

This mirrors the roadmap debate with Mem0 (the AI memory system made by the "Resident Evil" protagonist): do you build a refined tool for a vertical scenario, or a general-purpose infrastructure? DeerFlow 2.0's answer is clear — be a harness, not a framework.

One Sentence Summary

DeerFlow 2.0 lets you use a Super Agent framework to replace manual task decomposition + multi-tool switching + result aggregation, so long-running tasks of several hours run stably from start to finish — no crash, no forget, no confusion.

GitHub: https://github.com/bytedance/deer-flow

74K stars, MIT license, ByteDance-grade engineering quality. Deserves a star.

Found it useful? Share it with friends still struggling with AI Agents.