# DeerFlow Use Cases: 6 Practical Applications of the Super-Agent Harness

> Explore DeerFlow use cases and discover 6 practical applications of this open-source super-agent harness for automating research, content generation, data analysis, and complex workflows.

- Repository: [Bytedance Inc./deer-flow](https://github.com/bytedance/deer-flow)
- Tags: use-cases
- Published: 2026-03-08

---

**DeerFlow is an open-source super-agent harness that orchestrates sub-agents, memory, and sandboxes to automate deep research, content generation, data analysis, and multi-step workflows through a flexible skill system.**

DeerFlow 2.0, developed by ByteDance, is an open-source super-agent harness designed to execute sophisticated multi-step tasks by coordinating sub-agents, persistent memory, and sandboxed environments. Whether you need to synthesize research from multiple sources, generate multimedia content, or automate complex data pipelines, understanding the primary DeerFlow use cases helps developers leverage its modular architecture for production-ready AI applications.

## Deep Research and Document Analysis

DeerFlow excels at **deep research and summarization** by retrieving, reading, and synthesizing information from the web, PDFs, and code repositories. The system uses the `deep-research` and `github-deep-research` skills to autonomously search, crawl, and extract insights from multiple sources.

The research workflow relies on the **LangGraph Server** ([`src/agents/lead_agent/agent.py`](https://github.com/bytedance/deer-flow/blob/main/src/agents/lead_agent/agent.py)) to manage thread state and tool execution. When processing documents, the `UploadsMiddleware` creates virtual paths under `/mnt/user-data/` and makes uploaded files reachable to the agent, while the `SandboxMiddleware` acquires an isolated execution environment for safe tool operation.

To analyze a PDF document, use the embedded Python client with the `pdf-processing` skill:

```python
from src.client import DeerFlowClient

client = DeerFlowClient()
thread_id = "research-thread-001"

# Upload local PDF to thread workspace

upload_resp = client.upload_files(thread_id, ["./research-paper.pdf"])

# Extract key contributions using the agent

answer = client.chat(
    "Read the uploaded PDF and extract the key contributions, methodology, and limitations.",
    thread_id=thread_id,
)
print(answer)

```

Uploaded files are stored under `.deer-flow/threads/<thread_id>/user-data/uploads/` as implemented in `client.upload_files()` (see [`backend/src/client.py`](https://github.com/bytedance/deer-flow/blob/main/backend/src/client.py)), and the `pdf-processing` skill automatically becomes available during the subsequent agent run.

## Automated Report and Presentation Generation

One of the most common DeerFlow use cases involves **automated report generation** and slide deck creation. The `report-generation` skill produces markdown or HTML reports from raw data, while the `ppt-generation` skill creates PowerPoint presentations complete with charts and structured layouts.

This capability leverages the **Tool System** ([`src/tools/__init__.py`](https://github.com/bytedance/deer-flow/blob/main/src/tools/__init__.py)) which aggregates built-in tools like `present_file` with configured tools such as `web_search` and `bash`. The agent chains these tools to fetch data, analyze it, and format the output into publication-ready documents.

For streaming report generation:

```python
client = DeerFlowClient()

for event in client.stream("Write a comprehensive 5-page report on quantum-safe cryptography standards."):
    if event.type == "messages-tuple" and event.data["type"] == "ai":
        print(event.data["content"], end="", flush=True)

```

The streaming interface returns `StreamEvent` objects mirroring the SSE protocol (`values`, `messages-tuple`, `end`) defined in the client implementation, allowing real-time monitoring of report construction.

## Multimedia and Content Creation

DeerFlow supports **multimedia creation** through dedicated skills for generating images, videos, podcasts, and charts from textual prompts. The `image-generation`, `video-generation`, and `podcast-generation` skills interface with external APIs or local models to produce rich media content.

The **Skill Loader** ([`src/skills/loader.py`](https://github.com/bytedance/deer-flow/blob/main/src/skills/loader.py)) parses [`SKILL.md`](https://github.com/bytedance/deer-flow/blob/main/SKILL.md) files from `skills/public/` to register these capabilities as tools. Each skill definition specifies allowed tools and execution parameters:

```yaml
---
name: Video Generation
description: Generate short videos from textual prompts.
license: MIT
allowed-tools:
  - web_search
  - bash
  - present_file
---

```

Skills are lazily loaded—only those required for a given thread are parsed, keeping the token window small. The sandboxed execution environment ensures that media generation tools run safely without affecting the host system.

## Data Analysis and Visualization

For **data analysis and visualization**, DeerFlow combines the `data-analysis` skill with `chart-visualization` to execute Python scripts, create spreadsheets, and generate visual representations. The agent can load CSV files, perform statistical analysis using pandas or similar libraries, and output results as interactive charts or formatted tables.

The **Sandbox Providers** ([`src/sandbox/local.py`](https://github.com/bytedance/deer-flow/blob/main/src/sandbox/local.py), [`src/community/.../aio_sandbox.py`](https://github.com/bytedance/deer-flow/blob/main/src/community/.../aio_sandbox.py)) isolate execution of analysis scripts, supporting both local and Docker-based environments. This isolation is critical when executing arbitrary data processing code from external sources.

To list available analytical capabilities:

```python
client = DeerFlowClient()
skills = client.list_skills()

for s in skills["skills"]:
    if "analysis" in s["description"].lower() or "chart" in s["name"].lower():
        print(f"{s['name']}: {s['description']}")

```

This queries the skill catalog via `load_skills` in [`src/skills/loader.py`](https://github.com/bytedance/deer-flow/blob/main/src/skills/loader.py), which reads all [`SKILL.md`](https://github.com/bytedance/deer-flow/blob/main/SKILL.md) files under `skills/public/`.

## Web Development and UI Prototyping

DeerFlow enables **web and UI prototyping** through the `frontend-design` and `bootstrap` skills. The system can generate mock-ups, write front-end code (HTML, CSS, JavaScript, or framework-specific code), and even deploy static sites by coordinating with sandboxed build tools.

The **FastAPI Gateway** ([`src/gateway/app.py`](https://github.com/bytedance/deer-flow/blob/main/src/gateway/app.py)) provides REST endpoints for file uploads and artifact retrieval, enabling seamless integration with external deployment pipelines. The agent can write code, test it in the sandbox, and present the resulting files for download or deployment.

## Workflow Automation and Orchestration

The most powerful DeerFlow use case involves **automation of complex workflows** by chaining multiple skills into autonomous pipelines. Using **plan mode**, the system tracks sub-tasks through the `TodoListMiddleware`, enabling explicit task management across multi-step operations.

When initialized with `plan_mode=True`, the client enables the middleware chain that maintains the `todos` field in `ThreadState` (see [`ARCHITECTURE.md`](https://github.com/bytedance/deer-flow/blob/main/ARCHITECTURE.md)). This allows the agent to execute sequences like: fetch data → analyze → generate report → create presentation, with full state persistence across steps.

```python
client = DeerFlowClient(plan_mode=True)  # enables TodoListMiddleware

# Step 1: Research phase

client.chat(
    "Perform a web search on 'Edge-AI hardware trends 2024' and summarise the top 5 findings.",
    thread_id="edge-ai-research"
)

# Step 2: Visualization phase  

client.chat(
    "Create a bar chart visualising the performance-price trade-off of the top 3 devices mentioned.",
    thread_id="edge-ai-research"
)

# Step 3: Documentation phase

client.chat(
    "Write a markdown report that includes the chart and explains the implications for developers.",
    thread_id="edge-ai-research"
)

```

The **Memory Subsystem** ([`src/agents/memory/updater.py`](https://github.com/bytedance/deer-flow/blob/main/src/agents/memory/updater.py)) ensures that user-level memory persists across these thread interactions, allowing the agent to reference previous research in subsequent conversations.

## Summary

- DeerFlow combines a **LangGraph Server**, **FastAPI Gateway**, and **Embedded Python Client** to support six primary use cases: deep research, report generation, multimedia creation, data analysis, web prototyping, and workflow automation.
- The **Skill System** ([`src/skills/loader.py`](https://github.com/bytedance/deer-flow/blob/main/src/skills/loader.py)) enables lazy-loading of capabilities defined in [`SKILL.md`](https://github.com/bytedance/deer-flow/blob/main/SKILL.md) files, keeping context windows efficient while supporting extensible tool use.
- **Sandboxed execution** via Docker or local providers ensures safe operation of arbitrary code during data analysis and content generation tasks.
- **Plan mode** with `TodoListMiddleware` enables complex multi-step workflows with explicit task tracking and persistent memory across agent runs.
- File operations integrate through `UploadsMiddleware` which manages virtual paths under `/mnt/user-data/` for seamless document processing.

## Frequently Asked Questions

### What is DeerFlow used for?

DeerFlow is used for building autonomous AI agents that perform multi-step tasks including deep research across web and PDF sources, automated report and presentation generation, multimedia content creation (images, videos, podcasts), data analysis with visualization, web UI prototyping, and complex workflow automation. According to the bytedance/deer-flow source code, it functions as a "super-agent harness" that orchestrates sub-agents, memory, and sandboxes through a flexible skill system.

### How does DeerFlow handle file uploads in research workflows?

DeerFlow processes file uploads through the `client.upload_files()` method in [`backend/src/client.py`](https://github.com/bytedance/deer-flow/blob/main/backend/src/client.py), which stores files under `.deer-flow/threads/<thread_id>/user-data/uploads/`. The `UploadsMiddleware` ([`backend/src/agents/middlewares/uploads_middleware.py`](https://github.com/bytedance/deer-flow/blob/main/backend/src/agents/middlewares/uploads_middleware.py)) creates virtual paths at `/mnt/user-data/` and injects file metadata into the thread state, making documents immediately available to skills like `pdf-processing` during agent execution.

### What is the difference between the Python client and FastAPI gateway in DeerFlow?

The **Embedded Python Client** ([`backend/src/client.py`](https://github.com/bytedance/deer-flow/blob/main/backend/src/client.py)) provides direct in-process access to the agent runtime without HTTP overhead, ideal for scripting and automation. The **FastAPI Gateway** ([`backend/src/gateway/app.py`](https://github.com/bytedance/deer-flow/blob/main/backend/src/gateway/app.py)) exposes REST endpoints for model listing, skill management, file uploads, and artifact retrieval, making it suitable for external integrations and web applications. Both interfaces utilize the same underlying LangGraph server and skill system.

### Can DeerFlow generate multimedia content autonomously?

Yes, DeerFlow supports autonomous multimedia generation through specific skills including `image-generation`, `video-generation`, and `podcast-generation`. These skills are defined in [`SKILL.md`](https://github.com/bytedance/deer-flow/blob/main/SKILL.md) files under `skills/public/` and loaded by [`src/skills/loader.py`](https://github.com/bytedance/deer-flow/blob/main/src/skills/loader.py). The agent can chain these capabilities with research and analysis tools to create complete content pipelines—for example, researching a topic, generating explanatory images, and producing a video script in a single orchestrated workflow.