Multi-agent handoffs and orchestrator-worker

How it works: multi-agent handoffs

1. Define specialist agents, each with focused instructions and a small tool set: triage, billing, technical support.
2. Give each agent handoff options: the agents it may transfer to, with descriptions of when.
3. A handoff is usually a tool call like transfer_to_billing. When the model calls it, your runtime switches the active agent.
4. The receiving agent sees the conversation (optionally filtered or summarised) and continues with its own instructions and tools.
5. Hand back or escalate when needed (to triage, or to a human).
6. Frameworks such as the OpenAI Agents SDK (handoffs=[...]) and LangGraph make this explicit.

How it works: the orchestrator-worker pattern

1. The orchestrator (lead agent) plans: it breaks the job into sub-tasks that can be done independently.
2. It delegates each sub-task to a worker with clear instructions: goal, scope, output format, budget.
3. Workers run in parallel, each in its own context with the tools it needs.
4. Workers return short, structured results, not their whole transcripts.
5. The orchestrator combines the results, checks gaps, and may launch another round.
6. Limit it: cap the number of workers, their steps and tokens; this pattern can multiply cost quickly.

How it works: subagents

1. A subagent is an agent started by another agent for a self-contained task, usually as a tool call ("research X and report back").
2. It gets a fresh, clean context with only what it needs, so reading 50 files or 30 web pages doesn't pollute the parent's context (context engineering).
3. It returns a concise result (a summary, a list, a decision) to the parent.
4. Typical uses: exploration and search, reviewing (a separate reviewer subagent checks the main agent's work), parallel research, and isolating risky tools in a more restricted subagent.
5. Coding agents commonly use subagents to search a codebase or review a change without filling the main session.

import asyncio
 
# ORCHESTRATOR-WORKER: one agent splits the job, workers run in parallel with their own small context.
async def worker(company: str) -> str:
    await asyncio.sleep(0.01)                          # stand-in for a worker agent's own LLM loop
    facts = {"Acme": "revenue up 12%", "Globex": "revenue down 3%", "Initech": "revenue flat"}
    return f"{company}: {facts[company]}"              # workers return SHORT results, not their whole transcript
 
async def orchestrator(task: str) -> str:
    subtasks = ["Acme", "Globex", "Initech"]           # a real orchestrator asks an LLM to plan these
    results = await asyncio.gather(*(worker(c) for c in subtasks))   # fan out, then gather
    return f"{task}\n- " + "\n- ".join(results)        # synthesise (another LLM call in real life)
 
print(asyncio.run(orchestrator("Compare Q3 for our three competitors")))
 
# HANDOFF: the active agent passes the WHOLE conversation to a specialist and steps aside.
AGENTS = {"triage": "routes questions", "billing": "handles invoices and refunds", "tech": "fixes login problems"}
def triage(message: str) -> str:
    return "billing" if "refund" in message or "invoice" in message else "tech" if "login" in message else "triage"
for msg in ["I need a refund", "My login fails"]:
    print(f"{msg!r}: triage -> handoff to {triage(msg)} ({AGENTS[triage(msg)]})")

Compare Q3 for our three competitors
- Acme: revenue up 12%
- Globex: revenue down 3%
- Initech: revenue flat
'I need a refund': triage -> handoff to billing (handles invoices and refunds)
'My login fails': triage -> handoff to tech (fixes login problems)