# AgentManager: From Dispatch to Active Management of LLM Sub-Agents

**Authors:** Simon Yu, [collaborators TBD]

## Introduction

Current meta-agent systems — from Claude Code's sub-agent dispatch [1] to Kimi's multi-agent coordination [2] to agent swarms like ClawTeam [3] — share a common architecture: decompose a goal into subtasks, dispatch an LLM agent for each, wait for results, collect. Each dispatch is a recursive invocation of a full reasoning system, not a tool call. Recursive Language Models [4] decompose long inputs by programmatically calling themselves over snippets of text; but when a meta-agent calls `claude -p "fix the authentication system"` and that agent in turn dispatches `claude -p "refactor the login module"` as a sub-task, we have **self-recursive language models** — LLMs that recursively invoke fully autonomous LLM agents with natural language instructions, creating execution trees of arbitrary depth where every node is as capable as the root. Yet the orchestrator treats each invocation as fire-and-forget. The result is a dispatcher, not a manager.

On multi-step benchmarks like SWE-EVO [5], agents that resolve 65% of individual issues succeed on only 21% of interdependent sequences — not because the agents lack capability, but because nobody is managing the execution: propagating context between sub-agents, intervening when a branch goes off-track, or learning from past orchestration failures. We propose AgentManager, a framework where the meta-agent is an **active manager** rather than a passive dispatcher. AgentManager gives contextual instructions to each recursive sub-agent, monitors their execution and intervenes proactively, and accumulates management skills from the structure of past execution trees. The key enabler is treating each sub-agent's execution not as a black box that returns success/fail, but as a stream of structured effects — files changed, tests broken, resources consumed — that the meta-agent can observe, reason about, and learn from.

## Problem Statement

Current meta-agent systems face three critical limitations. First, **static decomposition**: the execution tree is planned once upfront and never restructured during execution, even when sub-agent results invalidate later branches. Second, **context-blind dispatch**: every recursive sub-agent receives the same quality of instructions, regardless of what sibling or parent agents have already discovered. Third, **no cross-tree learning**: each new execution tree starts from scratch, never leveraging patterns from previous trees — for instance, the pattern that sub-agents modifying config files reliably cause downstream test sub-agents to fail.

A subtler but equally important challenge is **decomposition granularity**. The meta-agent must decide how much work to delegate in each sub-agent invocation. Consider fixing an authentication system: the meta-agent could dispatch one sub-agent with "fix the authentication system" (coarse), three sub-agents for "fix login bug," "add tests," and "update docs" (medium), or ten sub-agents each handling a single file edit (fine). Too coarse and the sub-agent flounders on a complex task. Too fine and the meta-agent micro-manages, wasting tokens and removing the sub-agent's ability to reason holistically. The optimal granularity depends on the task, the executor's capability, and what has been tried before — and it cannot be learned from outcome rewards alone, since a coarse dispatch that succeeds and a fine dispatch that succeeds both receive the same +1 reward despite radically different efficiency and robustness.

## Proposed Solution

AgentManager introduces structured execution **effect streams** as the meta-agent's feedback channel. Unlike scalar rewards (ToolOrchestra [6]) or text reflections (Reflexion [7]), effect streams capture the state delta of each sub-agent action: files modified, resources consumed, tests broken, dependencies changed. This structured signal is what allows the meta-agent to evaluate not just whether a decomposition worked, but *how* it worked — distinguishing a clean three-step execution from a messy ten-step one that happened to reach the same outcome.

The execution model is simple. The meta-agent holds a goal, decomposes it into sub-goals, and dispatches each as a natural language instruction to a sub-agent (e.g., `claude -p "fix auth.py"` or `codex exec "add tests"`). The method is executor-agnostic — any agent that accepts NL and returns results works as a sub-agent. The recursive structure emerges naturally: a sub-agent dispatched to "set up the experiment pipeline" may itself create child sub-agents for data preparation, training, and evaluation. The meta-agent manages the full tree.

We propose three levels of meta-agent intelligence, each building on the previous.

