A root orchestrator decomposes a complex task into domain-specific sub-tasks, each handled by a second-tier orchestrator that further decomposes into leaf agents. Results propagate back up the hierarchy and are synthesized at each tier.
A hedge fund deploys an automated investment research system. A single orchestrator running all research tasks becomes a coordination bottleneck at 50+ data sources. The fix: a three-tier architecture. A Root Orchestrator receives a thesis and spawns three Domain Orchestrators - macro, sector, and company. Each Domain Orchestrator spawns 3-5 specialist leaf agents: earnings analysts, patent researchers, sentiment scorers. Results synthesize bottom-up - leaf agents return to domain orchestrators, domain orchestrators return to root.
The result: the 3-tier system processes 120 data sources in 8 minutes versus 47 minutes linear. Parallelism at each tier compounds. The single-orchestrator bottleneck was not a compute problem - it was an architectural one. Decomposition authority belongs at each tier, not at the root.
| Metric | Signal |
|---|---|
| Tier-level completion time distribution | Identifies bottleneck tier - the tier with the highest variance in completion time is where reliability investment is needed first |
| Synthesis quality loss per tier | Information retention after each summarization step - measure by comparing leaf outputs to domain synthesis to root brief for key signal preservation |
| Spawn depth max | Safety parameter - actual observed max spawn depth vs. configured limit; any breach is a system integrity alert |
| Cross-tier dependency count | Hidden dependencies that break tier independence - leaf agents from different domains that implicitly require each other's outputs undermine the AND-parallel model |
| Node | What it does | What it receives | What it produces |
|---|---|---|---|
| Root Orchestrator | Reads investment thesis. Identifies which domains require investigation. Spawns one domain orchestrator per domain. Waits for all domain syntheses before final synthesis. | Investment thesis + domain registry | Domain dispatch plan + final research brief after synthesis |
| Macro / Sector / Company Orchestrators | Receives domain-scoped questions. Decomposes into specialist leaf tasks. Dispatches leaf agents in parallel. Synthesizes leaf outputs into a domain summary for the root. | Domain questions + data source registry | Domain synthesis: key signals, supporting data, confidence flags |
| Leaf Agents (GDP Analyst, FX Modeler, Rate Tracker, etc.) | Executes a single atomic research task: pull a data source, run a model, score a signal. Returns structured result to parent domain orchestrator. | Specific data access + scoped question | Structured atomic result: value, confidence, source reference |
| Domain Sync Nodes (Macro Sync, Sector Sync, Company Sync) | Collects all leaf results within a domain. Resolves conflicts. Produces domain-level narrative with supporting evidence for the root synthesizer. | All leaf results for that domain | Domain synthesis package: narrative + signals + gaps |
| Root Synthesizer | Combines all three domain syntheses. Identifies cross-domain relationships (e.g., macro rate signal contradicts company guidance). Produces final brief. | All three domain synthesis packages | Final research brief: thesis assessment, key risks, conviction score |
| Origin of Value | Where it appears | How it is captured |
|---|---|---|
| Future Cashflow | Root Synthesizer output quality | Research quality at root synthesis depends on how well domain orchestrators retain signal across the summarization chain. Each tier is a compression step - quality is bounded by the weakest tier's synthesis fidelity. |
| Governance | Root Orchestrator decomposition decision | Root Orchestrator holds planning authority - its domain decomposition is the governance decision. Which domains are activated, which are skipped, and how questions are scoped determines where compute is allocated and where it is not. |
| Risk Exposure | Tier-2 domain orchestrators | A tier-2 failure propagates to root synthesis failure. If one domain orchestrator stalls or returns a corrupted synthesis, the root synthesizer either waits indefinitely or produces a brief with a missing domain - both are critical failures for a research product. |
| Conditional Action | Every spawned agent | Each spawned agent is compute spend. The compounding parallelism is the primary economic argument for this pattern - but it holds only if tier-level coordination overhead is lower than the saved sequential time. |
VCM analog: Governance Token hierarchy. Root holds governance over domain orchestrators; each domain orchestrator holds governance over its leaf agents. Value flows up; authority flows down. A leaf agent that produces results without domain context is like a token holder voting without reading the proposal.
One domain orchestrator (e.g., Company Orchestrator) takes 3x longer than the others because its leaf agents are hitting rate-limited APIs. The Root Synthesizer AND-joins on all three domain syntheses - it cannot proceed until Company Sync completes. The Macro and Sector results sit idle, wasting their compute advantage. Fix: root must have a timeout-and-partial-synthesis path. If one domain misses its deadline, the root synthesizes with a flagged gap rather than blocking indefinitely. Parallel execution guarantees are only as strong as the slowest member.
Each domain orchestrator summarizes 5 leaf results into a domain synthesis package. The root synthesizer only sees the domain summaries - not the original leaf outputs. A critical signal from the Earnings Analyst (e.g., a footnote about a pending SEC investigation) gets dropped in the Company Sync's compression step. The root brief is coherent but misses the most actionable finding. Fix: establish a "critical signal escalation" protocol at each tier - leaf agents can flag results that must be forwarded verbatim to the root, bypassing the synthesis compression. Do not rely on summarization to preserve rare but high-value signals.
A domain orchestrator, finding its initial leaf results ambiguous, decides to spawn additional leaf agents to investigate further - treating itself as capable of recursive sub-orchestration. Without a depth limit, this creates unbounded spawning: a Company Orchestrator spawns a sub-orchestrator that spawns three more leaf agents, each of which spawns sub-agents. Compute spend grows exponentially. Fix: enforce a maximum spawn depth parameter at the root level, passed down to all orchestrators on instantiation. Any orchestrator at depth N must treat itself as a leaf - it can execute but not spawn further.
Root Synthesizer uses an AND-join gateway - it waits for all three domain synthesis packages before proceeding. If one domain orchestrator fails silently (returns nothing rather than returning an error), the AND-join waits forever. The hedge fund never receives its research brief. Fix: implement timeouts at each AND-join with explicit failure tokens. A domain orchestrator that exceeds its deadline emits a structured failure token - "Domain: Company, Status: timeout, Partial results: attached" - rather than silence. The root synthesizer treats this as a flagged gap and proceeds.
| Variant | Modification | When to use |
|---|---|---|
| Adaptive Tier Depth | Orchestrators self-decide whether to spawn a sub-tier based on task complexity - simple domains execute as leaves; complex domains spawn a sub-orchestrator | Domain complexity is heterogeneous - some domains need only 2 leaf agents, others need 15; fixed tier depth wastes structure on simple domains |
| Lazy Tier | Tier-2 orchestrators only spawn when root determines the domain is relevant after an initial assessment pass | Many domains are conditionally relevant - investing compute in all tiers upfront is wasteful when 2 of 5 domains are irrelevant for most inputs |
| Event-Driven Tiers | Leaf agents push results as events rather than synchronous return; domain orchestrators update their synthesis incrementally as events arrive | Leaf agent latency is high and variable; consumers can act on partial domain syntheses rather than waiting for all-or-nothing delivery |
| Pattern | Relationship |
|---|---|
| 20.23 Orchestrator-Workers | 2-tier version of this pattern - when domain structure is flat enough that a single orchestrator managing all workers is sufficient |
| 10.16 Staged Pipeline with Feedback | Sequential stages vs. parallel tiers - use staged pipeline when domains must process in order with quality gates between them |
| 10.11 Pipeline | Sequential alternative - if domains must be processed serially (each domain result informs the next), collapse to a pipeline with specialized stages |
Multi-tier architectures are harder to audit than flat ones. Each tier introduces a synthesis step that compresses information - and each compression step can lose or distort signals that were present in the leaf outputs. A firm with a 3-tier system that only measures root-level output quality cannot tell you where quality was lost.
The tier-level instrumentation gap is the primary valuation risk. If the firm cannot produce per-tier quality metrics - synthesis retention rate, tier completion time distribution, leaf signal escalation counts - the architecture is a black box above the leaf level. Acquirers inherit opaque compression logic with no way to improve it without full trace-log archaeology.
Acquisition thesis: the domain taxonomy and the synthesis protocols at each tier are the IP. Leaf agents are commodity specialists. The domain decomposition logic - which domains to activate for which thesis types - encodes the firm's research methodology and is not easily replicated from API calls alone.