modular system design

Microservices achieve physical isolation but fail to prevent the proliferation of logical coupling, undermining module independence. This paper proposes a novel modularization paradigm based on universal interface boundaries, constructs a quantifiable model for assessing module independence, and designs a runtime mechanism supporting dynamic loading, unloading, and hot updates within a single process. Its core contributions are: (1) reframing module independence as a formal, modelable, and measurable system property—moving beyond qualitative assertions; (2) replacing implicit dependencies with explicit interface contracts to fundamentally block coupling propagation; and (3) implementing the EIGHT platform prototype, which achieves microservice-level module autonomy within a monolithic process. Experimental results demonstrate that the approach significantly reduces the impact scope of cross-module changes, enhancing system maintainability and evolutionary efficiency. It provides both theoretical foundations and practical pathways for next-generation architectures transcending the monolith–microservice dichotomy.

Current micro-frontend architectures heavily rely on specific bundlers (e.g., Webpack), leading to inflexible module composition, constrained cross-team collaboration, and bottlenecks in error detection, runtime observability, and loading performance. To address these limitations, we propose Bundler-Independent Module Federation (BIMF)—the first runtime module federation framework decoupled from build-time bundlers. BIMF enables dynamic module loading, type-safe inter-module collaboration, and cross-team dependency sharing. It integrates runtime dependency resolution, distributed tracing, server-side rendering (SSR), and intelligent prefetching to significantly enhance observability and first-contentful-paint (FCP) performance. Experimental evaluation of a prototype implementation demonstrates: (1) full preservation of TypeScript type contracts across modules; (2) 100% dependency deduplication; (3) a 37% reduction in average module loading latency; and (4) a 42% improvement in parallel development efficiency across distributed teams.

Current harness designs for large language model agents lack a formal foundation, hindering guarantees of compositional correctness, property preservation, and systematic cross-framework comparison. This work introduces the first formal theory of harnesses, modeling them as categorical triples (G, Know, Φ) that integrate coalgebraic state representations, operator composition, and compilation functors. The framework incorporates structural replay and integrity gating mechanisms to ensure certificate-preserving behavior. Building on this theory, we implement a configuration compiler supporting Swarms, DeerFlow, Ralph, Scion, and LangGraph, which preserves three classes of structural certificates. End-to-end experiments demonstrate that the proposed quality-driven upgrade pathway is agnostic to underlying model parameters.

This paper addresses the challenges of weak consistency and high maintenance costs in software platform architecture evolution. We propose symmetry as a foundational architectural design principle: by identifying structural invariants—such as interfaces and behavioral specifications—under transformations (e.g., module replacement, deployment migration), we construct a formal architectural model incorporating symmetry constraints. Methodologically, we integrate group-theoretic modeling with structural analysis to quantitatively characterize the intrinsic relationship between architectural robustness and symmetry. Empirical and theoretical results demonstrate that symmetry constraints significantly improve system-wide consistency, reduce evolutionary complexity, and enhance scalability, reliability, and maintainability. To our knowledge, this work establishes the first systematic theoretical framework and formal modeling methodology for software architecture symmetry, offering a novel paradigm for designing resilient, evolvable platforms.

Existing large-scale systems face challenges including poor cross-domain collaboration, weak dynamic adaptability, and inefficient human–machine interaction. To address these, this paper proposes a large language model (LLM)-enhanced hierarchical heterogeneous holon architecture for adaptive, human-centered systems of systems (SoS). Methodologically, it introduces four specialized holon types—supervisory, planning, task, and resource—organized within a three-layer structure (reasoning, communication, and capability), with LLMs deeply embedded in the reasoning layer for autonomous decision-making and real-time reconfiguration. The architecture is validated in a 3D urban traffic simulation, demonstrating scalability and sub-100-ms response latency. Furthermore, the work defines quantifiable metrics for efficiency and scalability, enabling both simulation-based optimization and practical deployment.

This study addresses the challenge of automating workflows in complex industries—such as logistics, healthcare, and construction—where processes are fragmented across heterogeneous tools and involve multi-party collaboration. The work proposes orchestration as a core abstraction to enable effective automation by dynamically coordinating multi-step tasks, enforcing domain-specific constraints, managing human approvals, and integrating legacy systems. It introduces the novel concept of “orchestration bottlenecks” and develops a theoretical framework that unifies multi-agent systems, workflow modeling, constraint reasoning, and human–AI collaboration, while exposing critical gaps in current multi-agent approaches at the orchestration level. Based on distinct sources of operational friction across domains, the paper advocates for targeted architectural safeguards—such as constraint enforcement or explainability—and phased implementation strategies to provide actionable pathways for automation in complex operational environments.

This work addresses the complexity and heavy reliance on manual effort in software architecture design, particularly the challenge of efficiently exploring diverse architectural solutions within agile development contexts. To this end, the paper proposes MAAD, a novel framework that systematically integrates multi-agent collaboration, Retrieval-Augmented Generation (RAG), and hierarchical memory mechanisms into the architectural design process. MAAD employs four specialized agents—analyst, modeler, designer, and evaluator—that collaboratively transform requirements into multi-view architectural blueprints and support iterative refinement. Experimental results across ten case studies demonstrate that MAAD-generated architectures consistently outperform those produced by the MetaGPT baseline in terms of completeness, modularity, and traceability. Furthermore, the evaluator agent automatically produces structured quality reports, substantially reducing the cost of manual validation.

This work proposes a novel software construction paradigm that fundamentally departs from the core assumptions of object-oriented programming. By decoupling problem-domain entities from functional modules, the approach enables independent organization and reuse of functionality, thereby addressing the fragmentation of features and entanglement of responsibilities commonly induced by binding system behavior to individual domain objects. The proposed paradigm adopts a non-object-oriented modular design that substantially mitigates architectural coupling stemming from rigid object boundaries. As a result, it offers a clearer, more flexible, and maintainable pathway for modeling complex systems, overcoming key limitations inherent in traditional object-oriented approaches.

This work addresses the lack of a unified configuration governance mechanism in heterogeneous multi-agent systems, which hinders versioned, auditable, and cross-framework consistent management. The authors propose a framework-agnostic reference model for agent configuration governance that normalizes diverse configurations into a canonical configuration graph via semantic projection and enforces uniform governance semantics over this graph. Key innovations include typed and independently versioned configuration items, strict decoupling of configuration from runtime, a lattice-based monotonic influence propagation mechanism, and dependency-aware immutable revisions with provenance tracking. The model is validated across LangGraph, CrewAI, and OpenAI Agents SDK, demonstrating governance-equivalent ACM representations across 27 governance scenarios and 9 propagation cases, while guaranteeing convergence, termination, and a unique fixed point.

This work addresses the challenge of ensuring safety, reliability, and trustworthiness in collective adaptive systems operating in dynamic environments by proposing a modular design paradigm centered on intrinsic trustworthiness. The approach integrates a runtime model based on local causal event sequences, a temporal logic verification technique supporting modular architectures, and a compositional reasoning mechanism for global system properties grounded in component attributes. Through this tripartite framework, the study overcomes key limitations of conventional formal methods and demonstrates substantial improvements in verifiability and scalability in case studies, thereby establishing both a theoretical foundation and a practical pathway for engineering highly trustworthy collective adaptive systems.