**Level 1: Post-hoc Skill Accumulation (train-free).** Effect streams from completed execution trees are compressed into reusable management skills. After observing across multiple trees that config-editing sub-agents cause downstream test failures, the meta-agent learns to insert a test-verification sub-agent after any config modification. Critically, effect streams also teach granularity: when past trees show that coarse dispatches for authentication tasks produce tangled diffs affecting 15 files while medium-grained dispatches produce clean, isolated changes, the meta-agent learns to prefer medium granularity for similar tasks. This is analogous to Voyager's skill library [8] but operates at the management level — learning patterns about how to structure and size execution trees, not how to solve individual tasks.

**Level 2: Proactive Intervention (train-free).** The meta-agent monitors effect streams from active sub-agents in real time, not just after completion. When a sub-agent's effects deviate from expected patterns — for example, editing 15 files when its instruction was to modify one, suggesting the decomposition was too coarse — the meta-agent intervenes by splitting the task into finer sub-agents, rewriting instructions, or pruning that branch entirely. This transforms the meta-agent from a root node that waits for leaf results into an active tree manager that shapes execution as it unfolds.

**Level 3: Learned Management Policy (trained).** We train an 8B meta-agent via GRPO to generate natural language instructions for recursive sub-agent dispatch. Unlike ToolOrchestra [6], which selects from a fixed tool set, our meta-agent's action space is open-ended NL generation — it learns what to say to each sub-agent, at what granularity to decompose, and when to intervene or restructure the tree. This is a weak-to-strong paradigm: a small trained model manages powerful executors. The training signal combines trajectory-level outcome rewards with per-node effect credit assignment, tracing which sub-agent instructions and tree-structuring decisions led to which downstream effects. This per-node credit is essential for learning granularity: outcome reward gives +1 whether the meta-agent used 3 or 10 sub-agents, but effect-based credit reveals that the 3-sub-agent tree produced cleaner effects with fewer conflicts, teaching the meta-agent to prefer that decomposition.

## Comparison to Prior Work

**vs. Hyperagents [9].** Hyperagents makes a better worker by self-modifying the executor's code through evolutionary search. AgentManager makes a better manager by learning how to structure execution trees, choose decomposition granularity, and communicate with sub-agents. A self-improving worker that nobody manages still cannot coordinate a 20-step pipeline or propagate context across recursive sub-agent calls. Hyperagents optimizes the leaf nodes; AgentManager optimizes the tree structure. These are complementary — a Hyperagent-improved executor is one possible sub-agent within AgentManager's recursive dispatch.

**vs. Agent Swarms (ClawTeam [3], CrewAI, AutoGen).** Swarm frameworks define static coordination topologies where agents message peers via inboxes or shared state. The topology is fixed at design time, and no swarm framework learns from execution history to improve coordination over time. AgentManager's execution tree is dynamic — sub-agents create new branches at runtime — and the meta-agent learns to structure better trees over time, including learning the right granularity of delegation for different task types.

**vs. ToolOrchestra [6].** ToolOrchestra trains an 8B model to select tools from a fixed menu using scalar rewards. AgentManager's action space is open-ended NL generation (write instructions for recursive sub-agents at varying granularity, not pick from a list), the training signal is richer (per-node effect credit through the tree, enabling granularity learning that scalar rewards cannot provide), and the scope is broader (multi-session trees with experience transfer). ToolOrchestra answers "which tool should I call?" AgentManager answers "what should I tell this sub-agent, how much should I delegate, and should I intervene now given what its siblings discovered?"

## Evaluation & Benchmarks

We evaluate on five existing benchmarks that expose meta-agent quality. **SWE-EVO** [5] (48 multi-step code evolution tasks, 21% SOTA) tests whether better tree decomposition and context propagation across sub-agents improves multi-step success — tasks where decomposition granularity directly determines whether sub-agents produce conflicting edits. **SWE-CI** [10] (100 tasks spanning 71 commits each) tests long-horizon recursive sub-agent coordination over extended commit sequences. **Recovery-Bench** [11] tests effect-aware failure diagnosis versus blind retry of sub-agents. **RE-Bench** [12] (ICML 2025, 7 research tasks with 2-32h budgets) tests time-budgeted multi-step sub-agent management where granularity choices determine whether the time budget is spent effectively. **REALM-Bench** [13] tests scheduling under dynamic disruptions requiring tree restructuring.

