2000 character limit reached

Coordinator–Worker–Sub-agent Architecture

Updated 16 November 2025

Coordinator–worker–sub-agent architecture is a hierarchical design pattern that decomposes complex tasks into role-specialized modules for planning, management, and execution.
It defines clear agent roles where the coordinator handles high-level planning, workers manage local contexts, and sub-agents execute fine-grained tasks.
This architecture enhances scalability, robustness, and flexibility through modular task decomposition and efficient communication protocols.

The coordinator–worker–sub-agent architecture is a hierarchical design pattern for multi-agent systems that decomposes complex tasks into modular, role-specialized subtasks. Its core motivation is scalable coordination, robust specialization, and flexible orchestration of autonomous agents. The paradigm has been instantiated in numerous state-of-the-art systems for information retrieval, scientific reasoning, desktop automation, cooperative reinforcement learning, and hierarchical task solving. The specifics of task decomposition, communication protocols, agent autonomy, and error recovery vary, but foundational principles remain the separation of planning (coordinator), subtask management (workers), and primitive execution (sub-agents).

1. System Decomposition and Layer Definitions

In paradigm examples such as the blackboard system for data science information discovery (Salemi et al., 30 Sep 2025), self-organizing S-Agents (Chen et al., 7 Feb 2024), generalist orchestration frameworks (AgentOrchestra (Zhang et al., 14 Jun 2025); OrchVis (Zhou, 28 Oct 2025)), and hierarchical RL approaches (FMH (Ahilan et al., 2019)), the architectural roles are formally defined as:

Coordinator (Main Agent, Planner, Controller): Interprets global objectives, parses user queries, maintains system state, performs high-level planning, issues requests, and aggregates program outputs. Operates at the meta level.
Workers (Helper Agents, Manager, Worker System, Worker Agents): Receive explicit delegated requests, decompose them (if applicable), manage local context, and select or assign subtasks to specialized executors.
Sub-agents (Auxiliary Agents, Specialized Executors, Action Planners): Execute fine-grained domain tasks via specialized toolkits (e.g., file search, symbolic deduction, code execution), often operating asynchronously and autonomously.

In blackboard systems (Salemi et al., 30 Sep 2025), the partitioning of a large data lake $D=\{d_1,...,d_N\}$ into $C$ clusters $D_1,...,D_C$ prefigures $C$ file worker agents $\pi_{f_i}$ , each with local-only access for scalability (context size $O(|D_i|)\ll O(N)$ ). This principle generalizes: workers tackle only manageable subspaces, and sub-agents further abstract away low-level execution.

In S-Agents (Chen et al., 7 Feb 2024), the tree-of-agents graph $G=(V,E)$ enforces a pure hierarchical (ToA) structure: a single root (coordinator), leaves (workers), edges only from root to leaf. In OrchVis (Zhou, 28 Oct 2025), the hierarchy is made explicit in the goal graph $G_{hier}$ , with coordinator, intermediate workers, and leaf sub-agents.

2. Communication Protocols and Coordination Algorithms

Coordinator–worker–sub-agent systems leverage multiplexed communication channels or shared data structures to orchestrate agent collaboration. Key protocol features include:

Blackboard paradigm (Salemi et al., 30 Sep 2025): The coordinator posts natural-language requests to a write-only shared blackboard $\beta$ , with each request $r$ spawning a dedicated response board $\beta_r$ for asynchronous worker replies. Workers poll for relevant requests, volunteer responses only when applicable, and coordinator aggregates and integrates outcomes, avoiding explicit subtask assignment and agent registry dependence.
Tree-of-agents asynchrony (Chen et al., 7 Feb 2024): All agents interact via a shared message pool $M$ ; non-obstructive collaboration allows workers to execute and report independently, never blocking for slow agents.
Semi-centralized agent-to-agent collaboration (Ren et al., 23 Aug 2025): Anemoi's MCP server establishes threads $\tau$ ; planner, workers, critique, and answer-finding agents interact through primitives (send_message, wait_for_mentions) formalized as state transitions $S_t\xrightarrow{i_t} S_{t+1}$ and consensus voting. Real-time critique and plan adaptation are supported.
JSON-RPC and function calling (Zhang et al., 14 Jun 2025, Zhou, 28 Oct 2025): Coordinators interact via standard RPC endpoints (plan, assign, mark, execute); workers or sub-agents respond with status and structured output.
FSM-based orchestration (Guo et al., 14 Sep 2025): The controller transitions among states ({REPLAN, SUPPLEMENT, GET_ACTION, EXECUTE_ACTION, QUALITY_CHECK, FINAL_CHECK, DONE}) via triggers from workers, manager, and evaluator, with routing determined in each situation by the assigned subtask and its role tag.

