Fan-Out Orchestrator
Run multiple sub-tasks in parallel across specialized agents, then synthesize. Avoids the single-loop serialization trap where everything waits on one slow step.
When to use
- ✅ Task naturally decomposes into 2+ independent streams
- ✅ Each stream benefits from a specialist's perspective
- ✅ You can describe the synthesis step clearly
- ❌ Streams depend on each other's output (use sequential instead)
- ❌ Streams are trivial (just do them yourself)
How
Layer 1 — Lean on OpenProse directly
OpenProse (already installed via open-prose plugin) is the engine. For ad-hoc fan-outs, write a .prose file and run it. Pattern template:
# parallel-research.prose
agent researcher:
prompt: "You are a research specialist. Gather, verify, synthesize. Cite sources."
parallel:
stream_a = session: researcher
prompt: "Research X — return sources + 200-word brief"
stream_b = session: researcher
prompt: "Research Y — return sources + 200-word brief"
stream_c = session: researcher
prompt: "Research Z — return sources + 200-word brief"
session "Synthesize streams A, B, C into a unified answer for Daniel"
context: { stream_a, stream_b, stream_c }
Run with: prose run parallel-research.prose
Layer 2 — sessions_spawn for inline fan-outs
For shorter fan-outs that don't need a full prose file, dispatch via sessions_spawn in parallel:
# Pseudo-pattern (run all in one assistant turn to maximize parallelism):
- spawn researcher → "look up X"
- spawn analyst → "evaluate Y"
- spawn writer → "draft Z"
- wait for all three, aggregate, return synthesis
Each call returns independently. Run them in the same tool-call block so they execute concurrently rather than sequentially.
Layer 3 — Specialist routing
When specialists exist in the agent topology (researcher/analyst/writer/coder — currently blocked on config unlock), pick the right one for each stream:
| Stream type | Specialist |
|---|---|
| Web search, source synthesis, fact-finding | researcher |
| Markets, prices, decision analysis, predictions | analyst |
| Polished prose, X drafts, articles, copy | writer |
| Code generation, debugging, review | coder |
Anti-patterns
- False parallelism: spawning streams that immediately need each other's output. Just run them sequentially.
- Over-decomposition: 10 tiny streams cost more in coordination than they save in time.
- Fan-out without synthesis: parallel work that returns raw streams is worse than one good answer.
- Serial spawning: calling
sessions_spawnone at a time across multiple turns. Always batch.
Output shape
Return:
- Per-stream result (concise)
- Synthesis (what the streams together imply)
- Tradeoffs / contradictions between streams
- Practical read for the user