agent architectures

This study systematically investigates how tool architecture influences the behavior and performance of coding agents, holding underlying capabilities constant. Through controlled experiments on repository-scale program repair tasks, six distinct tool interfaces—ranging from bash and structured low-level APIs to natural language search, Python CodeAct, and cognitive scaffolding—are evaluated. Analysis of 11,700 agent trajectories reveals, for the first time, that the architectural design of tools—not merely their functional capacity—plays a critical role: structured low-level interfaces improve consistency across repeated attempts by 4.7×, natural language search increases access to relevant files by over 11%, and CodeAct substantially reduces both action steps (by 41.6%) and token consumption (by 56.3%), whereas cognitive scaffolding yields limited benefits.

This work proposes a new paradigm for software design tailored to AI agents as primary users, addressing the limitations of traditional human-centric approaches. It formally defines the concept of an “agent interface” for the first time, centering on callable capabilities and emphasizing machine interpretability, composability, and invocation reliability. Guided by the interaction requirements of large language model–based agents, the study introduces a capability-oriented software architecture and corresponding interface specifications. By establishing a conceptual foundation and design framework for AI-native systems, this research advances software engineering beyond monolithic applications toward dynamic, composable ecosystems of interoperable capabilities.

Current LLM-driven autonomous agents lack scalable, secure, and maintainable architectures for tool orchestration, hindering large-scale deployment. To address this, we propose the novel “Control Plane as a Tool” paradigm, which— for the first time—abstracts tool scheduling, security policies, and extensibility mechanisms into a unified, pluggable tool interface, thereby decoupling control logic from the LLM agent core. Leveraging modular routing protocols and production-grade encapsulation, our approach significantly reduces integration complexity while enabling dynamic tool registration/removal and runtime policy updates. Empirical evaluation across diverse application scenarios demonstrates over 40% improvement in both horizontal scalability efficiency and security robustness. The architecture provides a reusable, evolution-aware foundation for controllable, embodied intelligent agents.

This study addresses the challenge of deploying agentic AI in regulated environments, where existing approaches lack a systematic design framework that jointly accounts for autonomy and agency, often failing to balance compliance, auditability, and error correction. The work introduces the first unified model of these two dimensions, defining a two-dimensional hierarchical design space with five operational levels each. It proposes six architectural strategies—checkpoints, escalation mechanisms, multi-agent delegation, tool provisioning, tool sandboxing, and write staging—to enable flexible system configuration under real-world regulatory constraints. Validated through public-sector case studies, the framework establishes a shared terminology and actionable design guidelines, facilitating interpretable, controllable, and compliant AI deployment amid evolving model capabilities and tool fidelity.

This work proposes a software engineering–inspired approach to enhance the controllability and engineering rigor of large language model (LLM) agents by treating agent skills as modular software components. For the first time, core software engineering principles—including single responsibility, separation of interface and implementation, low coupling, and token economy—are systematically applied to guide skill design. The authors establish a behavior-evaluation-driven skill development pipeline integrating UML modeling, phased loading mechanisms, and standardized skill descriptions, while formally defining skill structure and loading models. The study further identifies canonical implementation patterns and anti-patterns, and formulates decision rules for selecting among coordination mechanisms such as memory integration and sub-agent delegation. This framework provides developers with actionable guidelines for building reusable, maintainable skills and offers criteria for evaluating trustworthiness in third-party skills.

This study addresses the lack of systematic investigation into architectural design decisions for non-large language model components in current AI agent systems. The authors propose a protocol-guided, source code–driven empirical analysis method that enables, for the first time, transparent deconstruction of heterogeneous AI agent systems. Through cross-project qualitative coding and co-occurrence analysis of 70 open-source projects, they identify five core design dimensions—sub-agent architecture, context management, tooling systems, security mechanisms, and orchestration—and uncover their combinatorial patterns. Based on these findings, the study further distills five archetypal architectural patterns: lightweight tool-oriented, CLI framework–based, multi-agent orchestrator, enterprise system, and domain-specific vertical architectures.

This study investigates whether large language model–based multi-agent systems can achieve efficient autonomous collaboration without predefined roles or hierarchical structures. Through extensive experiments involving 25,000 tasks across system scales ranging from 4 to 256 agents, the authors evaluate the impact of eight coordination protocols—including fixed-order execution, centralized control, and self-organization—on task performance. The results demonstrate that minimal structural scaffolding suffices for agents to spontaneously develop role specialization and shallow hierarchies. Notably, the proposed Sequential protocol outperforms centralized approaches by 14%, with the largest performance gap between protocols reaching 44%. The system scales effectively to 256 agents without performance degradation, and open-source models achieve 95% of the performance of closed-source counterparts at only 1/24th of the computational cost.

Existing agent organizations are often oversimplified as static dialogue topologies or fixed workflows, struggling to balance persistence with dynamism. This work proposes a native agent organization architecture featuring four hierarchical layers—persistence, coordination, runtime, and human-agent interaction—that constructs task-specific operational worlds through permission/privilege mechanisms while orthogonally separating execution, auditing, and oversight roles. The design adopts a dual-state paradigm: rigid at the foundational layer yet flexible at the execution interface, ensuring persistent integrity of records, write constraints, and separation of powers while enabling task-driven dynamic reconfiguration. Key technical components include a four-store recording architecture, specialized agent pools, isolated runtimes, and non-decisional translator agents. A prototype implementation demonstrates the framework’s feasibility, offering a falsifiable foundation for the design, governance, and evaluation of agent organizations.

This work addresses the lack of systematic empirical comparison among tool integration and agent delegation protocols in multi-agent systems, which hinders informed architectural choices for complex task orchestration. We propose the first evaluation framework specifically designed for assessing multi-agent communication protocols in task orchestration, establishing a standardized benchmark to compare pure tool-integration, pure multi-agent delegation, and hybrid architectures across three levels of task complexity. Leveraging a standardized query set, end-to-end metric collection, and real-world deployment environments, we quantitatively analyze performance along multiple dimensions—including response time, context consumption, cost, error recovery, and implementation complexity. Our experiments reveal critical trade-offs among the protocols in terms of efficiency, resource overhead, and robustness, offering data-driven guidance for practical system design.