Agent Module Composition in Multi-Agent Systems

• Agent module composition is the process of integrating modular components—such as planners, memory, action, and security—to achieve coordinated multi-agent workflows.
• It employs formal models, multi-stage orchestration, and optimization techniques to ensure secure, scalable, and fault-tolerant execution in LLM systems.
• Empirical studies demonstrate its benefits in diverse applications, from financial analysis to digital automation, by enforcing sound modular boundaries.

Agent module composition is the process of assembling, orchestrating, and coordinating modular agent components—such as planners, tool modules, memory, security, and action interfaces—within single or multi-agent systems to achieve target workflows and satisfy user intent. Modern research on agent composition in LLM-centric multi-agent systems integrates automated planning, agent recommendation, execution graph construction, robust orchestration, and security enforcement into end-to-end frameworks, enabling scalable, extensible, and fault-tolerant execution of complex tasks. The field encompasses formal semantics, optimization, security/compositional correctness, and empirical evaluation across diverse domains, including digital automation, financial analysis, and scientific workflows.

1. Architectural Principles and Formal Models

Agent module composition is grounded in explicit modularization of agent functions, with clear interfaces and separation of concerns. Unified architectural models—such as the five-module separation in LLM-Agent-UMF (planning, memory, profile, action, security) (Hassouna et al., 2024), layered workflow architectures (e.g., planning→analysis→integration→decision in P1GPT (Lu et al., 27 Oct 2025)), and formal agent protocol stacks (Zheng et al., 25 Mar 2026)—ensure that each system component has precisely defined I/O contracts, invariants, and composition operators. Formal calculi, such as $λ_A$ (a typed lambda calculus for LLM agent composition), rigorously specify the syntactic and semantic rules for assembling agent pipelines, enforcing type safety, bounded termination, and compositional soundness (Liu, 13 Apr 2026).

Typical agent modules and their roles (see also Table 1):

