Pattern Matrix/White Paper/C1

Problem

A single agent that researches, writes the body text, produces figures, and assembles the report all at once is not specialized in any of them, and across a long workflow its context keeps growing. The more subtle problem is this: when one agent processes several subtasks in sequence, the execution details of the earlier tasks stay in its context the whole time, and by the third or fourth task its reasoning quality starts to degrade.

Hierarchical delegation replaces "one all-purpose agent" with "one supervisor plus several specialized workers." The supervisor splits the task, monitors progress, and merges the output; each worker only does the one kind of work it is good at, running in its own isolated context. This lets each segment of work be handled by an appropriate model and prompt, and it also frees the supervisor's context from execution details so it can focus on coordination. The price is that token consumption rises by a multiple, so this pattern only fits scenarios where the value of the task can cover that multiple.

Classification: Collaboration × Hierarchy

• Vertical axis · Collaboration: This is genuine multi-agent role differentiation—the supervisor and the workers are different agents that carry different responsibilities, not an engineering abstraction inside a single agent. Researcher, Writer, and Visualizer each correspond to one professional capability, and this division of labor by occupational ability is the classic form of multi-agent collaboration.
• Horizontal axis · Hierarchy: The topology is a tree. The orchestrator sits on top and several workers sit below; workers do not communicate directly, and to exchange information they must go through the supervisor. This is a natural hierarchical structure, distinct from the fan-out aggregation of Parallel, the review loop of adversarial review, and the sequential handoff chain.

Solution and mechanics

A single hierarchical delegation consists of three stages:

1. Dynamic splitting: The supervisor decides, based on the specific input, how many workers to split into and what each worker does. Researching the AI industry and researching the coffee industry produce different subtask structures, so the split must be tied to the input and cannot be hardcoded.
2. Isolated execution: Each worker runs in an isolated context, does not inherit the supervisor's history, and receives only its own system prompt, its specific task instruction, and its own tool set. Workers run in parallel wherever they can.
3. Centralized synthesis: The supervisor looks only at the structured artifacts the workers return, not at the workers' raw trajectories, and makes its overall judgment and final merge based on these refined summaries.

The supervisor and workers usually use different models. The supervisor does the splitting and synthesis, which require deep reasoning, so it uses a strong model; the workers do specialized execution, so they use cheaper models. This is the same idea as Plan-and-Execute separating the planner from the executor, only extended from inside a single agent to across multiple agents.

The artifact a worker returns should have at least a three-field structure:

Applicability

• Long-workflow tasks with clear professional division of labor: industry research report generation, investment research analysis, new-drug R&D processes, where each stage needs a different professional capability.
• Isolated processing of batches of similar tasks: contract review, resume screening, document compliance scanning, where each item is handed independently to a worker to avoid mutual contamination and context explosion.
• Tasks valuable enough to cover the collaboration overhead: Compare a single-agent baseline with the delegated version on the same task set, including quality, latency, total tokens, and review effort.

Known failure modes

• The form of delegation without the spirit of isolation: the supervisor sees the worker's full execution process rather than a schema artifact, and after a few tasks its context is filled with details from earlier tasks, causing reasoning quality to fall off a cliff. Workers must reduce to a structured artifact before returning.
• Workers communicating directly: letting worker A call worker B to save effort turns the tree structure into a mesh structure and drives up the risk of cascade failure. The essence of hierarchical delegation is a tree, and breaking the tree structure breaks the isolation.
• No boundary on worker failure: a worker throws an uncaught exception, the supervisor receives a raw exception rather than a failure artifact, and the whole task is interrupted. Each worker needs a timeout plus exception wrapping.
• Too many parallel workers: As worker count grows, the supervisor may struggle to compare and synthesize the returned artifacts. Set the concurrency and fan-out limit from provider capacity, artifact size, and measured synthesis quality.
• Misuse in Collaboration Light scenarios: if the system has no genuine multiple roles and is only an engineering-level abstract split (for example, the same agent swapping a few prompts), hierarchical delegation should not be applied. It requires that there really be multiple agents with professional differentiation.

Verification and metrics

• Coordination overhead ratio: Measure the tokens and wall-clock time spent on supervisor-worker communication. If it dominates useful work, compress artifacts, reduce round trips, or use a lighter coordination channel.
• Worker failure cascade rate: Measure whether one worker failure interrupts unrelated branches or the supervisor. High-risk workflows should test isolation and partial-failure handling explicitly.
• Artifact compliance rate: Track whether worker returns conform to the schema. Free text that bypasses the contract creates redispatch, manual correction, and additional latency.
• Multi-agent cost ratio: Compare total tokens, model spend, and wall-clock time with the single-agent baseline. Fall back to a smaller delegation scope when the added value does not justify the overhead.

Reference implementation

SupervisorAgent.execute(task):
                plan = decompose(task)              # dynamic split, tied to the input
                artifacts = parallel gather(        # concurrency cap is configuration
                    IsolatedSubAgent(worker).execute(subtask)
                    for worker, subtask in plan
                )
                return synthesize(task, artifacts)  # look only at artifacts, not raw trajectory

            IsolatedSubAgent.execute(subtask):
                local messages = [system_prompt, subtask]   # do not inherit parent history
                try: raw = wait_for(llm(messages, tools), timeout)  # failure boundary
                except: return Artifact(verdict="failure", ...)
                return reduce_to_artifact(raw)      # force reduce to verdict/findings/confidence
            

Four engineering points: each worker starts in an isolated context; workers are forced to reduce to a schema artifact; each worker uses a timeout plus exception wrapping to isolate failures; a semaphore controls the concurrency cap, and workers share no state with one another.

Illustrative scenario

Consider a law-firm contract review agent. A first version lets every sub-agent return its full analysis, quickly filling the supervisor's context with detail. A stronger version assigns each contract to an isolated worker and requires a fixed-schema artifact containing contract_id, risk_level, top_concerns, recommendation, and a tamper-evident contract_hash. High-risk contracts enter a lawyer-review queue, timed-out workers return a failure artifact, and the portfolio report is retained for audit. Actual throughput and review quality must be evaluated on an authorized contract set.

Related patterns

• Sub-Agent Isolation (C5): the implementation core. Hierarchical delegation is the move (the supervisor dispatches workers), and sub-agent isolation is the inner skill (the worker's isolated context plus schema artifact plus failure boundary). Hierarchical delegation without isolation will inevitably suffer context explosion plus cascade failure, so the two must go together.
• Fan-out Aggregation (C2): also one-to-many, but the division logic differs. Hierarchical delegation is one-to-many by specialty (each worker does something different), while fan-out aggregation is one-to-many by volume (multiple workers do different parts of the same kind of work at the same time).
• Handoff Chain (C4): hierarchical delegation has a supervisor as a stable anchor, while a handoff chain has no supervisor and every leg is a peer.
• Plan-and-Execute (Action module): hierarchical delegation is its extension at the multi-agent layer, extending "plan-execute separation inside one agent" to "separation across multiple agents."

Design conclusion

Hierarchical delegation divides both work and information scope. The supervisor receives structured conclusions from the layer below instead of inheriting every worker's raw trajectory, keeping synthesis and responsibility boundaries manageable.