Supervisor

The hierarchical multi-agent pattern. Anthropic Multi-Agent Research System (2026 internal report) + Anthropic Agent Teams (Feb 2026). The 2026 production consensus: hierarchical Supervisor is the multi-agent pattern that earns its cost in production. Anthropic reports +90.2% on their MA research benchmark vs single-agent baseline.

   prompt ───► manager ───► delegate(...) ─┬─► worker A ─┐
                              │            ├─► worker B ─┤  parallel
                              │            └─► worker C ─┤
                              ▼                          │
                          [worker outputs] ◄─────────────┘
                              │
                              ├─► synthesize ──► output
                              │
                              └─► forward_message(worker) ──► verbatim output

Pattern

The supervisor itself runs an architecture (default ReAct). Its tool host is augmented with two extra tools:

• delegate(worker, instructions). The named worker Agent runs to completion with the given instructions and returns its final answer as the tool result.
• forward_message(worker). Same as above but returns the worker’s output verbatim with no synthesis pass at the supervisor.

Because ReAct’s tool dispatch is already parallel (anyio.create_task_group over all tool calls in a turn), the supervisor gets parallel delegation for free. Emit two delegate calls in one turn and both workers run concurrently.

Usage

from loomflow import Agent
from loomflow.team import Team
 
researcher = Agent("Find sources, summarise key claims.",
                   model="claude-opus-4-7", tools=[search])
writer     = Agent("Draft the article.",
                   model="claude-opus-4-7")
reviewer   = Agent("Critique the draft for clarity and factual accuracy.",
                   model="gpt-4o")
 
team = Team.supervisor(
    workers={"researcher": researcher, "writer": writer, "reviewer": reviewer},
    instructions=(
        "Manage the article pipeline. Delegate research first, then "
        "writing, then a review pass. Synthesize the final answer."
    ),
    model="claude-opus-4-7",
)
 
result = await team.run("Write an article about agent harnesses.")

Or via the explicit Architecture form:

from loomflow import Agent
from loomflow.architecture import Supervisor
 
agent = Agent(
    "Manage the article pipeline.",
    model="claude-opus-4-7",
    architecture=Supervisor(workers={
        "researcher": researcher,
        "writer": writer,
        "reviewer": reviewer,
    }),
)

The two forms are interchangeable, Team.supervisor(...) is exactly Agent(architecture=Supervisor(...)) under the hood. Use the Team facade for single-level teams; use the explicit form for recursive composition.

Replay correctness

Each delegated worker run is journaled by (session_id, "delegate_<turn>_<worker>") in the runtime. With a SqliteRuntime or PostgresRuntime, a crash mid-supervisor-turn replays cleanly: completed worker runs return cached results; only the un-completed work re-executes.

When Supervisor pays off

• Specialist workers with distinct skills (research vs write vs review).
• Tasks decompose into chunks the supervisor can hand off without hand-holding.
• Cost is acceptable at 2–4× ReAct. Typical for important research, multi-source content generation, complex coding tasks.