betaFeedback

WorksComputer Science

When the Mythical Man-Month Meets Agentic Web Systems: Structured Coordination for Scalable Development

Abstract

As agentic systems are increasingly deployed to support complex Web tasks, multi-agent architectures offer greater parallelism, specialization, and task coverage. However, increasing the number of agents does not necessarily improve system performance, as communication, synchronization, redundant work, and coordination overhead may offset the benefits of additional agents. This presents a fundamental scaling challenge for agentic Web systems: how can agent populations be organized to balance task performance and coordination costs? To address this challenge, we systematically investigate the relationship between agent population size, per-agent token consumption, and coordination overhead in collaborative agentic systems. Experiments on complex Web-oriented software development tasks reveal a non-linear scaling pattern: per-agent token consumption initially decreases as the agent population grows, but eventually exhibits diminishing returns. Motivated by these findings, we introduce the Surgical Team Model (STM), a structured coordination framework that organizes agents through role specialization, constrained inter-agent communication, and coordinator-mediated task aggregation. Experiments on full-stack Web application development tasks show that STM achieves competitive task completion quality and comparable token consumption relative to representative baselines, while incurring higher execution latency.

CCS Concepts

• Computing methodologies → Multi-agent systems; • Information systems → Web applications; • Software and its engineering → Collaboration in software development.

Introduction

Large Language Models (LLMs) and autonomous agents are increasingly transforming how complex tasks on the Web are performed. Agentic systems are being integrated into Web-facing applications such as search, information retrieval, software development, content generation, and interactive services, where agents can autonomously plan, execute, and coordinate multiple subtasks [3, 5, 6, 13, 18]. Compared with single-agent systems, multi-agent architectures provide additional parallelism, specialization, and task coverage, making them promising for complex tasks that require diverse capabilities and coordinated execution. As multi-agent systems become increasingly sophisticated, however, their effectiveness depends not only on the capabilities of individual agents but also on how many agents are deployed and how they interact. As agentic capabilities become increasingly integrated into Web applications, agentic Web systems are emerging as a new form of Web application infrastructure, where scalable agent coordination becomes an important systems concern [4, 15]. This makes the scalability and coordination of agentic Web systems an important research challenge, directly related to the design and orchestration of AI agents and multi-agent systems on the Web.

A fundamental challenge therefore arises in scaling multi-agent systems: does adding more agents always improve system performance? Recent studies have explored scaling LLM-based systems by increasing the number of agents [11]. However, simply expanding the agent population does not necessarily yield proportional performance gains [2, 8, 16, 19]. As more agents participate in a task, communication, synchronization, redundant computation, and coordination overhead can increase. Consequently, additional agents may provide diminishing returns or even reduce overall efficiency. This phenomenon resembles the classical Mythical Man-Month effect [7] in software engineering, where increasing manpower can paradoxically reduce productivity. Understanding this scaling behavior is therefore important for designing scalable multi-agent systems with effective coordination.

Existing research on multi-agent systems has primarily focused on improving agent collaboration frameworks [3, 5, 6, 13, 18] and reducing communication costs through more efficient interaction strategies [1, 20]. These approaches demonstrate the benefits of parallel execution and structured collaboration, but the relationship between agent population and coordination overhead remains insufficiently characterized. In particular, existing systems generally do not explicitly examine how coordination overhead evolves as the agent population increases or identify the efficient operating region of different agent population sizes. As a result, the trade-off between parallelism and coordination remains insufficiently understood, limiting principled guidance for determining an effective agent population in scalable multi-agent systems.

To address this gap, we conduct a systematic empirical study of agent population scaling in collaborative multi-agent systems. Using complex Web-oriented software-development tasks, we examine how token consumption and per-agent efficiency change as the number of agents increases. Our experiments reveal a consistent non-linear scaling pattern: increasing the agent population initially improves per-agent efficiency, whereas larger populations introduce increasing coordination-related costs and eventually lead to diminishing returns. We further keep task specifications, role prompts, model configurations, and decoding parameters consistent across experimental settings to provide a controlled comparison of different agent population sizes. These findings provide an empirical basis for understanding the scalability limits of multi-agent collaboration and motivating structured coordination mechanisms.

Motivated by these observations, we introduce the Surgical Team Model (STM), a structured coordination mechanism designed to manage agent population and interaction overhead. Inspired by the organization of specialized teams, STM assigns agents to task-specific roles, constrains unnecessary inter-agent communication, and employs coordinator-mediated task aggregation. Rather than maximizing the number of agents, STM organizes agents through a structured interaction topology that preserves the benefits of parallelism and specialization while limiting coordination overhead. Experiments demonstrate that STM achieves competitive task completion quality with comparable token-level cost to representative baselines, while incurring higher execution latency. These findings suggest that structured coordination can improve the scalability of multi-agent systems by controlling coordination overhead.

In summary, this paper makes the following contributions:

  • Empirical characterization of agent population scaling. We systematically investigate how agent population affects token-based efficiency in collaborative multi-agent systems, identifying a non-linear scaling pattern and characterizing the efficient operating regime under unstructured scaling.

  • Structural analysis of coordination overhead. We analyze how inter-agent interaction patterns contribute to coordination overhead in collaborative multi-agent systems, examining the structural cost implications of unstructured communication as agent populations grow.

  • Surgical Team Model for structured coordination. Motivated by the observed scaling behavior, we introduce STM, a role-based coordination mechanism that organizes agents through specialized roles, constrained communication, and coordinator-mediated aggregation. STM improves the quality–cost–latency trade-off compared with existing multi-agent frameworks.

Related Work

Prior work on multi-agent systems for software development, particularly in Web application development, can be broadly organized into two directions: agent scaling and coordination which examines communication mechanisms and the effects of increasing agent populations, and role-based collaboration which uses specialized agent roles to support task decomposition and coordination.

