One-Active–Many-Passive Core-Agent Architecture

• One-active–many-passive core-agent architecture is a distributed paradigm where a central active agent orchestrates multiple passive agents to execute delegated tasks, ensuring scalability and robust consensus.
• The methodology leverages finite-state machines and consensus dynamics to decompose user tasks, coordinate secure communications, and efficiently aggregate results across agents.
• Practical applications include LLM orchestration, multi-robot control, and intelligent automation, highlighting design trade-offs such as centralized failure risks versus modular simplicity.

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 (Hassouna et al., 17 Sep 2024):

• 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 (Yucelen, 2014).

The architecture is typically depicted (see (Hassouna et al., 17 Sep 2024)) 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 (Yucelen, 2014), 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 (Hassouna et al., 17 Sep 2024, Sarkar et al., 26 May 2025).

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 (Guo et al., 14 Sep 2025).

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 (Sarkar et al., 26 May 2025). 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 (Hassouna et al., 17 Sep 2024).

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 (Hassouna et al., 17 Sep 2024).

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 (Hassouna et al., 17 Sep 2024).

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 (Sarkar et al., 26 May 2025). 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 (Yucelen, 2014) 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 (Sarkar et al., 26 May 2025).

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 (Guo et al., 14 Sep 2025).

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 (Yu et al., 3 Nov 2025).

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 (Sarkar et al., 26 May 2025).
• 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 (Sarkar et al., 26 May 2025, Guo et al., 14 Sep 2025).
• Scalability Strategies: Broker layers and backend servers may be sharded or load-balanced to extend reach, and batch dispatch is used for efficiency (Sarkar et al., 26 May 2025).
• 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 (Hassouna et al., 17 Sep 2024).

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 (Guo et al., 14 Sep 2025)	OSWorld benchmark, 50 steps, SOTA	57.07% success rate; per-category +15.2pp (Chrome), etc.
Med Pre-Consult (Yu et al., 3 Nov 2025)	Triage accuracy / Task completion rate	87.0% (primary); 98.2% completion vs 93.1% (baseline)
LLM-Agent-UMF (Hassouna et al., 17 Sep 2024)	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 (Guo et al., 14 Sep 2025).

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 (Hassouna et al., 17 Sep 2024).
• 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 (Hassouna et al., 17 Sep 2024).
• 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 (Hassouna et al., 17 Sep 2024).

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 (Hassouna et al., 17 Sep 2024, Yucelen, 2014, Sarkar et al., 26 May 2025, Guo et al., 14 Sep 2025, Yu et al., 3 Nov 2025).