In these architectures, subordinate agent autonomy is maintained (self-selection in blackboard, non-blocking execution in ToA, parallel refinement and voting in Anemoi). Coordinator logic is lightweight (blackboard), plan/role discovery is dynamic (AgentOrchestra), and communication redundancy is handled by ignoring duplicate volunteer replies or aggregating sub-agent outputs.

3. Mathematical Models and Formal Characterizations

Architectures are grounded in explicit mathematical models:

Blackboard system (Salemi et al., 30 Sep 2025):
- Data lake $D = \{d_i\}_{i=1}^N$ ; query $q$ ; program $p$ generated by policy $\pi_s:(q;D)\to p$ .
- Success metrics: $μ_{generation}(p;q)\in[0,1]$ (program correctness); $μ_{retrieval}(p;Q)$ (file recall/precision, F₁).
- Partitioning: worker agent cost scales as $O(|D_i|)$ .
- Coordinator action space $A = \{\text{Plan}, \text{Reason}, \text{ExecCode}, \text{RequestHelp}(r), \text{Answer}\}$ under budget $T$ .
Tree-of-agents collaboration (Chen et al., 7 Feb 2024):
- Directed graph level structure; hourglass bottleneck $O = f_{filter}(\text{Percept}_p, \text{Chat}_A)$ ; hierarchical planner expands objectives.
Anemoi protocol (Ren et al., 23 Aug 2025):
- Plan-generation $\pi_t$ ; assignments $\phi:\mathcal{W}\to\mathcal{T}$ ; consensus voting $C(\{v_i\})$ ; error-rate formula for distributed critique
$ε_\text{eff} \approx P(\text{majority of $k$ agents err}) = \sum_{i=\lceil (k+1)/2\rceil}^k C(k,i) ε^i (1-ε)^{k-i}$
OWL decompositional notation (Hu et al., 29 May 2025):
- $\mathcal{A}=(M,\mathcal{O},\mathcal{T},\pi)$ as agent; planner decomposes $T$ over workers $\mathcal{P}.\mathrm{decompose}(T,\mathcal{W})$ ; DPO RL objective for planner optimization.
Orchestration cost/prioritization formulas (Zhang et al., 14 Jun 2025, Zhou, 28 Oct 2025):
- Role matching: $s(a,g) = \mathrm{sim}(\mathrm{capabilities}(a),\mathrm{requirements}(g)) + \lambda \cdot \mathrm{latencyPenalty}(a)$ .
- Subgoal prioritization: $\pi(g_i) = \alpha \cdot \text{depth}(g_i) - \beta \cdot \text{estCost}(g_i)$ .
- Communication overhead: $T_\mathrm{comm} = \sum_{k=1}^M(L_\mathrm{latency} + S_k/B_\mathrm{bandwidth})$ .

4. Task Decomposition, Role Assignment, and Execution Workflows

Task decomposition proceeds via explicit, formal coordination loops. Key algorithmic principles include:

Main agent (coordinator) loop (Salemi et al., 30 Sep 2025):
- Iteratively decides action $\mathbf{a}_t$ , posts requests, collects worker responses, executes code or reasoning steps, and generates the final program.
Worker agent loop (Salemi et al., 30 Sep 2025, Ren et al., 23 Aug 2025, Guo et al., 14 Sep 2025):
- Poll for requests/assignments, evaluate relevance, generate plans, reply; possibly perform further task decomposition internally (subgoal breakdown, internal index construction).
Sub-agent (specialist) loop (Zhou, 28 Oct 2025, Li et al., 11 Nov 2025):
- Receive subtask, invoke dedicated tools (web search, code execution, symbolic verification), reply with structured result or evidence, request clarification if underspecified.

Role assignment may be statically defined (FSM label from DAG in Agentic Lybic (Guo et al., 14 Sep 2025)), learned/decomposed (planner/worker assignment in OWL/Anemoi), optimized via matching (AgentOrchestra (Zhang et al., 14 Jun 2025)), or autonomously selected (blackboard (Salemi et al., 30 Sep 2025)). Multi-level review or critique loops support pipeline verification (SciAgent (Li et al., 11 Nov 2025), Anemoi (Ren et al., 23 Aug 2025)).

