Sprout — a self-growing multi-agent task tree
An MIT open-source framework, designed solo: when a large task hits the token ceiling, Agents split into a task tree; the same test goes from 25 to 100.
What shipped
MIT open-source · 24 unit tests covering the core modules
Status
Under a fixed token budget: single Agent scores 25 vs. Sprout's 100
Head-to-head
Breaks past the token-budget bottleneck of a single LLM call
Core value
Problem
Multi-agent orchestration with preset roles — a fixed researcher / writer / reviewer — can't fit the true shape of a task; a single Agent, meanwhile, is choked by the token and attention bottleneck of one LLM call. The division of labor needs to grow out of the task itself.
Approach
The core value is not making AI faster; it is keeping large tasks from being cut off by a single-call length limit. Sprout uses a recursive tree architecture: analyze() first decides whether to split, execute() does the work; the parent generates a methodology for each subtask and injects it into the child Agent's system prompt, so roles emerge from the task; branches that lag about 2.5× behind siblings are canceled and re-split; max_depth / max_children / max_total_nodes / max_total_tokens keep the tree bounded.
AI's role in this project
The framework itself is multi-agent engineering: split decisions, straggler detection, result aggregation, and safety boundaries are all designed solo — a first-hand experiment in answering "what does multi-agent actually solve?"
Why I built it
Mainstream multi-agent orchestration runs on "preset roles": pin down researcher / writer / reviewer up front, then feed the task in. But the true shape of a task varies wildly — and a preset structure often doesn't fit. Sprout flips it around: don't preset the structure; let each Agent take its task and decide for itself whether to split, and how, so the task tree grows recursively, its depth decided by the task.
Four core designs
1. Two-phase Worker. analyze() makes a lightweight call to first decide "should this split?", then execute() does the actual work. Separating analysis from execution makes the split decision sharper — and saves tokens.
2. Approach injection. When a parent splits, it generates a methodology and focus for each subtask and injects them into the child Agent's system prompt — so the child Agent's "role" emerges from the task rather than being hand-assigned.
3. Straggler handling. If a branch takes markedly longer than its siblings (say 2.5×), it's canceled and re-split. Nodes die once done, and results bubble up to the parent.
4. Safety boundaries. Four ceilings — max_depth · max_children · max_total_nodes · max_total_tokens — keep the tree from exploding; 24 unit tests cover the core modules.
Head-to-head
Same task, fixed token budget: single Agent scores 25, Sprout scores 100. The takeaway: Sprout's core value isn't parallel speedup — it's breaking past the token-budget bottleneck of a single LLM call. Every node gets a full context budget to do its own small piece of the work.
Links
- Source: github.com/hlbbbbbbb/sprout (MIT)