Agent Scaling and Coordination

Existing studies have explored communication and coordination mechanisms to improve the efficiency of multi-agent systems, including sparse message passing [1], adaptive communication topologies [17], large-scale coordination strategies [14], and communication protocols [20]. These approaches primarily aim to reduce unnecessary inter-agent communication and improve coordination efficiency.

Recent studies have also investigated how agent population affects system performance. Li et al. [11] examine the benefits of increasing the number of agents, while subsequent work shows that performance gains can saturate or decline as agent populations grow [2, 9, 16]. Such limitations have been attributed to redundant outputs, limited diversity, and increasing coordination costs. However, existing studies largely examine communication efficiency or population scaling separately, with limited systematic analysis of the joint relationship among agent population, coordination overhead, and task performance in collaborative software-development settings. Our work addresses this gap through a controlled empirical study across a broad range of agent populations.

Role-based collaboration

Role-oriented frameworks such as MetaGPT [6], ChatDev [13], AgentVerse [3], and CrewAI [5] assign specialized roles to facilitate task decomposition and collaborative execution. AutoGen [18] and CodeAgents [12] further support structured multi-agent interaction for code generation and software development, while CAMEL [10] explores role-playing based multi-agent collaboration.

These approaches demonstrate the benefits of role specialization and structured collaboration. However, their primary focus is on organizing agent capabilities and task interactions rather than explicitly managing agent population and coordination overhead as system scale increases. Our work studies this scaling problem and introduces the Surgical Team Model (STM), which combines role specialization with constrained communication and coordinator-mediated aggregation to improve scalability and efficiency.

Summary: Summary: Overall, existing studies have explored agent scaling, communication efficiency, and role-based collaboration, but relatively limited attention has been paid to how agent population, coordination overhead, and task performance jointly evolve as multi-agent systems scale. We address this gap through a systematic study of agent population scaling and introduce STM to enable structured coordination for scalable deployment in agentic Web systems.

Empirical Scaling Behavior of Agent Population

This section investigates how the agent population affects the scalability and token-based efficiency of agentic Web systems in Web application development. We formulate an empirical scaling model to characterize changes in per-agent token consumption as the agent population increases, and evaluate the resulting scaling behavior across diverse Web application development tasks.

Agent Population Scaling Model

Let nn denote the number of agents participating in a software development task. We characterize the token-based cost at population size nn using the total token consumption Tt(n)T_t(n). To compare systems with different agent populations, we define the per-agent token consumption as

Tp(n)=Tt(n)n.(1)T_p(n) = \frac{T_t(n)}{n}. \tag*{(1)}

A lower value of Tp(n)T_p(n) indicates lower average token consumption per engineering agent and serves as a proxy for token-based efficiency. This metric does not directly capture task quality or end-to-end execution latency, which are evaluated separately.

To characterize the effect of increasing the agent population, we define the marginal efficiency gain as

G(n)=Tp(n)−Tp(n+1).(2)G(n) = T_p(n) - T_p(n+1). \tag*{(2)}

When G(n)>0G(n) > 0, adding an agent reduces the per-agent token consumption and therefore improves token-based efficiency. When G(n)<0G(n) < 0, adding an agent increases the average token consumption per agent and reduces token-based efficiency. When G(n)G(n) approaches zero, the benefit of increasing the agent population becomes limited.

As the agent population grows, we characterize changes in marginal efficiency gains using the second-order difference

ΔG(n)=G(n+1)−G(n).(3)\Delta G(n) = G(n+1) - G(n). \tag*{(3)}

When G(n)>0G(n) > 0 and ΔG(n)<0\Delta G(n) < 0, the marginal efficiency gain decreases as the agent population increases, indicating diminishing returns in token-based efficiency. When G(n)≤0G(n) \le0, adding an agent no longer improves per-agent token efficiency. This analysis characterizes changes in marginal gains without assuming a specific functional form for the scaling behavior.

Based on the observed per-agent token consumption, we define the empirical optimal agent population as

n∗=arg min⁡n∈N Tp(n),(4)n^* = \underset{n \in N}{\operatorname{arg\,min}}\ T_p(n), \tag*{(4)}

where NN denotes the set of evaluated agent population sizes. Thus, n∗n^* identifies the configuration with the lowest average token consumption per agent among the evaluated population sizes. It represents an empirical optimum under the selected metric and evaluated population range, rather than a theoretical optimum over all possible agent population sizes.

The following sections empirically examine these scaling characteristics across a diverse set of Web application development tasks.

Scaling Behavior and Optimal Agent Population

We evaluate the population scaling model across a diverse set of application development tasks spanning four categories: high concurrency, data processing, system services, and niche systems. The workflow uses fixed functional roles, including Product Manager (PM), System Architect (SA), Full-Stack Engineer (Eng), and Project Manager (PMgr), while only the number of agents is varied. The evaluated agent populations are N={1,2,4,6,8,10,12,16,24,32}N = \{1, 2, 4, 6, 8, 10, 12, 16, 24, 32\}. For each task and population size nn, we record the total token consumption Tt(n)T_t(n) and compute the corresponding per-agent token consumption Tp(n)T_p(n). The empirical optimal population n∗n^* is then identified according to the criterion defined in Section 3.1. All other task descriptions, role prompts, and decoding parameters are kept fixed, with a temperature of 0.6 using the Moonshot Kimi API (kimi-k2-turbo-preview).

