---
title: One-Active–Many-Passive Core-Agent Architecture
url: https://www.emergentmind.com/topics/one-active-many-passive-core-agent-architecture
type: topic
---

# One-Active–Many-Passive Core-Agent Architecture

A one-active–many-passive core-agent architecture is a multi-agent system paradigm that distinguishes a single authoritative coordinating agent—the “active core agent” or Controller—from a collection of subordinate “passive core agents” (workers or executors). The active core-agent bears comprehensive planning, memory, and coordination responsibilities, while the passive agents are designed for stateless, non-authoritative task execution. This separation underpins scalable, modular, and robust computational frameworks in consensus networks, LLM-based agent orchestration, and both theoretical and applied distributed AI systems.

## 1. Formal Definitions and Core Structure

A core-agent is the central entity in an LLM-based agent system, mediating between LLMs, tools/APIs, user interfaces, and memory blocks. Within this architectural paradigm, agents are formally classified as follows [2409.11393]:

- **Active core-agent:** Implements planning, memory, profile, action, and security modules. It is authoritative, stateful, and governs task decomposition, context management, scheduling, subtask allocation, results aggregation, and all decision-making.
- **Passive core-agent:** Implements only the action and security modules. It is stateless, not authoritative, and simply executes delegated tasks (e.g., tool/API calls), forwarding results to the active agent.

In dynamical system terms (e.g., distributed consensus), agent 1 (the “core” or “active” agent) receives external input $c\in\mathbb{R}$ and drives the global state convergence, while agents $i=2,\dots,n$ are passive, operating solely under inter-agent couplings [1405.1480].

The architecture is typically depicted (see [2409.11393]) as a central active core-agent node coordinating task, context, and data flows to multiple worker/adapter nodes, each of which mediates with an external service, API, or data stream.

## 2. Mathematical and Algorithmic Foundations

### 2.1 Dynamical Systems Perspective

In networked consensus with integral action [1405.1480], the agent-level dynamics are:

- **Active agent (agent 1):**
  \[
  \dot{x}_1 = -\sum_{j\in N_1}(x_1-x_j) + \sum_{j\in N_1}(\xi_1-\xi_j) - (x_1 - c), \quad
  \dot{\xi}_1 = -\sum_{j\in N_1}(x_1-x_j)
  \]
- **Passive agents ($i=2,\dots,n$):**
  \[
  \dot{x}_i = -\sum_{j\in N_i}(x_i-x_j) + \sum_{j\in N_i}(\xi_i-\xi_j), \quad
  \dot{\xi}_i = -\sum_{j\in N_i}(x_i-x_j)
  \]

Compactly:
\[
\dot{x} = -Lx + L\xi - K_1x + K_2c, \qquad \dot{\xi} = -Lx
\]
where $L$ is the graph Laplacian, $K_1 = \text{diag}(1,0,...,0)$ and $K_2 = e_1e_1^T$. This yields an asymptotic global consensus at the input value $c$. Closed-loop convergence is guaranteed via quadratic Lyapunov analysis, with a rate determined by the smallest eigenvalue of $L+K_1$.

### 2.2 Task-Oriented, Software, and FSM Models

In agentic orchestration systems, such as LLM-based task planners or desktop automation controllers, the core agent decomposes the user task $T$ into subtasks $\{t_i\} = \text{Plan}(T)$, assigns each to a passive agent $P_i$, collects results $r_i = \text{Exec}_i(t_i)$, aggregates $\bigoplus_{i=1}^n r_i$, applies security filtering, and synthesizes the final response with the LLM given the task profile [2409.11393][2506.05364].

Centralized state and event flow are succinctly modeled using finite-state machines (FSM). For instance, Agentic Lybic encodes the control logic as a Mealy-FSM with states for planning, execution, evaluation, error recovery, and task finalization. The transition function $T:S\times I\to S\times O$ handles all workflow event routing [2509.11067].

### 2.3 Scalability and Communication Complexity

The architectural communication complexity is linear in the number of passive agents, $L_\mathrm{central} = O(N)$, as opposed to $O(N^2)$ for fully connected multi-peer networks [2506.05364]. This has critical implications for extensibility and the upper bounds of system size. Information-theoretic and queueing formulations further frame the efficiency and load behavior, though detailed quantitative models are an open research direction [2409.11393].

## 3. Design Rationales and Trade-Offs

### 3.1 Motivations

