Skip to content

Multi-Agent Architecture

A multi-agent system is one parent agent with a list of sub-agents and a strategy that decides how they run. The strategy is a single field. Everything else — durability, retries, visibility of each delegation — comes from Conductor compiling the whole thing into a workflow.

support = Agent(
    name="support_supervisor",
    model="openai/gpt-4o-mini",
    instructions="Route each request to the right specialist.",
    agents=[billing, technical, sales],
    strategy=Strategy.HANDOFF,
)

Choosing a strategy

The dividing question is who decides: the model, the graph, or you.

Strategy Who decides Runs Reach for it when
handoff Model One sub-agent, conversationally A specialist should take over the conversation
router Model One sub-agent, no conversation You just need classification and dispatch
sequential Graph All, in order Each step builds on the previous output
parallel Graph All, at once Independent opinions you want to compare
swarm Sub-agents Until one finishes Agents should pass control between themselves
round_robin Graph Next in rotation Spreading load or alternating reviewers
random Graph One at random A/B comparison between agent versions
plan_execute Model, then graph A planned sequence, replanned as it goes The steps aren't knowable up front
manual You, in code Whatever you select Routing is a business rule, not a judgement call

Two practical notes. router is cheaper than handoff — it classifies and dispatches without handing over the conversation, so use it when there's nothing to converse about. And plan_execute is the only strategy that replans; the others commit to their dispatch decision.

The shapes

handoff and router. Sub-agents are exposed to the parent's model as callable tools.

support = Agent(
    name="support",
    model=MODEL,
    instructions="Route to billing, technical, or sales.",
    agents=[billing, technical, sales],
    strategy=Strategy.HANDOFF,   # or Strategy.ROUTER
)

sequential and parallel. The model isn't consulted about ordering.

pipeline = Agent(
    name="review_pipeline",
    model=MODEL,
    agents=[researcher, writer, editor],
    strategy=Strategy.SEQUENTIAL,   # or Strategy.PARALLEL
)

swarm. Control passes between sub-agents until one produces a final answer.

swarm = Agent(
    name="triage_swarm",
    model=MODEL,
    agents=[intake, diagnosis, resolution],
    strategy=Strategy.SWARM,
)

plan_execute. The model produces a plan of sub-agent calls, runs it, and revises when results come back.

planner = Agent(
    name="incident_planner",
    model=MODEL,
    agents=[log_reader, metrics_reader, remediation_drafter],
    strategy=Strategy.PLAN_EXECUTE,
)

What Conductor adds

  • Each delegation is its own execution. A specialist can retry without re-running the routing decision.
  • The choice is recorded. Which sub-agent ran, and why, is in the execution — not just in a log line.
  • Sub-agents keep their own tools and guardrails, so a billing agent can't reach fulfilment tools.
  • Parallel means actually parallel. parallel and fan-out compile to FORK_JOIN, not a loop.

Runnable examples in every SDK

Every strategy below is verified against main in all four SDKs.

Strategy Python Java TypeScript C#
handoff 05_handoffs.py Example05Handoffs.java 05-handoffs.ts 05_Handoffs
router 08_router_agent.py Example08RouterAgent.java 08-router-agent.ts 08_RouterAgent
sequential 06_sequential_pipeline.py Example06SequentialPipeline.java 06-sequential-pipeline.ts 06_SequentialPipeline
parallel 07_parallel_agents.py Example07ParallelAgents.java 07-parallel-agents.ts 07_ParallelAgents
swarm 17_swarm_orchestration.py Example17SwarmOrchestration.java 17-swarm-orchestration.ts 17_SwarmOrchestration
random 16_random_strategy.py Example16RandomStrategy.java 16-random-strategy.ts 16_RandomStrategy
manual 18_manual_selection.py Example18ManualSelection.java 18-manual-selection.ts 18_ManualSelection
plan_execute 108_plan_execute_refs.py Example108PlanExecuteRefs.java 108-plan-execute-refs.ts 108_PlanExecuteRefs

round_robin has no dedicated example yet; it takes the same shape as random, swapping the strategy value.

Next steps