We additionally contribute **EffectBench**, a new benchmark with three evaluation dimensions. The first, *Meta-Agent Communication Quality*, tests whether better NL instructions produce higher sub-agent success rates — isolating the core meta-agent skill of writing effective instructions for each node. The second, *Proactive Intervention*, provides sub-agents with streamed effects and asks the meta-agent to decide when to intervene, with ground truth from human expert annotations. The third, *Experience Transfer*, trains the meta-agent on execution trees in Domain A and evaluates on unseen Domain B, testing whether management skills — including learned decomposition granularity — generalize across domains.

For each benchmark, we measure completion rate (end-to-end tree success), intervention quality (precision/recall of proactive interventions), communication quality (correlation between instruction quality and sub-agent success), learning curve (improvement as experience accumulates across trees), tree efficiency (total sub-agent invocations — fewer indicates better granularity choices), and recovery rate (successful tree restructuring after branch failures).

We compare against seven baselines: (1) single agent with no sub-agent dispatch, (2) static planner that decomposes once without adaptation, (3) ReAct + Reflexion with text-based reflection after sub-agent failures, (4) ToolOrchestra with RL-trained fixed tool selection, (5) ClawTeam with agent swarm peer messaging, (6) AgentManager train-free with skill accumulation and proactive intervention, and (7) AgentManager trained with 8B RL-trained meta-agent generating NL sub-agent instructions.

## Why This Matters

Modern LLM agents are powerful but stateless executors. Wrapping them in recursive dispatch — where each invocation is just another sub-agent call — creates execution trees of arbitrary depth and complexity. The question is no longer "can the agent solve this?" but "can the meta-agent manage a tree of agents to solve this?" The 21% to 65% gap between multi-step and single-step performance suggests the meta-agent, not the executor, is the current bottleneck. Success would shift the community's focus from building better individual agents to building better management of agent trees — from improving workers to improving managers.

## References

[1] Anthropic. (2025). Claude Code: Sub-agent dispatch and tool use. [placeholder — cite Claude Code technical report when available]
[2] Moonshot AI. (2025). Kimi K2: Multi-agent coordination. [placeholder — cite Kimi K2 technical report when available]
[3] HKUDS. (2026). ClawTeam: Agent Swarm Intelligence. github.com/HKUDS/ClawTeam.
[4] Zhang, A.L., Kraska, T., Khattab, O. (2025). Recursive Language Models. arXiv:2512.24601.
[5] Thai, M.V.T., Le, T., Nguyen Manh, D., Phan Nhat, H., Bui, N.D.Q. (2025). SWE-EVO: Benchmarking Coding Agents in Long-Horizon Software Evolution Scenarios. arXiv:2512.18470.
[6] Su, H., Diao, S., Lu, X., Liu, M., Xu, J., Dong, X., Fu, Y., Belcak, P., Ye, H., Yin, H., Dong, Y., Bakhturina, E., Yu, T., Choi, Y., Kautz, J., Molchanov, P. (2025). ToolOrchestra: Elevating Intelligence via Efficient Model and Tool Orchestration. arXiv:2511.21689.
[7] Shinn, N., Cassano, F., Berman, E., Gopinath, A., Narasimhan, K., Yao, S. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. NeurIPS 2023.
[8] Wang, G., Xie, Y., Jiang, Y., Mandlekar, A., Xiao, C., Zhu, Y., Fan, L., Anandkumar, A. (2023). Voyager: An Open-Ended Embodied Agent with Large Language Models. arXiv:2305.16291.
[9] Zhang, J., Zhao, B., Yang, W., Foerster, J., Clune, J., Jiang, M., Devlin, S., Shavrina, T. (2026). Hyperagents. arXiv:2603.19461.
[10] Chen, J., Xu, X., Wei, H., Chen, C., Zhao, B. (2026). SWE-CI: Evaluating Agent Capabilities in Maintaining Codebases via Continuous Integration. arXiv:2603.03823.
[11] Letta. (2025). Recovery-Bench: Evaluating Agentic Recovery from Mistakes. letta.com/blog/recovery-bench.
[12] Wijk, H., Lin, T., Becker, J., et al. (2025). RE-Bench: Evaluating Frontier AI R&D Capabilities of Language Model Agents Against Human Experts. ICML 2025. arXiv:2411.15114.
[13] Geng, L., Chang, E.Y. (2025). REALM-Bench: A Benchmark for Evaluating Multi-Agent Systems on Real-world, Dynamic Planning and Scheduling Tasks. arXiv:2502.18836.