- **Single Responsibility Principle:** All orchestration, planning, and memory reside in one place, reducing interface and state management complexity.
- **Modularity:** Passive agents are lightweight wrappers, decoupled from the active agent’s (and each other's) logic.
- **Scalability:** Arbitrarily many passive agents can be added with linear growth in coordination cost.
- **Maintainability:** The active agent is the sole locus of complexity; passive agents remain as simple as possible [2409.11393].

### 3.2 Limitations

- **Single point of coordination/failure:** The system halts if the active agent is unavailable.
- **Limited autonomy:** Passive agents cannot internally replan or retry failed subtasks, rendering local resilience weak.
- **Security boundary:** Active agent must filter and validate all passive interactions; security gaps may exist if passive implementations are not hardened [2409.11393].

### 3.3 Design Patterns and Interface Realizations

The architecture maps to Mediator (core agent) and Broker (MCP server) software design patterns. Passive agents expose capabilities as callable “tools” via an MCP broker that centralizes all control and result routing [2506.05364]. Observer and Publish-Subscribe patterns are utilized if the core must subscribe to shared-state updates.

## 4. Concrete Instantiations Across Domains

### 4.1 Multi-Robot, Consensus, and Networked Agents

The one-active–many-passive consensus schemata [1405.1480] ensure distributed synchronization to a single external command, underpinning cooperative control scenarios in sensor networks and distributed robotics.

### 4.2 LLM-Orchestrated Agent Systems

The Model Context Protocol (MCP)-compliant orchestration pattern implements the core-agent as a mediator over multiple worker/service agents, each realized as an independently callable “tool.” Operational flows are specified in pseudo-algorithmic detail, covering registration, dispatching, result collection, and event-driven reactivity [2506.05364].

### 4.3 Applied Automation: Agentic Lybic

Agentic Lybic leverages a centralized controller maintaining an FSM that orchestrates Manager, Technician, Operator, Analyst, and Evaluator passive agents to solve desktop automation and UI manipulation tasks. The FSM encodes all error recovery, replanning, and quality gating, achieving state-of-the-art task success rates on complex benchmarks. Each passive agent implements a specialized execution or inference role, but scheduling and adaptive retry are strictly centralized [2509.11067].

### 4.4 Intelligent Medical Pre-Consultation

A hierarchical system deploys a single Controller responsible for global subtask selection, scheduling, and context update propagation, supported by passive specialist agents for inquiry generation, data recording, evaluation, and triage. Centralized scheduling raised dialogue completion rates (98.2% vs. 93.1% for default order), improved physician-rated clinical quality scores, and maintained high model-agnostic performance [2511.01445].

## 5. Implementation Guidelines and Practical Considerations

Core implementation guidelines include:

- **Loose Coupling:** Passive agents interact exclusively with the core agent or through a standardized broker/server interface; peer-to-peer links are eschewed [2506.05364].
- **Channel Configurability:** Choice between local/remote transports (e.g., stdio vs HTTP+SSE), per-message guarantees, and event subscription is domain-dependent.
- **Error Handling:** Passive agents are designed to return standard error/failure signals, with all recovery logic and fallback policies encoded in the core agent’s planner or FSM [2506.05364][2509.11067].
- **Scalability Strategies:** Broker layers and backend servers may be sharded or load-balanced to extend reach, and batch dispatch is used for efficiency [2506.05364].
- **Security:** Security-by-design is enforced by channeling all interactions through the active core agent’s profile and security modules, embedding privacy safeguards, and monitoring all passive output [2409.11393].

## 6. Evaluation Metrics and Empirical Results

Empirical assessments reflect the architecture’s impact on scalability, correctness, efficiency, and maintainability:

| System/Domain              | Metric                                  | Reported Result                                          |
|----------------------------|-----------------------------------------|----------------------------------------------------------|
| Agentic Lybic [2509.11067] | OSWorld benchmark, 50 steps, SOTA       | 57.07% success rate; per-category +15.2pp (Chrome), etc. |
| Med Pre-Consult [2511.01445] | Triage accuracy / Task completion rate | 87.0% (primary); 98.2% completion vs 93.1% (baseline)    |
| LLM-Agent-UMF [2409.11393] | ATRAF risk/quality satisfaction         | Outperforms uniform-active and uniform-passive designs   |

Efficiency scalings, e.g., $O(N)$ communication cost, and modular extension with new tools/workers are consistently confirmed. Advanced quality gates and dynamic replanning reduce error propagation in long-horizon, multistep settings [2509.11067].

## 7. Limitations, Open Challenges, and Future Directions

Noted limitations include:

- **Throughput and latency bounds:** The potential for bottlenecking at the active core-agent motivates proposals for distributed, sharded, or hierarchical actives [2409.11393].
- **Limited passive resilience:** While traditional designs forego replanning at the passive level, open challenges include embedding lightweight error handling or basic agent local autonomy for greater robustness.
- **Security hardening:** Weaknesses in passive-to-external tool linkages remain an unsolved vulnerability. Embedding lightweight guardrails in each passive is suggested [2409.11393].
- **Formal performance modeling:** Queueing-theoretic modeling and empirical wall-clock throughput/latency measurement are cited as future directions to quantitatively calibrate scaling laws and identify optimal configurations [2409.11393].

The one-active–many-passive paradigm, through its rigorous separation of orchestration and execution, is the recommended pattern for scalable, modifiable, and secure multi-agent LLM systems, consensus networks, and orchestration-driven automation agents [2409.11393][1405.1480][2506.05364][2509.11067][2511.01445].

Source: https://www.emergentmind.com/topics/one-active-many-passive-core-agent-architecture