Figure 1 reports token consumption for eight Web application tasks spanning high-concurrency, data-processing, system-service, and niche applications. Each panel shows smoothed per-agent token consumption Tp(n)T_p(n) (top) and total token consumption Tt(n)T_t(n) (bottom) for one task. Across tasks, Tp(n)T_p(n) decreases at smaller population sizes and increases after an efficient region, while Tt(n)T_t(n) continues to increase with the agent population. A larger population can therefore reduce average token consumption per agent while increasing overall token expenditure. The empirical optimum is n∗=8n^* = 8 for e-commerce, commodity inventory, personal accounting, library management, and equipment borrowing, n∗=6n^* = 6 for movie-ticket booking, and n∗≈7.9n^* \approx7.9 and n∗≈8.2n^* \approx8.2 for the birthday-reminder and volunteer-registration tasks. On the e-commerce task, the smoothed per-agent curve reaches its minimum near n=8.2n = 8.2; we use the empirical value 8 because n∗n^* in (4) is defined over the discrete set NN. These optima are concentrated around n∗≈8n^* \approx8. Cross-framework curves aggregated over Django, Gin, and Express are reported in Appendix A.

Figure 1. Per-agent token consumption (top of each panel) and total token consumption (bottom of each panel) under different agent populations. Panels: (a) e-commerce, (b) movie-ticket booking, (c) commodity inventory, (d) personal accounting, (e) library management, (f) equipment borrowing, (g) birthday reminder, (h) volunteer registration. Shaded bands on the per-agent curve mark the parallel-gain, coordination-efficient, and coordination-dominated regimes, and the marker indicates the empirical optimum n∗n^*. One legend is shared across panels.

Three-Regime Scaling Behavior

Across the evaluated tasks, we observe a consistent three-regime scaling pattern as the agent population increases. Rather than improving monotonically with additional agents, token-based efficiency first improves, reaches an efficient region, and then deteriorates as the cost associated with larger agent populations becomes increasingly prominent.

Parallel-gain regime. When the agent population is small, adding engineering agents reduces per-agent token consumption. The additional agents increase parallel execution capacity, while the cost associated with the larger population remains relatively limited. As a result, the reduction in average token consumption outweighs the additional token expenditure.

Coordination-efficient regime. At intermediate population sizes, the benefits of additional parallelism and the cost associated with a larger population become relatively balanced. Per-agent token consumption reaches its minimum in this region, with the empirical optima concentrated around n∗≈8n^* \approx8 across the evaluated application development tasks. This regime represents an efficient operating range for the evaluated multi-agent workflow.

Coordination-dominated regime. When the agent population increases beyond the efficient region, additional agents provide progressively smaller gains in per-agent efficiency, while total token consumption continues to increase. Consequently, per-agent token consumption also increases, indicating that the additional cost of a larger population is no longer offset by improvements in average token efficiency.

Overall, the three regimes characterize a non-linear scaling behavior in agentic Web systems. As the population grows beyond the efficient region, coordination-related costs become increasingly important relative to the benefits of additional agents. These findings highlight that effective scaling depends not only on the number of agents, but also on how their interactions are organized.

From Scaling to Structuring: The Surgical Team Model (STM)

Motivated by the coordination bottleneck observed in the population scaling analysis, we propose the Surgical Team Model (STM), a structured coordination framework that organizes agents through role specialization, centralized coordination, and constrained communication. Rather than targeting a fixed agent population size, STM focuses on structuring agent interactions to address coordination challenges as the system scales. This section first introduces the STM architecture and its structured interaction topology, then analyzes the resulting coordination complexity and its scaling implications, and finally evaluates STM through empirical benchmarks against representative baselines.

Surgical Team Model for Structured Coordination

The scaling results in § 2.3 reveal a fundamental limitation of simply increasing the agent population. We refer to this limitation as the coordination bottleneck, where the coordination requirements associated with a growing agent population can increasingly offset the benefits of additional parallelism. This observation motivates a shift from agent scaling to interaction structuring. To address this bottleneck, we introduce the Surgical Team Model (STM), a structured coordination framework that organizes agents through three complementary design principles: role specialization, centralized coordination, and bounded communication.

The design of STM is inspired by the surgical team organization described by Brooks, in which a small number of specialized roles are coordinated through a central mechanism rather than unrestricted interactions among all participants. Following this principle, STM assigns agents explicit roles according to their functional responsibilities, which may include architecture design, implementation, testing, documentation, and deployment, depending on the development task. This role specialization establishes a clear division of labor, reduces responsibility overlap and redundant work, and enables agents to focus on well-defined subtasks. It also supports parallel execution when task dependencies permit, allowing specialized contributions to be coordinated toward a common development objective.

At the center of STM is a coordinator that manages the overall development process and serves as the primary interface between the development task and specialist agents. Given a software development task, the coordinator analyzes the requirements, decomposes the task into subtasks, and assigns them to appropriate agents based on their roles and the dependencies among subtasks. During execution, it monitors progress, manages task dependencies, and collects intermediate and final outputs for integration into a coherent solution. For dependent subtasks, the coordinator determines the execution order and forwards relevant intermediate results to subsequent agents. For sufficiently independent subtasks, it enables parallel execution. By separating overall process management from individual task execution, the coordinator provides a unified mechanism for orchestrating development activities and integrating their outputs.

As illustrated in Figure 2, STM organizes interactions between the central coordinator and role-specialized agents through explicit coordination pathways. The topology distinguishes task assignment, result aggregation, and high-level design synchronization, clarifying how information flows between the coordinator and specialists during development. Direct communication between specialists is restricted to interactions required by specific development dependencies, while other coordination is mediated by the central coordinator. This explicit interaction structure provides a basis for controlling communication as the agent population grows.

STM framework with structured interaction topology

Figure 2. STM framework with structured interaction topology. STM framework with a structured interaction topology. The system adopts a hub-and-spoke architecture in which a central coordinator manages interactions with specialized agents, replacing unrestricted pairwise communication with controlled, coordinator-mediated coordination.