Module	Role	Example Interface
Planning	Task decomposition, sequencing	$f_{\mathrm{plan}}(S, G, M) \to P$
Memory	STM/LTM management	$m_{\mathrm{read}}, m_{\mathrm{write}}$
Action	Tool execution/invocation	$f_{\mathrm{act}}(a, S) \to (R, S', \Delta M)$
Profile	Persona/model configuration	$f_{\mathrm{profile}}(R) \to \theta$
Security	Input/output sanitization, privacy	$f_{\mathrm{sec}}(x) \to (d, x')$

These modular boundaries underlie both agent-centric frameworks like AgentScope (Gao et al., 22 Aug 2025) and composition-unifying formal frameworks such as $λ_A$ (Liu, 13 Apr 2026).

2. Composition Mechanisms: Planning, Orchestration, and Execution

State-of-the-art agentic composition frameworks employ multi-stage orchestration pipelines, typically beginning with automated task decomposition and progressing through agent selection, call graph construction, and runtime execution. The AutoMAS workflow (Athrey et al., 5 May 2026) exemplifies this approach:

• User Intent Capture: Free-form intent plus constraints as input.
• LLM-Derived Planner: Recursive decomposition to atomic subtasks, yielding a finite-state machine (FSM) or dynamic call graph $G=(V,E)$.
• Orchestrator and Registry Mapping: Function $$M: \text{Task} \times \text{AgentRegistry} \to \text{CandidateAgents}$$ selects agents per subtask, based on hybrid embedding & retrieval scoring.
• Two-Stage Agent Recommendation: (1) Dense/sparse embedding retriever for high-recall candidate generation; (2) LLM-based re-ranking for precision.
• Critique Agent: Global compatibility and constraint enforcement, revising agent selection and recommending corrections.
• Execution Engine: Dynamic call graph traversal; failure handling via alternative edges and re-routing based on runtime signals.

Agent architectures may enforce additional composition constraints, such as cost, latency, data modality compatibility, or cross-module security invariants (Athrey et al., 5 May 2026, Zheng et al., 25 Mar 2026, Yuan et al., 18 Oct 2025).

3. Optimization and Selection Techniques

Agent module composition is often framed as a discrete optimization problem. For instance, optimal multi-agent team selection for coverage (Sun et al., 2020) formulates the problem as maximizing a submodular reward minus cost under cardinality constraints, enabling use of greedy algorithms with explicit curvature-based approximation guarantees. In automated tool/agent selection, “Automated Composition of Agents: A Knapsack Approach for Agentic Component Selection” (Yuan et al., 18 Oct 2025) uses online knapsack algorithms to select agentic components, dynamically testing candidates in a sandbox to estimate real utility, while enforcing skill coverage and budget bounds.

Comparison of optimization approaches:

Method	Optimization Formulation	Constraints	Guarantee Source
Submodular Greedy + PGA (Sun et al., 2020)	$\max_{x\in\{0,1\}^m} f(S(x)) - c^T x$	$f_{\mathrm{plan}}(S, G, M) \to P$0	Submodularity, curvature
Online Knapsack (Yuan et al., 18 Oct 2025)	$f_{\mathrm{plan}}(S, G, M) \to P$1	$f_{\mathrm{plan}}(S, G, M) \to P$2, skill coverage	Dynamic threshold (ZCL)
Two-Stage IR + LLM (Athrey et al., 5 May 2026)	Top-K selection by embedding, re-rank by fit	Agent registry, constraints	Empirical accuracy

Empirical studies show that combining retrieval and live evaluation (sandboxing) outperforms static retrieval and achieves placement on the Pareto frontier in the success rate vs. cost plane (Yuan et al., 18 Oct 2025).

4. Patterns of Module Composition: Single and Multi-Agent Systems

Module composition can occur within monolithic single agents or across multi-agent ecosystems. LLM-Agent-UMF (Hassouna et al., 2024) distinguishes between “active” agents (full planning/memory/action) and “passive” agents (execution/security only), supporting architectures including monolithic single-core, uniform multi-passive, uniform multi-active, hybrid, and fully distributed manager-worker models.

Concrete implementations:

• Layered workflow (P1GPT (Lu et al., 27 Oct 2025)): Input → Planning → (parallel) Specialized Analysis Agents → Integration/Fusion → Action/Decision.
• Graph-based planning (AgentKit (Wu et al., 2024)): Nodes (prompts/tasks/submodules) wired as dynamic DAGs; on-the-fly addition/removal enables hierarchical planning, reflection, symbolic learning.
• Specialist agent orchestration (OptAgent (Jiang et al., 27 Jan 2026)): Centralized or hierarchical orchestrator dispatches tasks to domain-specialist agents via shared tool protocols (e.g., MCP).

Composition patterns emphasize explicit dependency management, parallelization (e.g., across independent subtasks), and flexible evolution of agent pools and tool registries.

5. Semantic Integrity, Security, and Formal Correctness

Composition correctness in modular agent systems depends on both semantic and security assurances. The $f_{\mathrm{plan}}(S, G, M) \to P$3 calculus (Liu, 13 Apr 2026) enforces strong type safety, bounded termination of fixpoint loops, and symbolic route coverage via case-analysis, with operational semantics dictating the allowable flows of LLM calls, tool invocations, and memory updates. Automatic linting and configuration checking are derived from these formal semantics, achieving near-perfect detection of ill-formed agent configurations in large-scale empirical evaluations.

The AgentRFC security model (Zheng et al., 25 Mar 2026) systematically analyzes protocol composition safety via a six-layer stack (transport, message format, session lifecycle, identity, semantics/consent, audit), with composition invariants (e.g., CS_NoLeakage, CS_AuditChain) checked both by TLA+ model checking and live execution trace replay. Failure to specify all stack layers or to bridge audit/accountability across modules results in concrete, empirically validated security gaps.

6. Empirical Evaluation and Design Guidance

Modern frameworks report comprehensive empirical benchmarks, using recall@k, nDCG, mAP, tool selection accuracy, plan step accuracy, and domain-specific metrics (Sharpe ratio, coverage reward) to quantify module composition robustness (Athrey et al., 5 May 2026, Sun et al., 2020, Lu et al., 27 Oct 2025). Ablation and comparative studies reveal the performance impact of each module and composition strategy, guiding best practices in module boundary definition, tool registry management, parallel execution, memory persistence, and security enforcement.

Design recommendations include:

• Maintain clear single-responsibility modular decomposition (Hassouna et al., 2024).
• Embed security and audit modules at all I/O boundaries (Zheng et al., 25 Mar 2026, Hassouna et al., 2024).
• Use asynchronous and event-driven orchestration for scalable parallelism (Gao et al., 22 Aug 2025).
• Leverage dynamic agent or tool pools for extensibility and evolving domains (Jiang et al., 27 Jan 2026).
• Apply static linting and dynamic assertion checking to guard against semantically invalid configurations (Liu, 13 Apr 2026).

7. Applications and Extensions Across Domains

Agent module composition frameworks have been demonstrated in financial analysis (P1GPT (Lu et al., 27 Oct 2025)), audio/video generation (Audio-Agent (Wang et al., 2024)), building energy management (OptAgent (Jiang et al., 27 Jan 2026)), open-domain workflow automation (AgentScope (Gao et al., 22 Aug 2025), AutoMAS (Athrey et al., 5 May 2026)), melody composition (ByteComposer (Liang et al., 2024)), and others. Underlying principles generalize to context-embedding driven policy assembly (as in MDP ensemble composition (Merkle et al., 2023)), symbolic learning agents (Wu et al., 2024), and formal workflow construction across variable modality pipelines.

Ongoing research directions include richer compatibility/synergy modeling beyond basic constraints (Yuan et al., 18 Oct 2025), automated synthesis of agent-composable workflows from natural language (Athrey et al., 5 May 2026), and more expressive and auditable IRs spanning configuration, protocol, and interaction layers (Liu, 13 Apr 2026, Zheng et al., 25 Mar 2026).

---

By formalizing modular boundaries, optimizing agent selection, enforcing semantic and security guarantees, and benchmarking end-to-end composition within robust architectural scaffolds, recent work has established agent module composition as a central mechanism for scalable, reliable, and interpretable LLM-driven multi-agent systems (Athrey et al., 5 May 2026, Liu, 13 Apr 2026, Hassouna et al., 2024, Yuan et al., 18 Oct 2025, Zheng et al., 25 Mar 2026).