Routes any request to the right
sub-agent automatically
Move beyond single skills to a top-level orchestrator that fans work out to research, coding, UI, and docs sub-agents in parallel — without babysitting. This is how teams scale past 10 skill files without prompt chaos.
Recommended Models
The orchestrator layer is the most important part of a multi-agent system — use a capable model here. Sub-agents can use cheaper models depending on the task.
| Model | Best For | Cost | Quality | |
|---|---|---|---|---|
| Claude Sonnet 4.6 | Best routing logic — understands sub-skill contracts reliably | Moderate | ★★★★★ | Recommended |
| GPT-5.4 | Strong function-calling for complex routing logic | Moderate | ★★★★★ | Recommended |
| Claude Opus 4.7 | Complex multi-step orchestration requiring deep planning | Expensive | ★★★★★ |
Temperature tip: Set to 0.2. Routing decisions need to be consistent and deterministic. High temperature causes the orchestrator to pick different sub-agents for the same request type — killing reproducibility.
Cost Estimate
⚡ Variable Tier
~$0.003
routing layer only · sub-agent costs added on top
~500
routing tokens / request
Scales
with sub-agent depth
Near-zero
routing overhead
The orchestration layer itself is cheap — about $0.003 per routing decision on Claude Sonnet 4.6. Total cost depends entirely on which sub-agents are invoked and how deeply they work. Use model routing (Haiku/Flash) for simple worker sub-agents.
Before & After Examples
The difference between a monolithic prompt and a properly orchestrated multi-agent system.
Landing page request Before — mega-prompt
"Build me a landing page." Sent to a single agent with a 2,000-token mega-prompt covering copywriting, UI design, SEO, and accessibility. Output is mediocre at all four. Changes cascade unpredictably.
After — orchestrated
routing: [
{skill: "copywriter", priority: "parallel"},
{skill: "ui-designer", priority: "parallel"},
{skill: "seo-optimizer", priority: "sequential",
depends_on: "copywriter"}
]
Before — routing by hand
Developer pastes code and manually picks which prompt to use — security review? style guide? logic check? Forgets half the specialists exist. Reviews are inconsistent across PRs.
After — auto-routed
Orchestrator detects "code review" intent and simultaneously dispatches: security-scanner, logic-checker, and style-guide specialists in parallel. Merged output covers all three in one pass.
Model Compatibility
✓ Works Best With
- Claude Sonnet 4.6 — best at maintaining routing contract fidelity
- GPT-5.4 — strong function-calling makes specialist handoffs clean
- Claude Opus 4.7 — for deeply nested multi-step orchestration
✗ Not Recommended
- Small models under 30B — routing logic breaks on edge cases
- High temperature settings — inconsistent routing on repeat requests
- Models without reliable JSON output for routing decisions
Chainable Skills
The Orchestrator sits at the top of a skill hierarchy. Every other skill is a potential sub-agent it can invoke.
Request In
Any user request
→
Orchestrator
Route · This skill
→
Specialists
Parallel sub-agents
→
Merged Output
Unified result
Pro workflow: Build your Specialist Stack first, then write the Orchestrator last. The orchestrator is only as good as the sub-agents it knows about — define each specialist's trigger and contract before writing the routing logic.
The System Prompt
Fill in the AVAILABLE SPECIALIST SKILLS section with your actual skill slugs and descriptions. The routing output is structured JSON — downstream tools can parse it programmatically.
List your specialists precisely. Vague skill descriptions ("handles writing stuff") produce garbage routing. Give each specialist one tight sentence: what it does, what it doesn't do, and what triggers it.
System Prompt
You are an orchestrator. Your job is to analyze incoming requests and route them to the right specialist skills.
AVAILABLE SPECIALIST SKILLS:
[List your specialist skills here with one-line descriptions]
ROUTING RULES:
1. Parse the request and identify the primary task type
2. Select the appropriate specialist skill(s) — multiple if the task is compound
3. If tasks can run in parallel, identify them explicitly
4. If tasks are sequential, define the handoff points
5. Never try to do the work yourself — always delegate to a specialist
OUTPUT FORMAT:
{
"request_type": "[identified task type]",
"routing": [
{
"skill": "[skill-slug]",
"task": "[specific task for this specialist]",
"priority": "[sequential|parallel]",
"depends_on": "[slug of skill that must complete first, if sequential]"
}
],
"notes": "[anything the caller should know about this routing decision]"
}
When routing is ambiguous, ask one clarifying question rather than guessing.
Routing Patterns
Three patterns cover most orchestration needs. Start with the simplest that fits.
- Fan-out (parallel) — one request → multiple specialists running simultaneously. Best for tasks with no dependencies (copywriter + designer + SEO can all work at once)
- Chain (sequential) — output of specialist A feeds specialist B. Use when later specialists need earlier output to function (SEO optimizer needs the copy first)
- Conditional routing — the orchestrator inspects the request and picks one of several paths. Use when request types are distinct and non-overlapping
Default to fan-out first. Most work is more parallelisable than it looks. Only add sequencing when a specialist genuinely can't start without another specialist's output.
Community Signals
642Total installs
4.6★Community rating
7.3Avg sub-agents routed
Most commonly paired with: Specialist Stack (89% of workflows), Prompt Chaining (56%), Memory Hack (44%). Nearly all Orchestrator users have a Specialist Stack folder — the two skills are designed to work together.
Ready to stop babysitting your AI stack?
Copy the prompt, fill in your specialist skills, and let the orchestrator do the routing.
✓ Prompt copied to clipboard