Together, role specialization, centralized coordination, and bounded communication define the structural principles underlying STM. These principles establish a structured alternative to unrestricted multi-agent collaboration. Building on this design, the following section analyzes the implications of interaction organization for coordination overhead and scalability.

Interaction Topology of Structured Coordination

The scalability implications of STM can be analyzed by examining how the number of coordination relationships grows with the agent population. We compare the interaction complexity of unstructured multi-agent workflows with that of STM, focusing on the growth of potential pairwise communication relationships under different interaction topologies. We model the coordination structure of a multi-agent system with nn agents according to the number of inter-agent communication relationships induced by its interaction topology.

Unstructured coordination. In an unstructured multi-agent workflow, agents may communicate with multiple other agents during task execution. As the agent population increases, the number of potential communication relationships can grow rapidly. In a dense interaction setting, the number of possible pairwise relationships is proportional to n(n−1)/2n(n-1)/2, giving a quadratic upper bound on the interaction space:

Cunstructured(n)=O(n2).C_{\mathrm{unstructured}}(n) = O(n^2).

This quadratic growth characterizes the potential interaction space rather than the actual number of communication events. It nevertheless indicates that unrestricted interaction can introduce increasingly complex coordination relationships as more agents participate in the development process.

STM structured coordination. In contrast, STM restricts communication through role specialization and a centralized coordination interface. Each specialist agent communicates through a bounded number of interfaces independently of the total agent population. As a result, the number of communication relationships induced by the STM topology grows approximately linearly with the agent population:

CSTM(n)=O(n).C_{\mathrm{STM}}(n) = O(n).

Under an unstructured topology, the number of potential communication relationships associated with an agent can increase with the population size. In STM, specialist agents primarily communicate with the central coordinator, keeping their communication degree bounded. Thus, increasing the number of specialist agents does not require a corresponding increase in direct peer-to-peer communication relationships.

Scaling implication. The difference between these interaction structures provides a structural explanation for their different scaling behavior. As the agent population increases, an unstructured topology may introduce an increasingly large interaction space, whereas STM constrains the growth of topology-induced coordination complexity. This allows additional agents to contribute execution capacity without proportionally increasing the coordination relationships that must be managed by each specialist.

This analysis should be distinguished from the total execution cost of a multi-agent system. The expressions Cunstructured(n)=O(n2)C_{\mathrm{unstructured}}(n) = O(n^2) and CSTM(n)=O(n)C_{\mathrm{STM}}(n) = O(n) describe the growth of the interaction structure rather than the complete system cost. In practice, model inference, task complexity, output generation, tool invocation, execution dynamics, and coordination rounds also contribute to the actual cost.

Efficiency Model. To conceptually characterize the trade-off between task quality and overall system cost, we define collaboration efficiency as:

E(n)=Q(n)C(n).E(n) = \frac{Q(n)}{C(n)}.

where Q(n)Q(n) represents the quality of the completed task and C(n)C(n) denotes the overall system cost associated with the corresponding configuration. This formulation provides a conceptual basis for interpreting the quality–cost trade-off. In the empirical evaluation, however, task quality, token consumption, and execution latency are reported separately rather than combined into a single efficiency score.

Empirical Connection. In our experiments, the exact coordination cost cannot be directly isolated because agent execution and inter-agent communication are jointly reflected in model token usage. We therefore use total token consumption Ttotal(n)T_{\mathrm{total}}(n) as an empirical proxy for overall system cost:

C(n)≈Ttotal(n).C(n) \approx T_{\mathrm{total}}(n).

This proxy captures both execution- and coordination-related token usage and should not be interpreted as a direct measurement of communication cost alone. We use it to compare the overall cost of different agent configurations under the same task and model settings.

The empirical optimal agent population n∗n^{*} is determined according to the criterion defined in § 2. This definition identifies the population size with the lowest average token cost per agent among the evaluated configurations. It provides an empirical token-based optimum for the evaluated population sizes and is distinct from the conceptual efficiency formulation E(n)E(n).

Overall, the topology analysis and empirical measurements provide complementary views of scalable coordination. The topology characterizes how potential communication relationships grow with the agent population, while the token-based measurements capture the resulting overall system cost during practical execution. Together, they provide a structural and empirical basis for understanding how STM addresses the coordination bottleneck identified in § 2.3.

Empirical Evaluation

To empirically evaluate the scaling and coordination model in § 3.2, we evaluate STM on five full-stack Web application development tasks, including e-commerce, inventory management, equipment borrowing, birthday reminder, and commodity inventory management. All tasks are implemented on a unified technology stack, consisting of a Gin backend, Preact frontend, and PostgreSQL database, to ensure comparability across different systems. Experiments are conducted using the moonshot-v1-8k model via the Kimi API under identical task specifications across all baselines.

Experimental Setup. The evaluation considers STM and two representative baselines, MetaGPT and Claude Code. MetaGPT represents a role-based multiagent framework that organizes development through multiple specialized agents, while Claude Code serves as a representative coding-agent baseline. For STM, all experiments follow the coordination structure described in § 3.1, where a central coordinator organizes interactions among specialist agents. These baselines provide reference points for evaluating STM against both multi-agent and single-agent development paradigms.

Evaluation Metrics

Evaluation Metrics. We evaluate the systems from the following metrics.

Cost Approximation. Following the coordination model in § 3.2, we use total token consumption as an empirical proxy for the overall system cost. Specifically, C(n)≈Ttotal(n)C(n) \approx T_{\mathrm{total}}(n) is used as an empirical approximation, where Ttotal(n)T_{\mathrm{total}}(n) denotes the total number of input and output tokens consumed by the system with nn agents. This proxy captures both inter-agent coordination and execution-related token usage. It therefore reflects the overall token-level cost of the system rather than serving as a direct measurement of communication cost alone.

