Supervisor Agent Pattern for Complex Tasks

Key facts, with sources

• Gartner predicts over 40 percent of agentic AI projects will be canceled by the end of 2027 due to escalating costs, unclear business value, or inadequate risk controls. (Gartner)
• Gartner predicts 33 percent of enterprise software applications will include agentic AI by 2028, up from less than 1 percent in 2024. (Gartner)
• Gartner estimates only about 130 of the thousands of vendors claiming to sell agentic AI are real, with the rest engaged in agent washing of existing chatbots and RPA products. (MarTech)
• McKinsey's State of AI 2025 found 23 percent of organizations are scaling an agentic AI system somewhere in the enterprise and another 39 percent have begun experimenting with agents. (McKinsey)
• Gartner forecasts 40 percent of enterprise applications will embed task-specific AI agents by the end of 2026, up from under 5 percent in 2025. (Joget)

Why single agents hit a wall

Two failure modes show up in every long single-agent run I have debugged. The first is context rot: forty tool results in, the window is mostly stale intermediate output, and the model starts missing instructions that were perfectly clear at turn one. The second is role conflict: a prompt that says "research thoroughly" and "write concisely" and "review critically" produces an agent doing all three halfheartedly at once.

The supervisor pattern attacks both. Each subagent gets a clean window containing only its subtask, so there is no rot to manage. And each specialist prompt holds exactly one role, so the researcher can be exhaustive while the reviewer stays adversarial — instructions that would fight each other in a shared prompt.

The mechanics: delegation as a tool call

The implementation is smaller than the diagram suggests: the supervisor is an ordinary tool-use loop whose most important tool is delegate. When the model calls it, your handler spins up a fresh messages array with the specialist's system prompt and the subtask, runs it to completion, and returns the final text as the tool result. The supervisor sees only that distilled result — none of the subagent's intermediate tool calls enter its context.

That containment is the entire point. A subagent can burn thirty turns exploring a dataset, and the supervisor's window grows by one tool result. I keep supervisor prompts focused on orchestration: decompose, delegate, evaluate what came back, decide whether to re-delegate or integrate.

from anthropic import Anthropic

MODEL = "claude-opus-4-8"  # use the latest model id

client = Anthropic()

SPECIALISTS = {
    "researcher": "You gather facts and note where each one came from.",
    "writer": "You turn research notes into clear, structured prose.",
    "reviewer": "You check drafts for errors and unsupported claims.",
}

def delegate(specialist: str, task: str) -> str:
    """Runs a subagent in a fresh context window."""
    response = client.messages.create(
        model=MODEL,
        max_tokens=4096,
        system=SPECIALISTS[specialist],
        messages=[{"role": "user", "content": task}],
    )
    return "".join(b.text for b in response.content if b.type == "text")

DELEGATE_TOOL = {
    "name": "delegate",
    "description": (
        "Hand a self-contained subtask to a specialist. The specialist "
        "cannot see this conversation, so include every fact it needs."
    ),
    "input_schema": {
        "type": "object",
        "properties": {
            "specialist": {"type": "string", "enum": list(SPECIALISTS)},
            "task": {"type": "string"},
        },
        "required": ["specialist", "task"],
    },
}

The context contract: subagents see nothing

Subagents cannot see the supervisor's conversation, and forgetting this is the number-one supervisor bug. A delegation that says "summarize the findings from earlier" returns garbage, because there is no earlier. The tool description has to state the contract bluntly — the specialist sees only what you put in the task field — and the supervisor prompt should instruct it to write delegations like briefs for a contractor: goal, all relevant facts, constraints, and the exact shape of the expected output.

When a supervisor system underperforms, I log the delegation strings first. More often than not the problem is a lazy brief, not a weak model, and one added line in the supervisor prompt about delegation completeness fixes it.

Parallel fan-out and integration

Independent subtasks should fan out concurrently — research three competitors, process five documents — and the pattern supports it naturally, because the model can emit several delegate calls in one turn. Execute them concurrently in your handler and return all tool results together in a single user message. Wall-clock time drops roughly with the width of the fan-out, which matters when a full run takes minutes.

Integration is the supervisor's real job once results land: reconcile disagreements between subagents, spot gaps, and re-delegate with sharper briefs where needed. I explicitly prompt for a reconciliation pass — where sources conflict, name the conflict and resolve or flag it — because the default behavior is to paste results together and call it done.

Costs, and when to skip the pattern

The pattern costs real money and latency: every delegation re-sends a system prompt and pays for a full subagent run, and a supervisor round-trip wraps every leaf task. For tasks under a handful of steps, a single agent is cheaper, faster, and simpler to debug — one transcript instead of a tree of them.

My heuristics for reaching for a supervisor: the task has clearly separable phases with different skill profiles; intermediate output is large but the conclusions are small; subtasks are independent enough to parallelize; or single-agent transcripts show late-run instruction drift. If none of those hold, do not add the layer. And one level of hierarchy is almost always enough — supervisors of supervisors multiply cost and failure modes faster than they add capability.

When to hire senior help

Senior help is most valuable at the architecture stage, deciding what to automate, where approval gates belong, and how business value will be measured, before any code is written. It is also worth bringing in when a stalled pilot needs risk controls and evaluation rigor to pass security and compliance review. If your stack includes React Native + Python + AI, a senior engineer who owns the full product beats coordinating multiple juniors.

Bottom line

Dhairya Senjaliya ships AI — Agentic AI Systems projects worldwide — book a scoping call to discuss your specific situation.

Common pitfalls to avoid

• ✕Buying agent-washed products, since Gartner estimates only around 130 of thousands of self-described agentic AI vendors are genuine rather than rebranded chatbots or RPA
• ✕Deploying autonomy before defining risk controls and human-approval gates, one of the three causes Gartner cites for the 40 percent of projects it expects to be canceled
• ✕Measuring activity like tasks attempted instead of business value, leaving the project unable to justify escalating costs at renewal time
• ✕Wrapping agents around existing processes instead of redesigning the workflow, when McKinsey finds workflow redesign is the single biggest driver of EBIT impact from gen AI

Frequently asked questions

Sources

• Gartner
• MarTech
• McKinsey
• Joget