5. Comparative Analysis with Alternative Architectures

Coordinator–worker–sub-agent systems address deficiencies in flat, master-slave, or monolithic approaches. Notable comparison points:

Paradigm	Assignment	Controller Knowledge Needed	Robustness / Scalability
Master-Slave	Explicit	Registry of capabilities	Rigid, requires controller expertise, ambiguous on overlaps
Shared-Memory	Explicit	Same as above	Controller allocates, agents passive
Blackboard	Decentralized	None	Agents volunteer, scales with partitions, eliminates registry dependence
Hierarchical RL	Subgoal	Via manager	Private per-agent rewards, linear scaling, stable training

In blackboard and related systems, autonomous volunteering removes the need for the coordinator to track expertise. S-Agents’ asynchronous execution eliminates round-based waiting, reducing idle latency. Anemoi’s A2A protocol supports dynamic, distributed refinement and consensus; OWL’s modular worker pool and planner-only RL secures cross-domain generalization. FSM-driven orchestration enables fine-grained error recovery and adaptive replanning (Agentic Lybic (Guo et al., 14 Sep 2025)).

6. Empirical Validation and Performance Results

Coordinator–worker–sub-agent architectures demonstrate strong empirical scaling and reliability:

Blackboard system (Salemi et al., 30 Sep 2025): Outperforms RAG and master-slave by 13%–57% in task success and up to 9% in F₁ on file discovery, robust across proprietary and open-source LLMs, including Gemini 2.5 Pro and Claude 4-Opus. Performance remains steady as data lake size ( $|D|$ ) increases.
S-Agents (Chen et al., 7 Feb 2024): Tree-of-agents structure reduces time cost ( $\sim$ 7.5 min) and planning invocations (mean prompt times $\sim$ 3.8) over chain/graph alternatives.
Anemoi (Ren et al., 23 Aug 2025): Semi-centralized design yields 52.73% accuracy on GAIA, +9.09pp above strongest open-source baseline (OWL), even with weaker planner LLMs; token cost reduced by 30–40%, distributed critique drives error reduction.
Agentic Lybic (Guo et al., 14 Sep 2025): FSM-based routing and continuous evaluation yields 57.07% on OSWorld benchmark, with fewer wasted actions and superior error recovery.
OWL (Hu et al., 29 May 2025): OWL-trained planner achieves 52.73% on GAIA, +16.37pp above SFT-alone, matches closed-source models on hard tasks, scalable extension by simply registering new workers.
AgentOrchestra (Zhang et al., 14 Jun 2025): Hierarchical planning achieves 82.42% macro-average success on GAIA, outperforming flat-agent baselines by nearly 5pp.
SciAgent (Li et al., 11 Nov 2025): Consistently attains or surpasses gold-medalist human performance (IMO: 36/42; IMC: 100/100), high error-detection (>99%), low mean iterations to convergence.

7. Architectural Patterns, Best Practices, and Future Implications

Across reviewed frameworks, architectural best practices emerge:

Modular separation of concerns: Planners focus on high-level decomposition; workers specialize in targeted execution; sub-agents encapsulate primitive tool logic.
Explicit plan structures: Unique IDs, state, agent assignments per subgoal support dynamic adaptation and monitoring.
Unified communication protocols: Standard APIs (JSON-RPC, function-calling, shared blackboard) enforce interaction contracts and minimize channel overhead.
Closed-loop verification: Periodic critique, review pipelines, and error signals ensure task reliability; immediate replanning upon failure or stagnation prevents error cascades.
Extensibility and dynamic registry: Agent registries support plug-and-play addition of new specializations, enabling cross-domain scaling.
Autonomous agent selection and non-interference: Self-volunteering, as in blackboard systems, prevents execution overload and ambiguity; non-obstructive asynchrony speeds collective completion.
Hierarchical goal alignment and adaptive planning: Coordinators leverage learned relevance scoring, cost/risk simulation, and interactive re-planning for task optimization.
Empirical reliability in large-scale, multimodal, and cross-domain settings: Rigorous benchmark evaluations demonstrate robust scaling and transfer.

A plausible implication is that coordinator–worker–sub-agent architectures will continue to underpin scalable, robust multi-agent systems for increasingly complex environments, including data science, automation, scientific reasoning, and human–AI teaming. The avoidance of rigid controller dependencies, explicit agent specialization, and adaptive, consensus-based execution supports concurrent advances in agent autonomy and architectural generalization.