Quality Definition. We measure task quality using effective code lines LeffL_{\mathrm{eff}} and the overall completion rate RoverallR_{\mathrm{overall}}. The effective code lines represent the number of functional lines of generated code that contribute to successful task completion, providing a quantitative measure of the amount of usable implementation produced by each system. The overall completion rate is defined as Roverall=∑i=1mRiwiR_{\mathrm{overall}} = \sum_{i=1}^{m} R_i w_i, where Ri∈[0,1]R_i \in[0, 1] denotes the completion rate of development task ii, mm is the number of evaluated tasks, and wiw_i is the weight assigned to task ii, with ∑i=1mwi=1\sum_{i=1}^{m} w_i = 1. For each task, RiR_i reflects the proportion of required functionality successfully implemented and validated. When all tasks are weighted equally, wi=1/mw_i = 1/m. This metric measures the extent to which the generated applications satisfy their required functionality, while LeffL_{\mathrm{eff}} provides a complementary measure of the functional implementation produced by each system.

System Efficiency. We use E(n)=Q(n)C(n)E(n) = \frac{Q(n)}{C(n)} as a conceptual formulation of the quality–cost trade-off introduced in § 3.2. Here, Q(n)Q(n) represents task quality and C(n)C(n) represents the overall system cost. The formulation provides a conceptual basis for interpreting whether improvements in task quality are obtained at a reasonable system cost. In the empirical evaluation, however, we report task quality, token consumption, and execution latency separately rather than combining them into a single efficiency score. This separation avoids introducing an additional weighting scheme among heterogeneous evaluation metrics.

Operational Metrics. We additionally track implementation-level statistics to characterize the execution behavior of different systems. Total token consumption is defined as Ttotal=Tprompt+TcompletionT_{\mathrm{total}} = T_{\mathrm{prompt}} + T_{\mathrm{completion}}, where TpromptT_{\mathrm{prompt}} and TcompletionT_{\mathrm{completion}} denote input and output token usage, respectively. Execution time is measured as Texec=Tend−TstartT_{\mathrm{exec}} = T_{\mathrm{end}} - T_{\mathrm{start}}, where TstartT_{\mathrm{start}} and TendT_{\mathrm{end}} denote the beginning and end timestamps of task execution. We also report the number of agent calls NcallsN_{\mathrm{calls}} to characterize the interaction overhead associated with each system. These metrics provide complementary views of system cost: token consumption reflects the amount of model computation and generated information, agent calls characterize interaction frequency, and execution time reflects the end-to-end latency of completing a development task.

Benchmark Comparison

Benchmark Comparison. We compare STM against MetaGPT and Claude Code in terms of task completion quality, token-based system cost, and implementation-level operational metrics, as shown in Table 1 and Table 2. The two comparisons provide complementary reference points for evaluating the practical effects of STM’s structured coordination design.

TaskRoverallR_{\mathrm{overall}} (↑\uparrow) Base.RoverallR_{\mathrm{overall}} (↑\uparrow) STMNcallsN_{\mathrm{calls}} (↓\downarrow) Base.NcallsN_{\mathrm{calls}} (↓\downarrow) STMLeffL_{\mathrm{eff}} (↑\uparrow) Base.LeffL_{\mathrm{eff}} (↑\uparrow) STMTtotalT_{\mathrm{total}} (↓\downarrow) Base.TtotalT_{\mathrm{total}} (↓\downarrow) STMTexecT_{\mathrm{exec}} (↓\downarrow) Base.TexecT_{\mathrm{exec}} (↓\downarrow) STM
Birthday Reminder65%86%15101745612273840924.57s128.1s
Equip. Borrowing53%78%15101883532192734829.29s131.1s
E-Commerce System49%78%15101142681664805826.79s172.4s
Inventory Mgmt.43%88%15101553021745632121.69s114.3s
Commodity Inv.43%88%1510834471607804920.35s134.0s
Avg.51%84%15101433861896763723.54s136.0s

Table 1. Comprehensive Benchmark: STM Performance VS. MetaGPT

TaskRoverallR_{\mathrm{overall}} (↑\uparrow) Base.RoverallR_{\mathrm{overall}} (↑\uparrow) STMNcallsN_{\mathrm{calls}} (↓\downarrow) Base.NcallsN_{\mathrm{calls}} (↓\downarrow) STMLeffL_{\mathrm{eff}} (↑\uparrow) Base.LeffL_{\mathrm{eff}} (↑\uparrow) STMTtotalT_{\mathrm{total}} (↓\downarrow) Base.TtotalT_{\mathrm{total}} (↓\downarrow) STMTexecT_{\mathrm{exec}} (↓\downarrow) Base.TexecT_{\mathrm{exec}} (↓\downarrow) STM
Birthday Reminder71.0%80.0%7747346366416396126.0s124.5s
Equip. Borrowing92.5%100.0%7755862672387553136.7s146.7s
E-Commerce System87.1%87.1%8864565686999260161.2s171.8s
Inventory Mgmt.84.8%87.2%88107086111741174225.3s462.8s
Commodity Inv.74.6%74.3%8810788781265012802149.3s166.7s
Avg.82.0%85.7%7.67.6764.8696.87280.47437.0159.7s214.5s

Table 2. Comprehensive Benchmark: STM Performance VS. Claude Code

Task Completion Quality. STM significantly outperforms MetaGPT in task completion quality, achieving an average completion rate of 84% compared with 51%. It also produces approximately 2.7× more effective code lines (LeffL_{\mathrm{eff}}), with average values of 386 and 143, respectively. These results indicate that STM produces more functional implementation under the evaluated development tasks.

Compared with Claude Code, STM achieves an average completion rate of 85.7%, while Claude Code achieves 82.0%. The difference is relatively small, indicating that STM remains competitive with a strong coding-agent baseline despite employing a multi-agent coordination structure. The results therefore suggest that introducing multiple specialized agents does not necessarily compromise task completion quality when their interactions are organized through a constrained communication structure.

