featured · github
Deer: A Long-Horizon Agent Harness That Actually Finishes Multi-Hour Tasks
ByteDance's open-source SuperAgent framework handles research, coding, and creation across hours-long workflows using sandboxes, memory, and orchestrated subagents. Built for builders who need agents that don't lose the thread.
bytedance/deer-flow ↗Deer is a framework for building agents that can handle tasks spanning hours or days, not just single API calls. Think of it as a project manager for AI: it remembers what it's done, breaks complex work into smaller steps via subagents, runs code safely in sandboxes, and routes messages between components. A real use case: researching a market, writing code to solve a problem, then deploying it, all in one run without losing context. Most agent frameworks reset between steps or can't handle long execution chains. Deer adds memory layers and task orchestration so your agent stays coherent across a real workflow.
Share kit
Deer: The agent harness that handles multi-hour tasks (not just single steps)
ByteDance open-sourced Deer, a SuperAgent framework built for long-horizon work. Sandbox execution, memory persistence, subagent orchestration, and skill composition mean you can ship workflows that actually finish what they start, not just respond to isolated prompts. If you're building multi-step automation, worth a look.
Most agent frameworks reset between API calls. Deer doesn't. ByteDance's open-source harness keeps memory across hours-long tasks, orchestrates subagents, runs code safely in sandboxes, and lets you compose skills into real workflows. If you're shipping multi-step automation, this is the architecture you've been waiting for.
The hard part about agents isn't the LLM, it's the plumbing. Deer (ByteDance) solves that: persistent memory, sandboxed execution, subagent orchestration, and a message gateway that lets long-horizon tasks actually complete. Built by teams shipping production automation. Open source. Worth studying if you're scaling agentic systems.
Just found deer-flow from ByteDance, and it's solving a real problem I keep hitting: how do you actually orchestrate agents across multi-hour tasks without everything falling apart at task three. The architecture here is clean. Sandbox isolation so your agent doesn't hallucinate into production. Memory layer so context doesn't evaporate between steps. Subagent composition so you can break a 4-hour research+code+ship workflow into smaller, testable units. I've been watching the agent space splinter into either toy demos or proprietary black boxes. This sits in the middle: it's open, it's composable, and it handles the friction points I actually feel when building long-horizon automation. The message gateway piece is underrated too. Not just orchestration, but sensible async boundaries between components. If you're shipping task automation that takes more than 10 minutes end-to-end, worth a look.
deer-flow just landed on my radar. bytedance open-sourced an agent harness built for tasks that take hours, not seconds. the three things that stick: sandboxed execution (no hallucinations in prod), memory that persists across steps, subagent composition for breaking 4-hour workflows into checkpointable chunks. most agent frameworks assume sub-minute tasks. this one doesn't.