Multi agent orchestration: split by context, not by role

When one agent is not enough: three signals to check first

One agent is enough until it runs near its context limit, juggles overlapping tools, or scores low on your hard cases. The first two have cheaper fixes than a second agent. Anthropic's guidance says that outside a few such situations, coordination costs typically exceed the benefits². OpenAI's guide starts from the same place: maximize one agent first, and split when it keeps failing complicated instructions or picking the wrong tools³.

The first signal is context. An agent that routinely runs near its context limit while quality drops may be hitting context pressure, and Anthropic notes that compaction is pushing that limit out². So try compaction before you try a team.

The second signal is tools, and the sources disagree on the threshold. Anthropic's guidance puts it at 15 to 20 or more tools, and suggests on-demand tool search before a second agent². OpenAI says overlap matters as much as count: some agents manage more than 15 distinct tools while others struggle with fewer than 10 overlapping ones³.

LangChain's benchmark, a hundred examples on one model, shows where the drop comes.

The triage agent shows the overlap case. Its billing invoice lookup and its shipping order lookup sound alike, and it picks the wrong one on order disputes. The first fix is a rename and a description of what each returns.

The third signal is the baseline. In the same controlled study, tasks where a single agent already scored above 45% got negative returns from more agents, because coordination cost more than the headroom left¹. We have no score for the triage agent, so measure yours on your hard cases before you add anyone.

Where to cut: split by context, not by role

If the checks still point to a split after the cheap fixes, cut where the context splits, not where the job titles split. Anthropic's guidance says work should only be split when context can be truly isolated, because agents split by problem type play a telephone game and lose fidelity at each handoff².

The controlled study did not test roles, but it shows the same rule from the task side: the same move gains on work that splits apart and loses on work that runs in sequence¹.

Anthropic gives a test for the cut: isolation works best when a subtask generates more than 1000 tokens, most of it irrelevant to the main task, and has clear criteria for what to extract². Lookups that need filtering before use fit it best.

In the triage agent, the knowledge-base and past-ticket search passes that test. Compaction trims old turns, but every policy question still pulls whole articles into the window, and the lead needs only the few policy lines that apply. The refund decision does not split, as the first issue showed: the order and the payment facts must sit in one context.

Agent orchestration patterns and what each one passes along

Each orchestration pattern sets a default for what the next agent sees, and the patterns differ mostly in that default. In the Claude Agent SDK a subagent starts fresh, and the docs are blunt: the only content passed from parent to subagent is the Agent tool's prompt string⁵. In the OpenAI Agents SDK a handoff goes the other way, and the new agent sees the entire previous conversation unless you set an input filter⁶.

LangGraph's supervisor passes the full message history down by default⁷, and a LangGraph swarm by default puts every agent on one shared message list⁸. Microsoft's Magentic-One is a supervisor whose lead plans, tracks progress and re-plans to recover from errors⁹.

Anthropic's research system recorded two of these failures; the handoff and swarm costs are our read of their defaults. Anthropic's early research agents spawned 50 subagents for simple queries and distracted each other with updates¹⁰. In 2025 its lead agents waited for each set of subagents to finish, which kept coordination simple but created bottlenecks¹⁰.

In Claude Code, the orchestrator and worker pattern is a Markdown file. Each subagent runs in its own context window with its own system prompt, tool access and permissions¹¹, and only the name and description are required. The body states the four parts Anthropic says every worker needs: an objective, an output format, the sources to use and clear boundaries¹⁰.

---
name: policy-search
description: Finds the support policy lines that apply to one ticket. Use for refund, return and warranty questions.
tools: Read, Grep, Glob
---

Objective: find the policy lines that answer the question in the brief.

Output: at most three lines, each quoted exactly with its article id,
or "none found".

Sources: help articles in kb/articles and closed tickets in kb/tickets.

Boundaries: read only. Do not draft a reply, decide a refund or
summarise what you read.

A subagent can spawn subagents of its own, up to three layers below the main conversation by default¹¹. A search worker needs none, so its tool list leaves the Agent tool out. In the triage service, the same worker runs from the Agent SDK, and code builds the brief from the ticket, because that string is all the worker will see.

from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage

WORKER = open(".claude/agents/policy-search.md").read().split("---", 2)[2]

def brief(ticket_id: str, product: str, question: str) -> str:
    # The worker sees this string and nothing else from the ticket.
    return (
        f"Ticket {ticket_id}, product {product}.\n"
        f"Question: {question}\n"
        "Return at most three policy lines with their article ids."
    )

async def policy_lines(ticket_id: str, product: str, question: str) -> str | None:
    options = ClaudeAgentOptions(
        system_prompt=WORKER,
        allowed_tools=["Read", "Grep", "Glob"],
        disallowed_tools=["Bash", "Write", "Edit"],  # read only
        max_turns=10,
    )
    prompt = brief(ticket_id, product, question)
    async for message in query(prompt=prompt, options=options):
        if isinstance(message, ResultMessage):
            return message.result  # None if the run ended in an error
    return None

Keep every write with one agent and add readers

Search splits cleanly because it only reads, and the same reasoning says every write should stay with one agent. Cognition argued in 2025 that actions carry implicit decisions, conflicting decisions carry bad results, and you should by default rule out architectures that break that¹². Ten months later it ships multi-agent setups, on one condition.

The second agent with evidence behind it is a reader. Cognition reports that its review agent, which shares no context with the coding agent, still finds bugs in pull requests that coding agent wrote¹³. It is Cognition's own data, with no PR count given.

In the UC Berkeley failure study, adding one high-level verification step to ChatDev raised task success by 15.6%¹⁴. ChatDev is a research framework, not a production system, but the step that helped was a check on finished work, the reader role this section argues for.

In the triage service, the refund agent stays the single writer, and it only proposes. A policy reviewer agent gets the proposal and the policy lines, never the refund agent's reasoning, and either passes it or names the rule it breaks. A support lead approves, as in the first issue.

Cognition also found that agents assume they share state with their children when they don't¹³. That is why the reviewer gets its input written out in full.

What to do on Monday

1. Run the three signals. Check whether context runs near the limit, whether tools overlap or keep growing, and how one agent scores on twenty hard tickets you already have.
2. Fix the cheap ones first. Use compaction for context, and tool search plus clearer tool names and descriptions for tools.
3. Carve out one read-only subagent. Pick the lookup that reads the most and keeps the least, and give it a brief with an objective, an output format, sources and boundaries.
4. Keep one writer. Every action that changes data comes from one agent, and a reviewer with a clean context checks it before a person approves.
5. Trace every handoff. Log the brief that went in and the answer that came back, so a bad result points to the boundary that lost it.

Build it with me: the Free Live Lab Build a Multi-Agent System with MCP, live on Thursday, October 29.