System Cost and Operational Metrics. STM exhibits a different cost profile from the two baselines. Compared with MetaGPT, STM uses fewer agent calls on average, with 10 calls compared with 15 for MetaGPT, but consumes more total tokens, with 7637 tokens compared with 1896 tokens. This result indicates that reducing the number of agent interactions does not necessarily reduce overall token consumption. The structured workflow may instead involve more substantial generation within each interaction, particularly when specialist agents are responsible for producing more complete outputs within their assigned roles.

The execution time also differs substantially between the two systems. STM requires an average of 136.0 seconds, compared with 23.54 seconds for MetaGPT. Thus, although STM reduces the number of agent calls, its individual interactions are more computationally substantial and result in higher end-to-end execution time. This observation is consistent with the distinction made in § 3.2 between topology-level coordination complexity and total execution cost.

Compared with Claude Code, STM has comparable average total token consumption, with 7437 tokens for STM and 7280.4 tokens for Claude Code. Both systems also use the same average number of agent calls, 7.6. However, STM requires more execution time on average, with 214.5 seconds compared with 159.7 seconds for Claude Code. These results indicate that STM maintains a comparable token-level cost while introducing additional execution latency in the evaluated setting.

Efficiency. The results demonstrate a clear quality–cost trade-off for STM. Compared with MetaGPT, STM substantially improves task completion quality and effective code generation, at the expense of higher token consumption and execution time. In other words, the additional system cost is accompanied by a substantial improvement in functional output. This trade-off is consistent with the conceptual efficiency formulation E(n)=Q(n)/C(n)E(n) = Q(n)/C(n), but we do not reduce the empirical results to a single efficiency score.

Compared with Claude Code, STM achieves a slightly higher average completion rate, with 85.7% compared with 82.0%, while maintaining comparable total token consumption. The difference in completion quality is relatively small, suggesting that STM can provide competitive task performance without substantially increasing token-level system cost. However, the higher execution time indicates that token-level cost and end-to-end latency capture different aspects of system efficiency.

Overall, STM achieves competitive task completion quality while maintaining comparable token consumption to Claude Code, although with higher execution latency. These results suggest that structured coordination can support scalable multi-agent development by organizing agent interactions without requiring a fully decentralized interaction structure.

Scalability and Discussion. The results highlight the practical trade-offs associated with STM’s structured coordination design. Compared with MetaGPT, STM achieves higher task completion rates and produces more effective code lines while requiring fewer agent calls. However, these improvements come with higher token consumption and execution latency. Compared with Claude Code, STM achieves competitive task completion quality and comparable token consumption, but incurs higher execution latency. These findings indicate that the benefits of structured coordination are reflected primarily in task completion quality and the organization of agent interactions, rather than in uniformly lower execution costs.

These empirical observations complement the topology-level analysis in § 3.2. The theoretical analysis characterizes the growth of potential communication relationships under different interaction topologies, whereas the benchmark results measure overall token consumption and end-to-end execution latency. The latter are also affected by model inference, task complexity, output generation, and execution dynamics. Therefore, the linear growth of STM’s topology-induced coordination relationships should not be interpreted as evidence of linear growth in total execution cost or as a guarantee of lower empirical cost. Instead, the topology-level analysis explains the structural scalability of STM, while the empirical results characterize its practical performance under different quality, token-consumption, and execution-latency requirements.

Conclusion

This work investigates agent population scaling in agentic Web systems and identifies a non-linear pattern in which per-agent token consumption initially decreases but eventually increases as coordination-related costs grow. Motivated by this finding, we propose STM, a structured coordination framework based on specialized roles and bounded interaction. By organizing collaboration through a central coordinator, STM provides a systematic way to manage task decomposition, information exchange, and result integration as agent populations grow. Experiments on full-stack Web application development tasks show that STM achieves competitive task completion quality with token consumption comparable to that of a strong coding-agent baseline. These findings highlight the importance of structured coordination in designing scalable multi-agent development systems and demonstrate the need to consider interaction organization alongside agent population size.

Future work will explore adaptive coordination mechanisms, including dynamic role allocation and communication strategies that respond to task complexity and resource constraints. We will also investigate cross-model collaboration and evaluate these approaches across diverse Web application development scenarios to further improve the scalability and robustness of agentic Web systems.

Ethics and Privacy Statement

This work does not involve human participants or personal data, and therefore does not raise issues related to informed consent or human-subject privacy. The proposed structured coordination approach is intended to improve the scalability and efficiency of multi-agent software development; potential risks mainly concern the future misuse of autonomous agent systems, such as unintended software generation or deployment. We encourage the use of appropriate human oversight and safety mechanisms when deploying such systems in real-world Web environments.

References

Additional Experimental Results

Figure 1 in the main text shows per-agent and total token consumption for each task. This appendix examines the same eight tasks through the cross-framework curves in Figure 3, where each panel aggregates Django, Gin, and Express. Across these settings, per-agent token consumption remains approximately U-shaped, and the optimal team size stays in the same range as in the main experiments.

Figure 3. Cross-framework per-agent token consumption. Panels: (a) e-commerce, (b) movie-ticket booking, (c) commodity inventory, (d) personal accounting, (e) library management, (f) equipment borrowing, (g) birthday reminder, (h) volunteer registration. Each panel aggregates Django, Gin, and Express implementations of one task. The band is the mean ±\pm standard deviation, and the marker indicates the smoothed optimum. One legend is shared across panels.

High-Concurrency Systems

This category includes event-driven systems with bursty requests and strong real-time constraints. These tasks are sensitive to coordination overhead due to frequent inter-agent interactions.

