Multi-Agent Coordination: Orchestrator and Subagent Patterns (2026)

When to Use

• ✓Tasks requiring specialized expertise across multiple domains (legal review + financial analysis + technical due diligence)
• ✓Parallelizable tasks where multiple subtasks can run simultaneously to reduce total latency
• ✓Tasks too long for a single context window — delegate sections to subagents with separate contexts
• ✓Systems requiring audit trails — each agent's work is logged independently, enabling granular review
• ✓Building agent systems where different teams own different subagent capabilities

How It Works

1. 1Orchestrator pattern: the orchestrator receives the full task, generates a plan, and issues subtask assignments to subagents. Subagents are LLM calls with specialized system prompts and tool sets. The orchestrator waits for results and synthesizes.
2. 2Define clear handoff contracts: what the orchestrator sends to the subagent (task description, context, constraints) and what the subagent must return (structured result, confidence, sources). Use JSON schemas for handoffs.
3. 3Parallel execution: when subtasks are independent, execute subagent calls concurrently. If the research agent and the financial analysis agent can work simultaneously, run them in parallel with asyncio.gather().
4. 4Result aggregation: the orchestrator receives all subagent results and synthesizes them. If subagents return conflicting information, the orchestrator must detect and resolve conflicts explicitly.
5. 5Fault isolation: if a subagent fails, the orchestrator can retry it, replace it with a fallback, or complete the task with a note about missing information — without crashing the whole pipeline.

Examples

async def orchestrate_company_research(company: str) -> dict:
    # Orchestrator plans and delegates
    orchestrator_plan = await llm_call(
        system='You are an orchestrator. Given a research task, identify 3-4 parallel subtasks and their required tools.',
        prompt=f'Research {company} for investment analysis. List parallel subtasks.'
    )
    
    # Define subagents (specialized system prompts + tool subsets)
    subagents = [
        SubAgent('financial_analyst', tools=['get_financials', 'get_earnings']),
        SubAgent('news_analyst', tools=['search_news', 'get_sentiment']),
        SubAgent('competitive_analyst', tools=['search_web', 'get_competitors']),
    ]
    
    # Execute all subagents in parallel
    subtask_results = await asyncio.gather(*[
        subagent.run(f'Research {company} for your specialty')
        for subagent in subagents
    ])
    
    # Orchestrator synthesizes
    synthesis = await llm_call(
        system='Synthesize these research findings into an investment thesis.',
        prompt=format_results(subtask_results)
    )
    return synthesis

# Enforce structured subagent output for reliable orchestrator synthesis
SUBAGENT_RESULT_SCHEMA = {
    'completed_task': 'string',  # What was accomplished
    'findings': 'list[string]',  # Key findings
    'confidence': 'number 0-1',  # Self-reported confidence
    'sources': 'list[string]',   # URLs or document refs
    'limitations': 'string',     # What the subagent couldn't determine
    'flags': 'list[string]'      # Anything the orchestrator should know
}

# System prompt addition for subagents:
'Always return your findings as JSON matching this schema. Include limitations — the orchestrator needs to know what you couldn't determine.'

Common Mistakes

• ✗Too many subagents for simple tasks — multi-agent adds coordination overhead (extra LLM calls, latency, complexity). For tasks a single agent can do in 5-10 steps, multi-agent is overkill. Use it only when parallelism or specialization provides clear value.
• ✗No handoff schema — subagents returning free-text results force the orchestrator to parse and interpret, introducing errors. Always define JSON schemas for subagent outputs and validate them before passing to the orchestrator.
• ✗Subagents with access to the full tool set — subagents should be restricted to the tools they need for their specialty. A news analysis subagent shouldn't have database write access. Principle of least privilege applies to agents.
• ✗Infinite delegation depth — orchestrators can spawn subagents that spawn sub-subagents, creating uncontrolled recursion. Set a maximum delegation depth (typically 2) and reject delegation requests beyond that depth.

FAQ