Supervisor
Owns the conversation, decides which specialist handles each part of the task, and assembles the final answer. It never needs direct access to every tool in the system.
Specialists that work together
Multi-agent orchestration without custom plumbing
Build teams of specialized agents that delegate work, use narrowly scoped tools, pass results through gates, and stream their progress to your product.
- multi-agent orchestration
- multi-agent orchestration platform
- AI agent orchestration
- agent workflows
Teams, not mega-prompts
Multi-agent orchestration: supervisors, specialists, and flow edges
One agent with thirty tools and a two-page prompt fails in ways you cannot debug. A team of specialists, each with a focused role and only the tools it should touch, fails in ways you can see — and fix.
Specialists
Each runs its own ReAct loop with its own model, prompt, and tool bindings scoped through flow config. A rules agent does not automatically gain access to billing tools.
Coordination
Agents coordinate via flow edges, transfer, and spawn — declared in configuration, not hidden in prompt text — so the shape of the system is reviewable before it reaches users.
Bounded autonomy
AI agent orchestration with spawn policies you control
Beyond static flow edges, a supervisor can spawn sub-agents at runtime — but only inside the boundaries you declare. The spawn policy lists exactly which flows may be spawned and caps how many run concurrently, and the engine detects spawn cycles so agents cannot recursively launch each other.
- Allowed flows list — spawning is a whitelist, never a default.
- Concurrency cap — bound how many sub-agents run in parallel per supervisor.
- Cycle detection — A→B→A spawn loops are stopped at runtime.
- Blocking control — spawn, wait, status, list, and stop actions let the supervisor manage sub-agents like processes.
- Hard time bounds — every agent turn is capped, 120 seconds by default, alongside per-agent step limits.
Spawn policyYAML
agent: research-supervisor
max_turn_duration: 120s # engine default
spawn_policy:
allowed_flows: # only these may be spawned
- market-research
- report-drafting
max_concurrent: 3 # parallel sub-agent cap
# spawn-cycle detection stops A -> B -> A loops
# blocking actions: spawn, wait, status, list, stop Nothing invisible
Agent workflows you can watch: delegation as structured events
Delegation is not a black box between request and response. Every handoff streams to your product as typed SSE events, so your UI can show real progress — “researching your order” instead of an unexplained spinner — and your engineers can replay the exact sequence afterward from the persisted session log.
This is a core difference from code-first frameworks where coordination lives in application code you maintain yourself. See how the approaches compare in SyntheticBrew vs CrewAI and SyntheticBrew vs LangChain.
Delegation over SSEevent stream
event: agent_spawn → sub-agent "market-research" starts
event: tool_call → search_catalog {"query": "…"}
event: tool_result → 42 records returned
event: agent_result → sub-agent hands findings back
event: message_delta → supervisor streams the answer
event: done → run complete, fully persisted Beyond the chat window
Multi-agent workflows for long-running background work
Not every job fits inside one conversation turn. Dispatch long-running agent work as background tasks tracked through the task system: sub-agents parallelize the work under the spawn policy's concurrency cap, gates validate the output before it is delivered, and the full run remains auditable after the fact. Teams in regulated and industrial settings use this pattern for report generation, reconciliation, and fleet analysis — see SyntheticBrew for banking and SyntheticBrew for manufacturing and IoT.
Per-agent tool scoping creates a real security boundary: a rules agent does not automatically gain access to organization or billing tools.
Keep exploring
Related capabilities
Questions
Multi-agent orchestration: common questions
What is multi-agent orchestration?
Multi-agent orchestration is coordinating several specialized AI agents on one task instead of overloading a single prompt. In SyntheticBrew, a supervisor agent owns the conversation and delegates to specialists via flow edges, transfer, and runtime spawning — each specialist with its own model, prompt, and narrowly scoped tools.
How do agents delegate work to each other?
Two ways. Transfer hands the conversation to another agent along a configured flow edge. Spawn launches a sub-agent at runtime, governed by a spawn policy, with blocking spawn, wait, status, list, and stop actions — so the supervisor can fire off parallel sub-agents and collect their results.
How do I stop sub-agents from spawning endlessly?
Spawning is opt-in and bounded. The spawn policy declares which flows an agent may spawn and caps concurrent sub-agents, spawn-cycle detection stops A-spawns-B-spawns-A loops at runtime, and every agent has its own step limit and a 120-second default turn duration.
Can I watch what each agent in the system is doing?
Yes. Delegation streams as structured SSE events — agent_spawn when a sub-agent starts, tool_call and tool_result while it works, agent_result when it hands back. Sessions persist the full event log for replay, and the audit log records the actor, action, resource, session, and task for every run.
Build the team. Keep the boundaries.
Orchestrate supervisors and specialists with scoped tools and spawn policies — in Cloud or on your own infrastructure.