Instance: Movie Ticket Booking System. As illustrated in Figure 1(b) and Figure 3(b), the movie ticket booking system exhibits an optimal team size of n∗=6n^* = 6. The per-agent curve shows a transition from the Parallel-Gain Regime to the Coordination-Dominated Regime, with the minimum indicating the empirically optimal team size.

Cross-framework aggregation across Django, Gin, and Express yields n∗≈6.9n^* \approx6.9, indicating consistent scaling behavior across different backend implementations.

Data Processing Systems

This category involves structured workflows such as data collection, cleaning, and storage. Compared with event-driven systems, coordination costs are primarily associated with the structure and dependencies of the processing pipeline.

Instance: Commodity Inventory Management Tool. As shown in Figure 1(c) and Figure 3(c), the commodity inventory management system exhibits an optimal team size of n∗=8n^* = 8. The U-shaped curve indicates that moderate task decomposition reduces the per-agent token cost, while further scaling introduces increasing coordination overhead.

Cross-framework aggregation across Django, Gin, and Express yields n∗≈7.6n^* \approx7.6, indicating stable scaling behavior across different implementations.

Instance: Personal Accounting Applet.

As shown in Figure 1(d) and Figure 3(d), the personal accounting applet exhibits an optimal team size of n∗=8n^{*} = 8. The relatively flat U-shaped curve around the minimum suggests a wider range of team sizes with similar per-agent token consumption.

Cross-framework aggregation yields n∗≈7.6n^{*} \approx7.6, consistent with the scaling behavior observed across the other systems.

System Service Tasks

These tasks feature modular architectures with relatively decoupled components, resulting in comparatively stable coordination patterns.

Instance: Library Management System.

As shown in Figure 1(e) and Figure 3(e), the library management system exhibits an optimal team size of n∗=8n^{*} = 8. The results indicate that task decomposition remains beneficial at moderate team sizes, while additional agents introduce coordination overhead beyond the optimum.

Cross-framework aggregation across Django, Gin, and Express yields n∗≈8.2n^{*} \approx8.2, suggesting stable scaling behavior across different backend configurations.

Instance: Equipment Borrowing System.

As shown in Figure 1(f) and Figure 3(f), the equipment borrowing system exhibits an optimal team size of n∗=8n^{*} = 8. The results show the same non-linear scaling pattern, with increasing coordination overhead as the team size grows beyond the optimum.

Niche Applications

Niche applications involve lightweight business logic and relatively limited concurrency. Despite their simplicity, these systems still exhibit non-linear scaling behavior as the agent population increases.

Instance: Birthday Reminder System.

As shown in Figure 1(g) and Figure 3(g), the birthday reminder system exhibits an optimal team size of n∗=7.9n^{*} = 7.9. The results indicate that increasing the agent population beyond the optimum introduces additional coordination overhead without reducing the per-agent token cost.

Instance: Volunteer Registration System.

As shown in Figure 1(h) and Figure 3(h), the volunteer registration system exhibits an optimal team size of n∗=8.2n^{*} = 8.2. Despite differences in task characteristics, the same non-linear scaling pattern is observed.

References

  1. [1]Dong Chen, Kaixiang Zhang, Yongqiang Wang, Xunyuan Yin, Zhaojian Li, and Dimitar Filev. 2024. Communication-Efficient Decentralized Multi-Agent Reinforcement Learning for Cooperative Adaptive Cruise Control. IEEE Transactions on Intelligent Vehicles 9, 10 (Oct. 2024), 6436–6449. doi:10.1109/TIV.2024.3368025DOI
  2. [2]Nuo Chen, Yicheng Tong, Yuzhe Yang, Yufei He, Xueyi Zhang, Qingyun Zou, Qian Wang, and Bingsheng He. 2026. Diversity Collapse in Multi-Agent LLM Systems: Structural Coupling and Collective Failure in Open-End Idea Generation. In Findings of the Association for Computational Linguistics: ACL 2026. Association for Computational Linguistics, San Diego, California, United States, 251–306.
  3. [3]Weize Chen, Yusheng Su, Jingwei Zuo, Cheng Yang, Chenfei Yuan, Chi-Min Chan, Heyang Yu, Yaxi Lu, Yi-Hsin Hung, Chen Qian, Yujia Qin, Xin Cong, Ruobing Xie, Zhiyuan Liu, Maosong Sun, and Jie Zhou. 2024. AgentVerse: Facilitating Multi-Agent Collaboration and Exploring Emergent Behaviors. In International Conference on Learning Representations. OpenReview.net, Vienna, Austria, 20094–20136.arxiv.org/abs/2308.10848
  4. [4]Guanting Dong, Licheng Bao, Zhongyuan Wang, Kangzhi Zhao, Xiaoxi Li, Jiajie Jin, Jinghan Yang, Hangyu Mao, Fuzheng Zhang, Kun Gai, Guorui Zhou, Yutao Zhu, Ji-Rong Wen, and Zhicheng Dou. 2025. Toward Generalized Web Agent Training: A Deep Dive into Entropy-Balanced Reinforcement Learning. In Proceedings of the ACM Web Conference (WWW). ACM, Dubai, United Arab Emirates, 2126–2137.DOI
  5. [5]ZhiHua Duan and Jialin Wang. 2024. Exploration of LLM Multi-Agent Application Implementation Based on LangGraph+CrewAI. arXiv:2411.18241 doi:10.48550/arXiv.2411.18241
  6. [6]Sirui Hong, Mingchen Zhuge, Jiaqi Chen, Xiawu Zheng, Yuheng Cheng, Ceyao Zhang, Jinlin Wang, Zili Wang, Steven Ka Shing Yau, Zijuan Lin, Liyang Zhou, Chenyu Ran, Lingfeng Xiao, Chenglin Wu, and Jürgen Schmidhuber. 2023. MetaGT: Meta Programming for A Multi-Agent Collaborative Framework. arXiv:2308.00352 doi:10.48550/arXiv.2308.00352DOI
  7. [7]Frederick P. Brooks Jr. 1995. The Mythical Man-Month: Essays on Software Engineering (2nd ed.). Addison-Wesley, Boston, MA.
  8. [8]Yubin Kim, Ken Gu, Chuanwoo Park, Chunjong Park, Samuel Schmidgall, A. Ali Heydari, Yao Yan, Zhihan Zhang, Yuchen Zhuang, Yun Liu, Mark Malhotra, Paul Pu Liang, Hae Won Park, Yuzhe Yang, Xuahi Xu, Yilun Du, Shwetak Patel, Tim Althoff, Daniel McDuff, and Xin Liu. 2025. Towards a Science of Scaling Agent Systems. arXiv:2512.08296 doi:10.48550/arXiv.2512.08296DOI
  9. [9]Yubin Kim, Ken Gu, Chuanwoo Park, Chunjong Park, Samuel Schmidgall, A. Ali Heydari, Yao Yan, Zhihan Zhang, Yuchen Zhuang, Yun Liu, Mark Malhotra, Paul Pu Liang, Hae Won Park, Yuzhe Yang, Xuahi Xu, Yilun Du, Shwetak Patel, Tim Althoff, Daniel McDuff, and Xin Liu. 2026. Capable Language Models Can Outgrow the Benefits of Collaboration. Nature Machine Intelligence 8, 7 (July 2026), 1157–1172. doi:10.1038/s42256-026-01268-yDOI
  10. [10]Guohao Li, Hasan Abed Al Kader Hammoud, Hani Itani, Dmitrii Khizbullin, and Bernard Ghanem. 2023. CAMEL: Communicative Agents for "Mind" Exploration of Large Language Model Society. In Advances in Neural Information Processing Systems 36. Neural Information Processing Systems Foundation, Inc., New Orleans, Louisiana, USA, 51991–52008.
  11. [11]Junyu Li, Qin Zhang, Yangbin Yu, Qiang Fu, and Deheng Ye. 2024. More Agents Is All You Need. arXiv:2402.05120 doi:10.48550/arXiv.2402.05120DOI
  12. [12]Aditya Paranjape, John X. Morris, Valentin Hofmann, et al. 2024. CodeAgents: Evaluating LLMs with Communicative Agents for Code Review. In Proceedings of EMNLP. Association for Computational Linguistics, Miami, Florida, USA, 10987–11002.
  13. [13]Qian Qian, Wei Liu, Hongzhang Liu, Nuo Chen, Yufan Dang, Jiahao Li, Cheng Yang, Weize Chen, Yusheng Su, Xin Cong, Juyuan Xu, Dahai Li, Zhiyuan Liu, and Maosong Sun. 2024. ChatDev: Communicative Agents for Software Development. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics. Association for Computational Linguistics, Bangkok, Thailand, 15174–15186.
  14. [14]Chen Qian, Zihao Xie, YiFei Wang, Wei Liu, Kunlun Zhu, Hanchen Xia, Yufan Dang, Zhuoyun Du, Weize Chen, Cheng Yang, Zhiyuan Liu, and Maosong Sun. 2025. Scaling Large Language Model-based Multi-Agent Collaboration. In International Conference on Learning Representations. OpenReview.net, Singapore, 41488–41505.arxiv.org/abs/2406.07155
  15. [15][15*] Jinwei Su, Qizhen Lan, Yinghui Xia, Lifan Sun, Weiyou Tian, Tianyu Shi, and Liewei He. 2026. Difficulty-Aware Agentic Orchestration for Query-Specific Multi-Agent Workflows. In Proceedings of the ACM Web Conference (WWW).arxiv.org/abs/2509.11079
  16. [16]Dat Tran and Douwe Kiela. 2026. Single-Agent LLMs Outperform Multi-Agent Systems on Multi-Hop Reasoning Under Equal Thinking Token Budgets. arXiv:2604.02460 doi:10.48550/arXiv.2604.02460
  17. [17]Jianrui Wang, Yi Li, Yitian Hong, and Yang Tang. 2025. Integrated Adaptive Communication in Multi-Agent Systems: Dynamic Topology, Frequency, and Content Optimization for Efficient Collaboration. Neurocomputing 613 (Feb. 2025), 129068. doi:10.1016/j.neucom.2024.129068DOI
  18. [18]Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, Beibin Li, Erkang Zhu, Li Jiang, Xiaoyun Zhang, Shaukun Zhang, Jiale Liu, Ahmed Hassan Awadallah, Ryen W. White, Doug Burger, and Chi Wang. 2024. AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation. In Proceedings of the 1st Conference on Language Modeling. Philadelphia, PA, USA, 1–46.arxiv.org/abs/2308.08155
  19. [19]Yingxuan Yang, Chengrui Qu, Muning Wen, Laixi Shi, Ying Wen, Weinan Zhang, Adam Wierman, and Shangding Gu. 2026. Understanding Agent Scaling in LLM-Based Multi-Agent Systems via Diversity. In ICLR 2026 Workshop on AI for Mechanism Design and Strategic Decision Making (AIMS). OpenReview.net, Singapore, 1–26.arxiv.org/abs/2602.03794
  20. [20]Yujia Zheng, Zhuokai Zhao, Zijian Li, Yaqi Xie, Mingze Gao, Lizhu Zhang, and Kun Zhang. 2025. Thought Communication in Multiagent Collaboration. In Advances in Neural Information Processing Systems 38. Curran Associates, Inc., San Diego, California, USA and Mexico City, Mexico, 136784–136813.arxiv.org/abs/2510.20733

Paper details

vlnc:W_psryr324
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC0-1.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents