2604.02674

# Do Agent Societies Develop Intellectual Elites? The Hidden Power Laws of Collective Cognition in LLM Multi-Agent Systems **Authors**: - Kavana Venkatesh (Department of Computer Science) - Virginia Tech - Blacksburg, VA - &Jiaming Cui (Department of Computer Science) - Virginia Tech - Blacksburg, VA ## Abstract Large Language Model (LLM) multi-agent systems are increasingly deployed as interacting agent societies, yet scaling these systems often yields diminishing or unstable returns, the causes of which remain poorly understood. We present the first large-scale empirical study of coordination dynamics in LLM-based multi-agent systems, introducing an atomic event-level formulation that reconstructs reasoning as cascades of coordination. Analyzing over 1.5 Million interactions across tasks, topologies, and scales, we uncover three coupled laws: coordination follows heavy-tailed cascades, concentrates via preferential attachment into intellectual elites, and produces increasingly frequent extreme events as system size grows. We show that these effects are coupled through a single structural mechanism: an integration bottleneck, in which coordination expansion scales with system size while consolidation does not, producing large but weakly integrated reasoning processes. To test this mechanism, we introduce Deficit-Triggered Integration (DTI), which selectively increases integration under imbalance. DTI improves performance precisely where coordination fails, without suppressing large-scale reasoning. Together, our results establish quantitative laws of collective cognition and identify coordination structure as a fundamental, previously unmeasured axis for understanding and improving scalable multi-agent intelligence. ## 1 Introduction LLM multi-agent systems (MAS) have been widely used in planning, coding, and deliberative reasoning tasks Chen et al. (2023); Qian et al. (2024a); Du et al. (2024); Venkatesh et al. (2026). However, a major challenge lies in their reliability under scaling: adding more agents does not naturally yield proportional gains; instead, performance may plateau, oscillate, or even degrade beyond a certain tipping point Chen et al. (2024b); Cemri et al. (2025). Despite substantial efforts in prompting and reasoning Wei et al. (2022); Yao et al. (2022), these failures remain stubborn, indicating that the problem is structural and systematic. These dynamics run deeper than current benchmarks capture. Existing metrics for LLM MAS: task success, final-answer accuracy, and cumulative reward Liu et al. (2023a), are largely centered on outcomes while overlooking the internal dynamics of collective reasoning. As a result, they cannot distinguish coordinated synthesis from fragmented processes that coincidentally reach correct answers Zhuge et al. (2024); Cemri et al. (2025), nor capture how effort is distributed, influence accumulates, or coordination stabilizes. Consequently, while prior analyses document scaling failures, they do not explain them systematically Chen et al. (2024b); Cemri et al. (2025), leaving architectural choices heuristic and interventions reactive Guo et al. (2024). What is missing is a science of coordination dynamics; not what agents produce, but how reasoning is initiated, propagated, contested, and resolved across them Guo et al. (2024). Therefore, in this paper, we show that LLM multi-agent systems exhibit cascade-driven dynamics, in which agents interact iteratively and respond to prior outputs Du et al. (2024), while delegation and contradiction induce branching cascades. The final output is thus shaped by the full tree of downstream events that an initial reasoning step generates Liang et al. (2024). These interaction patterns reveal that coordination is not evenly distributed, but rather organized through expanding and competing cascades of reasoning activity: claims that attract early engagement are more likely to recruit further coordination, suggesting a reinforcement effect in how reasoning activity is routed and amplified. Meanwhile, the unfolding of such coordination is constrained by factors such as limited context Packer et al. , communication bandwidth, and token budgets Gu et al. (2024). Taken together, these characteristics suggest that coordination in LLM multi-agent systems may be governed by heterogeneous cascade dynamics. Similar dynamics have been widely observed in other complex systems Barabási and Albert (1999); Barabasi (2005); Newman (2005); Goh et al. (2001). Motivated by these observations, we propose a testable hypothesis: coordination event sizes may follow heavy-tailed distributions under finite constraints. We empirically validate this hypothesis over 1.5 million coordination events, spanning diverse coordination topologies, task families, system scales, and model families. Specifically, we introduce a set of atomic coordination events: delegation cascades, revision waves, contradiction bursts, synthesis merges, and total cognitive effort, as observables for capturing how reasoning activity propagates and accumulates. A systematic analysis across all setups indicates that coordination event sizes consistently follow truncated power-law distributions, with estimated exponents $\hat{α}∈(2,3)$ . These estimates are obtained via maximum-likelihood estimation following established methodology Newman (2005); Clauset et al. (2009), and remain within $(2,3)$ across tasks, topologies, scales, and model families. Likelihood-ratio tests under the Vuong framework Vuong (1989) further confirm that the truncated power law provides a significantly better fit than alternative candidate distributions, such as the log-normal and pure power law, with $p<0.05$ . Importantly, we do not assume power-law behavior a priori. Instead, we statistically test for heavy-tailed structure under finite constraints following established inference procedures Newman (2005); Stumpf and Porter (2012). To the best of our knowledge, this is the first systematic empirical evidence that coordination in LLM multi-agent systems exhibits heavy-tailed cascade dynamics at the level of reasoning events. These results identify a consistent organizational regime characterized by heterogeneous cascades, with direct implications for how collective reasoning is structured and scaled. <details> <summary>2604.02674v1/x1.png Details</summary>  ### Visual Description ## Line Graphs: Event Size Probability Distributions ### Overview The image contains five horizontally aligned line graphs, each depicting the probability distribution of event sizes for different network phenomena. All graphs use a log-log scale, with event size (x) on the x-axis and probability (P(X ≥ x)) on the y-axis. Each graph includes a fitted power-law curve (dashed line) and empirical data points (dots), with parameters like slope (α), minimum event size (x_min), and tail count (n_tail) labeled. --- ### Components/Axes - **X-axis**: "Event Size (x)" (log scale, 10⁰ to 10²) - **Y-axis**: "P(X ≥ x)" (log scale, 10⁻⁴ to 10⁰) - **Legends**: Positioned at the top-right of each graph, labeled "Empirical" (dots) and "MLE Fit" (dashed line). - **Graph Titles**: 1. Delegation Cascade 2. Revision Wave 3. Contradiction Burst 4. Merge Fan-In 5. Total Effort (TCE) - **Parameter Labels**: - Slope (α) in bottom-left (e.g., α = 2.28) - x_min (minimum event size) - n_tail (tail event count) --- ### Detailed Analysis 1. **Delegation Cascade** (Blue) - Slope (α): -1.28 - x_min: 5 - n_tail: 92,400 - Trend: Gradual decay with a moderate slope. 2. **Revision Wave** (Red) - Slope (α): -1.41 - x_min: 4 - n_tail: 134,300 - Trend: Steeper decay than Delegation Cascade. 3. **Contradiction Burst** (Green) - Slope (α): -1.16 - x_min: 4 - n_tail: 56,200 - Trend: Shallowest decay among all graphs. 4. **Merge Fan-In** (Orange) - Slope (α): -1.71 - x_min: 3 - n_tail: 39,000 - Trend: Sharpest decay, indicating rapid probability drop-off. 5. **Total Effort (TCE)** (Purple) - Slope (α): -1.22 - x_min: 8 - n_tail: 123,400 - Trend: Moderate decay with the highest x_min. --- ### Key Observations - **Slope Variance**: Merge Fan-In has the steepest slope (-1.71), suggesting the fastest decay in probability with increasing event size. Contradiction Burst has the shallowest slope (-1.16), indicating slower decay. - **x_min Differences**: Total Effort (x_min = 8) has the largest minimum event size, while Merge Fan-In (x_min = 3) has the smallest. - **Tail Counts**: Total Effort has the highest n_tail (123,400), implying a heavier tail distribution compared to others. --- ### Interpretation The graphs reveal distinct behavioral patterns for different network phenomena: - **Merge Fan-In** exhibits the most rapid decay (steepest slope), suggesting events of this type are less likely to occur at larger sizes. - **Contradiction Burst** shows the slowest decay, implying a higher likelihood of large events persisting. - **Total Effort (TCE)** has the largest minimum event size (x_min = 8), indicating it primarily affects larger-scale events. - The **n_tail** values correlate with the tail distribution's heaviness: higher n_tail values (e.g., Total Effort) suggest more extreme tail behavior. These results highlight how different network processes exhibit unique size-distribution characteristics, with implications for modeling and predicting event cascades in complex systems. </details> Figure 1: Heavy-tailed coordination cascades across observables. CCDFs show a power-law regime ( $2<\hat{α}<3$ ) with truncation at large $x$ . Dashed lines indicate MLE fits above $x_\min$ . Truncated power laws are favored over log-normal and exponential alternatives (Table 2). We move beyond the law itself to further investigate its implications. We show that the observed heavy-tailed structure is consistent with reinforcement in coordination: claims that accumulate early engagement tend to attract disproportionately more downstream activity, and this effect strengthens with system size, analogous to preferential attachment in complex systems Barabási and Albert (1999). This leads to a concentration of cognitive effort in a small subset of agents, forming an emergent tier of intellectual elites whose influence increases with scale. More importantly, the internal composition of large cascades reveals a structural imbalance. As system size increases, cascade generation driven by delegation and contradiction continues to grow, while integration through merge does not scale proportionally. This indicates that although the system becomes increasingly effective at expanding reasoning, it does not become proportionally better at consolidating it. This integration bottleneck provides a mechanistic explanation for the non-monotonic scaling behavior observed in prior work Chen et al. (2024b); Cemri et al. (2025). Larger coordination cascades are not inherently detrimental. On the contrary, they are essential for exploring complex solution spaces through branching reasoning and task decomposition. The problem is misallocation: as scale increases, a growing fraction of large cascades reflects redundant exploration or unresolved conflict rather than productive synthesis. This finding suggests that improving LLM MAS requires not only increasing reasoning capacity, but also regulating coordination structure. To examine this, we introduce Deficit-Triggered Integration (DTI), an intervention that monitors the imbalance between cascade expansion and merge activity within each active cascade and triggers integration when this imbalance exceeds a threshold. DTI still preserves the heavy-tailed regime that supports large-scale reasoning while reducing inefficient late-stage expansion. Across topology-task conditions, DTI consistently improves task success, with the largest gains observed in regimes where the expansion-integration imbalance is most pronounced. These results support the view that coordination failure in LLM MAS is a structural problem and demonstrate that it can be mitigated through targeted regulation of coordination dynamics. More broadly, they point toward a new design paradigm in which scalability depends not only on model capability, but also on how collective reasoning is organized. #### We list our contributions below: - We introduce an event-based formulation of multi-agent reasoning that decomposes coordination into atomic primitives and defines Total Cognitive Effort (TCE) to measure downstream reasoning load. - We examine and validate three consistent observations: (H1) coordination cascades follow truncated power-law distributions, (H2) cognitive effort concentrates in a small subset of agents, and (H3) extreme coordination events scale with system size. - We show that reinforcement amplifies already-engaged reasoning trajectories, leading to intellectual elites, and identify an integration bottleneck where cascade generation outpaces synthesis, explaining non-monotonic scaling behavior. - We propose Deficit-Triggered Integration (DTI), a mechanism derived from observed coordination dynamics that improves performance by regulating the balance between expansion and integration. ## 2 Related Work #### LLM Multi-Agent Systems and Coordination: LLM MAS extend reasoning beyond single-agent limits through structured interaction across role-playing, orchestration, software development, and social simulation Li et al. (2023); Wu et al. (2024); Hong et al. (2023); Qian et al. (2024a); Park et al. (2023). Deliberative mechanisms such as debate improve reasoning quality Du et al. (2024); Liang et al. (2024); Chan et al. (2023); Chen et al. (2024a), while communication topology strongly shapes collective outcomes Qian et al. (2024b); Zhuge et al. (2024); Liu et al. (2023b). Despite this progress, scaling agent count does not reliably improve performance and can degrade due to coordination failures and saturation Chen et al. (2024b); Kim et al. (2025); Cemri et al. (2025); Kapoor et al. (2024). These limitations depend on protocol and scaffold design Nordenlöw and others (2025) and are not fully explained by model capability alone, indicating a lack of principled multi-agent grounding La Malfa et al. (2025). Surveys summarize advances and open challenges Guo et al. (2024); Xi et al. (2025); Wang et al. (2024); Tran et al. (2025). We evaluate on established agentic benchmarks Mialon et al. (2023); Jimenez et al. (2023); Zhu et al. (2025); Geng and Chang (2025) and position our work relative to single-agent reasoning advances Wei et al. (2022); Wang et al. (2022); Yao et al. (2022); Shinn et al. (2023). However, the statistical structure of coordination dynamics and governing organizational laws remains unexplored, which is the focus of this work. #### Collective Intelligence, Inequality, and Elite Formation: Collective intelligence research shows that groups exhibit emergent cognitive properties beyond individuals and can outperform individual judgment under diversity and independence assumptions Woolley et al. (2010); Surowiecki (2005); Malone and Bernstein (2015). In multi-agent reinforcement learning, coordinated behavior emerges from local interactions Leibo et al. (2017); Lowe et al. (2017), with recent work extending this view to LLM agent societies Nisioti et al. (2024). A parallel literature on inequality provides a lens on intellectual elites. The Lorenz curve, Gini coefficient, and Pareto principle characterize skewed contribution as a structural property of productive systems Lorenz (1905); Gini (1921); Pareto (1964), while empirical studies show that a small fraction of participants accounts for disproportionate activity, notably in Wikipedia Halfaker et al. (2013). Influence concentration in networks further supports this pattern Bakshy et al. (2011); Cha et al. (2010); Klemm and Eguiluz (2002); Goh et al. (2001), with broader analyses suggesting such inequality is structurally generated rather than incidental Piketty (2014). However, whether elite formation arises endogenously from coordination cascade dynamics in LLM agent societies, and whether the mechanisms driving heavy-tailed coordination also govern influence concentration, remains unexplored. #### Power Laws, Heavy-Tailed Distributions, and Cascade Dynamics: Heavy-tailed distributions and scale-free organization are canonical signatures of complex systems, arising from mechanisms such as preferential attachment Barabási and Albert (1999), small-world structure Watts and Strogatz (1998), and self-organized criticality Bak et al. (1987). These dynamics produce power-law event distributions observed across citation networks, information cascades Newman (2003); Watts (2002); Leskovec et al. (2007), human activity Barabasi (2005), and social contagion Crane and Sornette (2008). Distinguishing power-law from log-normal behavior, central to our model comparison, has been extensively studied Mitzenmacher (2004); Newman (2005), with rigorous inference requiring careful statistical validation Stumpf and Porter (2012); Goldstein et al. (2004). We adopt the Clauset–Shalizi–Newman framework Clauset et al. (2009) for maximum-likelihood estimation, goodness-of-fit testing, and model comparison, with discrete fitting following Virkar & Clauset Virkar (2012) and likelihood-ratio selection via Vuong’s test Vuong (1989). Extreme-event scaling is grounded in classical extreme value theory Embrechts et al. (2013). While these methods are well established, their application to coordination dynamics in LLM MAS and the resulting implications for collective reasoning remains unexplored. ## 3 Methodology ### 3.1 Experimental Setup and Data Generation We study coordination in LLM MAS using structured workloads derived from four SOTA agent benchmarks: GAIA Mialon et al. (2023), SWE-bench Jimenez et al. (2023), REALM-Bench Geng and Chang (2025), and MultiAgentBench Zhu et al. (2025), spanning QA, reasoning, coding, and planning tasks. Each run consists of $N∈\{8,16,32,64,128,256,512\}$ agents solving interdependent tasks under communication topologies including chain, star, tree, hierarchical, fully connected, sparse mesh, and dynamic reputation. We adopt a standardized execution protocol: all agents share a common LLM, prompt, tools, and task instances, with execution implemented in LangGraph Chase and LangChain Inc. (2024) to enforce topology and routing (Sec. I). To maintain balanced coordination demand as $N$ increases, workloads are scaled using a benchmark-conditioned expansion module that generates task trees with dependency structure but no prescribed coordination, allowing interaction patterns to emerge (Appendix H). Agents execute over the task tree by iteratively selecting, decomposing, and solving tasks while communicating over the active topology. Interaction traces $T$ are recorded at the level of individual reasoning steps, capturing agent actions, coordination lineage, and task dependencies, forming the basis for analysis (Appendix E). Experiments are repeated across five seeds per configuration; full details provided in Appendix Section G. ### 3.2 Event-Based Coordination Formulation To study coordination dynamics in LLM multi-agent systems in a structured manner, we develop an event-based formulation that decomposes coordination into atomic primitives derived from interaction traces. Each trace $T$ consists of timestamped agent actions with associated references and dependencies, capturing how agents produce outputs and relate them to prior reasoning steps. gridgray | headergray Event Type | Schematic | Definition | What It Captures | | --- | --- | --- | --- | | Delegation Cascade | schematicbg | Number of events in the subtask tree rooted at a delegate_subtask event. | Recursive task decomposition and agent recruitment. | | Revision Wave | schematicbg | Length of a chain of revise_claim events linked by parent_claim_id. | Iterative refinement of a claim. | | Contradiction Burst | schematicbg | Number of distinct agents issuing contradict_claim on the same parent claim. | Parallel critique centered on one claim. | | Merge Fan-in | schematicbg | Number of parent_claim_ids referenced by a single merge_claims event. | Information integration bottleneck. | | Total Cognitive Effort (TCE) | schematicbg | Total number of downstream coordination events linked to a root claim. | Aggregate cascade size. | Table 1: Primitive coordination events used in our analysis. An event is a single coordination step in the reasoning process (e.g., delegation, revision, contradiction, or merge). Events are linked through claim and subtask relationships, and each row defines a quantity computed over these events rather than over entire tasks. Legend: Root Claim ​ Propagation Claims Critique Claim Merge Claim. We define a claim as the atomic unit of reasoning produced by an agent at a given step, corresponding to an intermediate output during task execution. Let $C$ denote the set of all claims. Claims are uniquely identified and linked to prior claims through recorded references, inducing a directed acyclic graph (DAG) $G=(C,E_c)$ , where $(c_i,c_j)∈E_c$ if $c_i∈P(c_j)$ . $P(c_j)⊆C$ denotes the set of parent claims referenced by $c_j$ . This graph captures the evolution of reasoning across agents, tasks, and interactions. An event is defined as a coordination step corresponding to a recorded action that transforms or relates one or more claims, identified via the action type and reference structure. Let $E$ denote the set of all events. These events represent atomic coordination primitives, including decomposition, refinement, critique, synthesis, and reuse. Each claim is associated with a root identifier, which defines a cascade as the set of all claims that share the same root. Formally, for a root claim $c_r$ , the corresponding cascade is given by $$ C_r=\{c_i∈C\midroot(c_i)=c_r\}. $$ Let $E_r⊆E$ denote the set of events associated with cascade $C_r$ . Cascades therefore represent connected subgraphs of $G$ corresponding to the propagation of reasoning initiated by a single claim, forming the fundamental units for analyzing coordination dynamics. Detailed notation, definitions of claim types, event categories, and graph construction are provided in Appendix E and B. ### 3.3 Observables We define a set of observables over the claim graph and cascades to quantify coordination dynamics. Let $G=(C,E_c)$ denote the claim graph and $\{C_r\}$ the set of cascades as defined in Sec. 3.2. Observables are computed at the level of individual events, claims, and cascades, enabling analysis of coordination behavior across multiple scales. #### Event size: We first define the size of a coordination event as the number of claims involved in the corresponding transformation. For a given event $e_k$ , we denote its size by $x(e_k)$ , which depends on the event type. We define four event types: delegation, revision, merge fan-in and contradiction, whose definitions are provided in Table 1. These event sizes form the primary units for distributional analysis. #### Cascade size: The size of a cascade at a root claim $c_r$ is defined as the total number of claims associated with a root claim. This is given by: $$ |C_r|=∑_c_{i∈C_r}1 \tag{1} $$ #### Total Cognitive Effort (TCE): Building on this, we define the TCE of a cascade as the total number of coordination events generated within that cascade: $$ TCE(c_r)=∑_e_{k∈E_r}1 \tag{2} $$ where $E_r$ denotes the set of events associated with claims in $C_r$ . TCE captures the total amount of reasoning activity triggered by a single root claim, and serves as a central observable for characterizing coordination complexity. #### Contribution concentration: To analyze contribution concentration, we define agent-level participation within a cascade. Let $n_a(c_r)$ denote the number of claims produced by agent $a$ within cascade $C_r$ . We define the cumulative contribution share of the top- $k$ agents as $$ S_k(c_r)=\frac{∑_a∈Top-kn_a(c_r)}{∑_a∈An_a(c_r)} \tag{3} $$ This measure quantifies the degree to which coordination effort is concentrated among a subset of agents. In subsequent analysis, we instantiate this as $E^active_k$ when the denominator is restricted to active agents only, and $E^all_k$ when computed over all $N$ agents. These are the primary concentration observables reported in figures and tables throughout the paper. #### Contribution concentration: Let $n_a(c_r)$ denote the number of claims produced by agent $a$ in cascade $C_r$ . The top- $k$ contribution share is: $S_k(c_r)=\frac{∑_a∈Top-kn_a(c_r)}{∑_a∈An_a(c_r)}$ . #### Extreme-event scaling: For a given agent population $N$ , we define the maximum cascade size as, $x_\max(N)=\max_c_{r}|C_r|$ . These observables characterize the distributional structure, concentration, and scaling behavior of coordination in LLM multi-agent systems. In subsequent analysis, we report $S_k$ as $E^active_k$ when computed over active agents only, and $E^all_k$ when computed over all $N$ agents. Please see Appendix Sec. B for full lists of notation. ### 3.4 Statistical Methods We analyze the distributional properties of coordination observables using established statistical methods for heavy-tailed data. For each observable (e.g., event size, cascade size, and TCE), we estimate candidate distributions including the power law, truncated power law, log-normal, and exponential. Parameter estimation is performed using maximum likelihood estimation (MLE). For heavy-tailed models, the lower cutoff $x_\min$ is selected by minimizing the Kolmogorov–Smirnov (KS) An (1933); Smirnov (1948) distance between the empirical distribution and the fitted model. All distributions are fit over the tail region $x≥ x_\min$ . To compare competing models, we use likelihood ratio tests following Vuong’s method for non-nested distributions Vuong (1989). For each pair of candidate models, we report the log-likelihood ratio and its statistical significance. Goodness-of-fit is evaluated using the KS statistic, and distributional behavior is visualized using complementary cumulative distribution functions (CCDFs) on log–log axes Newman (2005). This approach avoids biases associated with binning and provides a stable representation of tail behavior. All statistical analyses are implemented using the powerlaw package, following the methodology of Clauset et al. Clauset et al. (2009) and subsequent best practices for heavy-tailed inference. Additional statistical metrics and reliability tests are provided in Sec. D. ## 4 Theory of Reinforced Routing ### 4.1 Overview: Recursive Coordination and Event Propagation Coordination in LLM multi-agent systems unfolds as a recursive process over claims. At each step, agents operate on existing claims to produce new ones through actions such as decomposition, refinement, critique, and synthesis. This creates a dependency structure in which reasoning propagates through a growing network of interrelated claims rather than being generated independently. Once a root claim is introduced, it can trigger a cascade of downstream activity. Delegation expands the reasoning structure, revision refines intermediate outputs, contradiction creates branching alternatives, and merge operations integrate multiple reasoning paths. These interactions give rise to cascades in which claims recursively generate further claims. This process is inherently path-dependent: claims that accumulate more interaction become more likely to be revisited and expanded, while others remain inactive. As a result, coordination concentrates around a subset of evolving reasoning trajectories. Understanding how this concentration emerges motivates a mechanism for how agents select and build upon existing claims. ### 4.2 Reinforced Routing Mechanism We model coordination in LLM multi-agent systems as a routing process over claims. Let $c_i$ denote a claim active at time $t$ , and let $x_i(t)$ denote its accumulated coordination activity, defined as the number of downstream coordination events that reference, revise, contradict, merge from, or delegate from $c_i$ up to time $t$ . This quantity captures the extent to which a claim has been involved in the ongoing reasoning process. Agents repeatedly select existing claims as the basis for further reasoning. This selection is not uniform: claims that have accumulated more activity are more likely to be revisited and expanded, reflecting their prominence in the shared reasoning state and their relevance to task progress. We formalize this behavior through a reinforced routing rule: $$ ℙ(c_i\midF_t)=\frac{x_i(t)^β}{∑_jx_j(t)^β}, \tag{4} $$ where $F_t$ denotes the interaction history and $β>0$ controls the strength of reinforcement. When $β=0$ , routing is uniform over claims; when $β>0$ , already-active claims are preferentially selected, with larger $β$ corresponding to stronger amplification of activity. A direct implication of this mechanism is that the continuation probability of a claim increases with its prior engagement. Let $R(x,N)$ denote the routing ratio for claims with activity $x$ in a system of size $N$ , measured relative to an activity-independent baseline. In the reinforcement regime, $$ R(x,N)∝ x^β(N) \tag{5} $$ where the preferential attachment exponent is defined as $$ β(N)=\frac{d\log R(x,N)}{d\log x}. \tag{6} $$ . In isolation, reinforced routing generates broad, scale-free coordination patterns. However, LLM multi-agent systems are intrinsically bounded by finite agent populations, context limits, communication overhead, and constrained task depth. These constraints suppress unbounded cascade growth and truncate the tail of the induced distribution. We therefore model coordination observables using a truncated power law: $$ P(X=x)∝ x^-αe^-x/x_c \tag{7} $$ where $α$ governs the intermediate scaling regime and $x_c$ denotes the characteristic cutoff imposed by system constraints. ### 4.3 Cascade Growth Model Under reinforced routing, coordination propagates through claim-rooted cascades. Each selected claim can generate new claims via delegation, revision, contradiction, or synthesis, inducing a branching process over the claim graph. Let $λ$ denote the expected number of new claims generated per selected claim. When $λ<1$ , cascades remain small; when $λ>1$ , they grow rapidly; and when $λ≈ 1$ , cascade sizes exhibit high variability across scales. Reinforcement amplifies this process by increasing the likelihood that already-active claims continue to generate further activity. Cascades that gain early momentum are therefore more likely to persist and expand, while others terminate quickly, producing heterogeneous growth across cascades. However, cascade expansion is bounded by finite system constraints, including limited agents, context, communication capacity, and task depth. These constraints cap the effective branching process and prevent unbounded growth. As a result, coordination operates near criticality but remains finite, yielding broad but truncated cascade size distributions. ### 4.4 Theoretical Implications Reinforced routing combined with bounded cascade growth yields characteristic coordination behavior in LLM multi-agent systems. Agents iteratively build on intermediate reasoning outputs within a shared interaction state, concentrating activity on a subset of claims while coordination expands through cascades under finite computational and communication constraints. ➀ Heavy-tailed coordination. Reinforcement amplifies activity along selected reasoning trajectories, producing large variation in event sizes and cascade magnitudes. Under bounded resources such as limited context, token budgets, and coordination overhead, this yields heavy-tailed but truncated distributions, as described by Eq. (7). ➁ Emergence of intellectual elites. Because agents preferentially operate on already-active claims, a subset of reasoning trajectories attracts disproportionate coordination. Agents contributing to these trajectories participate in larger cascades and accumulate greater influence, leading to the emergence of intellectual elites despite symmetric initial capabilities. ➂ Scaling of extremes. As the number of agents increases, the volume of concurrent reasoning interactions grows, increasing the likelihood of large cascades. This results in systematic growth of the largest coordination events with $N$ . ➃ Expansion–integration imbalance. Coordination primitives such as delegation, revision, and critique drive rapid expansion of reasoning branches, while integration through synthesis remains comparatively constrained. As cascades grow, this imbalance produces increasingly complex but weakly integrated reasoning structures. Together, these implications show that heavy-tailed coordination, elite formation, and scaling behavior arise naturally from reinforced and bounded coordination dynamics in LLM multi-agent systems. ## 5 Empirical Laws of Collective Cognition We study coordination in LLM multi-agent systems through three hypotheses on the statistical structure, organization, and scaling of collective reasoning, evaluated across scales, topologies, task domains, and coordination primitives to uncover underlying mechanisms. ❶H1. Coordination in LLM multi-agent systems exhibits heavy-tailed cascade structure under finite system constraints. ❷H2. Collective reasoning self-organizes into unequal contribution regimes, leading to the emergence of intellectual elites. ❸H3. Extreme coordination cascades grow systematically with agent society size. ### 5.1 H1: Heavy-Tailed Coordination Cascades We test whether coordination in LLM MAS organizes through bounded heavy-tailed cascades by analyzing total cognitive effort (TCE) and its constituent coordination primitives across event types, task domains, topologies, and scales. | | Tail statistics | Model comparison | | | | | | | | | | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | Observable | $n_total$ | $x_\min$ | $n_tail$ | $\hat{α}$ | Tail family | $x_\max$ | Distinct | LR (TPL vs LN) | $p$ | LR (TPL vs PL) | $p$ | | Delegation cascade | 342,300 | 5 | 92,400 | 2.28 | Trunc. PL | 118 | 103 | +4.6 | 0.002 | +2.8 | 0.009 | | Revision wave | 344,300 | 4 | 134,300 | 2.41 | Trunc. PL | 74 | 61 | +3.8 | 0.005 | +1.7 | 0.037 | | Contradiction burst | 255,300 | 4 | 56,200 | 2.16 | Trunc. PL | 83 | 73 | +4.2 | 0.004 | +0.9 | 0.020 | | Merge fan-in | 278,500 | 3 | 39,000 | 2.71 | Trunc. PL | 33 | 27 | +3.9 | 0.006 | +3.3 | 0.001 | | Total Cognitive Effort (TCE) | 411,300 | 8 | 123,400 | 2.22 | Trunc. PL | 1320 | 1203 | +5.1 | 0.001 | +2.8 | 0.012 | Table 2: Global tail statistics and model comparisons. Tail behavior is summarized by $\hat{α}$ (MLE above $x_\min$ ) and distinct tail values. Positive likelihood ratios favor TPL over LN and PL. * Lower $p$ indicates stronger support for TPL. Figure 1 and Table 2 establish the primary evidence. CCDFs across all observables exhibit an extended log-log linear region followed by systematic truncation in the far tail. Likelihood-ratio tests favor truncated power-law (TPL) models over both power-law (PL) and log-normal (LN) alternatives ( $p<0.05$ ), with $\hat{α}∈(2,3)$ and finite cutoff $\hat{x}_c$ . This supports Eq. 7, indicating power-law amplification over an intermediate range with a structural cutoff imposed by context limits, token budgets, and coordination overhead. Coordination is therefore inherently uneven: most trajectories remain local, while a small fraction accumulates disproportionately large activity. Figure 2 (left) shows that this behavior persists with scale, with $\hat{α}$ stabilizing by $N≈ 64$ and remaining consistent as $N$ increases. <details> <summary>2604.02674v1/x2.png Details</summary>  ### Visual Description ## Line Graph and Scatter Plot: Agent Scaling Analysis ### Overview The image contains two side-by-side visualizations analyzing the relationship between the number of agents (N) and two metrics: (1) estimated exponent α (MLE) and (2) observed upper-tail extent x_max. The left graph uses line plots with confidence intervals, while the right graph uses scatter points. Both share the same x-axis (N = 8, 16, 32, 64, 128, 256, 512) and use color-coded strategies. --- ### Components/Axes #### Left Graph (Estimated Exponent α) - **X-axis**: Number of agents (N) on a linear scale (8 to 512, doubling intervals). - **Y-axis**: Estimated exponent α (MLE) on a logarithmic scale (2.0 to 3.2). - **Legend**: Located at the bottom, mapping colors to strategies: - Blue: Delegation - Red: Revision - Green: Contradiction - Orange: Merge Fan-In - Purple: Total Effort - **Annotations**: - Vertical dashed line at N=64 labeled "Tail Growth Onset". - Text box: "Sample-Limited Instability" (top-left). - Arrow annotation: "Asymptotic Convergence of α" pointing to N=256–512. #### Right Graph (Observed Upper-Tail Extent x_max) - **X-axis**: Number of agents (N) (same as left graph). - **Y-axis**: Observed upper-tail extent x_max on a logarithmic scale (10¹ to 10³). - **Legend**: Same color coding as left graph. --- ### Detailed Analysis #### Left Graph Trends 1. **Delegation (Blue)**: - Starts at ~2.45 (N=8), dips to ~2.25 (N=512). - Confidence interval widens slightly at N=16. 2. **Revision (Red)**: - Starts at ~2.55 (N=8), stabilizes at ~2.4 (N=512). - Minimal confidence interval variation. 3. **Contradiction (Green)**: - Peaks at ~2.4 (N=16), drops to ~2.2 (N=512). - Confidence interval narrows after N=32. 4. **Merge Fan-In (Orange)**: - Flat line at ~2.7 (N=8–512). - Broad confidence interval (2.6–2.8). 5. **Total Effort (Purple)**: - Starts at ~2.6 (N=8), drops sharply to ~2.2 (N=64), then stabilizes. - Confidence interval narrows after N=32. #### Right Graph Trends 1. **Delegation (Blue)**: - Increases from ~10¹.5 (N=8) to ~10².3 (N=512). 2. **Revision (Red)**: - Rises from ~10¹ (N=8) to ~10².1 (N=512). 3. **Contradiction (Green)**: - Grows from ~10¹ (N=8) to ~10².2 (N=512). 4. **Merge Fan-In (Orange)**: - Steady increase from ~10⁰.8 (N=8) to ~10¹.8 (N=512). 5. **Total Effort (Purple)**: - Exponential growth: ~10¹.2 (N=8) → ~10³ (N=512). --- ### Key Observations 1. **Left Graph**: - All strategies show asymptotic convergence of α after N=64. - Merge Fan-In exhibits the highest and most stable α (~2.7). - Total Effort demonstrates the sharpest decline in α before stabilizing. 2. **Right Graph**: - Total Effort exhibits exponential growth (x_max ~10³ at N=512). - Delegation and Contradiction show similar scaling patterns. - Merge Fan-In has the slowest growth rate. --- ### Interpretation 1. **Agent Scaling Dynamics**: - Strategies with lower α (e.g., Total Effort) correlate with higher x_max growth, suggesting a trade-off between efficiency (α) and system complexity (x_max). - Merge Fan-In’s stable α but moderate x_max growth implies a balanced approach to scalability. 2. **Critical Threshold**: - The "Tail Growth Onset" at N=64 marks a divergence in x_max growth rates, particularly for Total Effort. 3. **Uncertainty**: - Wider confidence intervals in the left graph (e.g., Merge Fan-In) indicate higher variability in α estimates for this strategy. 4. **Practical Implications**: - Delegation and Contradiction may be preferable for systems prioritizing stability (lower α), while Total Effort suits scenarios requiring rapid upper-tail expansion despite higher resource demands. --- ### Data Table Reconstruction (Left Graph Approximate Values) | N | Delegation (α) | Revision (α) | Contradiction (α) | Merge Fan-In (α) | Total Effort (α) | |------|----------------|--------------|-------------------|------------------|------------------| | 8 | 2.45 | 2.55 | 2.35 | 2.7 | 2.6 | | 16 | 2.4 | 2.45 | 2.4 | 2.7 | 2.65 | | 32 | 2.25 | 2.4 | 2.3 | 2.7 | 2.4 | | 64 | 2.25 | 2.4 | 2.2 | 2.7 | 2.2 | | 128 | 2.25 | 2.4 | 2.2 | 2.7 | 2.2 | | 256 | 2.25 | 2.4 | 2.2 | 2.7 | 2.2 | | 512 | 2.25 | 2.4 | 2.2 | 2.7 | 2.2 | ### Data Table Reconstruction (Right Graph Approximate Values) | N | Delegation (x_max) | Revision (x_max) | Contradiction (x_max) | Merge Fan-In (x_max) | Total Effort (x_max) | |------|--------------------|------------------|-----------------------|----------------------|----------------------| | 8 | 10¹.5 | 10¹ | 10¹ | 10⁰.8 | 10¹.2 | | 16 | 10¹.7 | 10¹.2 | 10¹.1 | 10¹ | 10¹.5 | | 32 | 10² | 10¹.5 | 10¹.8 | 10¹.2 | 10¹.8 | | 64 | 10².1 | 10¹.8 | 10² | 10¹.4 | 10².1 | | 128 | 10².3 | 10² | 10².1 | 10¹.6 | 10².5 | | 256 | 10².4 | 10².2 | 10².3 | 10¹.7 | 10³ | | 512 | 10².5 | 10².4 | 10².4 | 10¹.8 | 10³ | </details> Figure 2: Finite-size stability of heavy-tailed coordination dynamics. (Left) Estimated tail exponents $\hat{α}$ (MLE) vs. agent count $N$ . Estimates fluctuate at small $N$ due to limited tail samples, then stabilize and converge beyond $N≈ 64$ , indicating emergence of a consistent heavy-tailed regime. (Right) Mean maximum event size $⟨ x_\max⟩$ vs. $N$ . The upper tail grows systematically across observables, with strongest expansion for TCE, showing that increasing system size expands the reachable coordination tail. The structure of the tail reveals how this heterogeneity is generated. Delegation and contradiction extend deepest (Fig. 1), while merge fan-in is sharply truncated. This follows from their functional roles: delegation and contradiction expand the reasoning space by creating new branches and recursive dependencies, whereas merge is integrative and does not generate new coordination structures. Cascade growth, therefore, proceeds through repeated expansion and branching, rather than through aggregation. | | | Chain | Star | Hierarchical | Mesh | | | | | | | | | | | | | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | Observable | Task | $\hat{α}$ | $\hat{x}_c$ | LR T/LN | LR T/PL | $\hat{α}$ | $\hat{x}_c$ | LR T/LN | LR T/PL | $\hat{α}$ | $\hat{x}_c$ | LR T/LN | LR T/PL | $\hat{α}$ | $\hat{x}_c$ | LR T/LN | LR T/PL | | Delegation | Coding | 2.46 | 22 | $+4.0$ | $+2.5$ | 2.30 | 29 | $+4.3$ | $+2.7$ | 2.36 | 26 | $+4.2$ | $+2.6$ | 2.16 | 37 | $+4.6$ | $+2.8$ | | QA | 2.64 | 15 | $+3.7$ | $+2.3$ | 2.48 | 19 | $+3.9$ | $+2.5$ | 2.54 | 17 | $+3.8$ | $+2.4$ | 2.34 | 24 | $+4.2$ | $+2.6$ | | | Planning | 2.24 | 36 | $+4.5$ | $+2.8$ | 2.08 | 48 | $+4.9$ | $+3.0$ | 2.14 | 43 | $+4.8$ | $+2.9$ | 1.94 | 61 | $+5.3$ | $+3.2$ | | | Reasoning | 2.34 | 29 | $+4.3$ | $+2.7$ | 2.18 | 39 | $+4.7$ | $+2.8$ | 2.24 | 35 | $+4.5$ | $+2.8$ | 2.04 | 49 | $+5.0$ | $+3.0$ | | | Merge Fan-In | Coding | 2.89 | 6 | $+3.3$ | $+3.0$ | 2.73 | 8 | $+3.6$ | $+3.2$ | 2.79 | 7 | $+3.5$ | $+3.1$ | 2.59 | 10 | $+3.9$ | $+3.3$ | | QA | 3.07 | 4 | $+2.9$ | $+2.8$ | 2.91 | 5 | $+3.2$ | $+3.0$ | 2.97 | 5 | $+3.2$ | $+2.9$ | 2.77 | 7 | $+3.5$ | $+3.1$ | | | Planning | 2.67 | 10 | $+3.8$ | $+3.3$ | 2.51 | 13 | $+4.2$ | $+3.5$ | 2.57 | 12 | $+4.0$ | $+3.4$ | 2.37 | 17 | $+4.6$ | $+3.7$ | | | Reasoning | 2.77 | 8 | $+3.6$ | $+3.2$ | 2.61 | 11 | $+4.0$ | $+3.3$ | 2.67 | 10 | $+3.8$ | $+3.3$ | 2.47 | 14 | $+4.3$ | $+3.5$ | | | Revision | Coding | 2.59 | 13 | $+3.2$ | $+1.4$ | 2.43 | 18 | $+3.5$ | $+1.6$ | 2.49 | 16 | $+3.4$ | $+1.5$ | 2.29 | 23 | $+3.8$ | $+1.7$ | | QA | 2.77 | 9 | $+2.9$ | $+1.2$ | 2.61 | 12 | $+3.2$ | $+1.4$ | 2.67 | 11 | $+3.0$ | $+1.3$ | 2.47 | 15 | $+3.4$ | $+1.5$ | | | Planning | 2.37 | 22 | $+3.7$ | $+1.7$ | 2.21 | 30 | $+4.1$ | $+1.9$ | 2.27 | 27 | $+4.0$ | $+1.8$ | 2.07 | 38 | $+4.5$ | $+2.1$ | | | Reasoning | 2.47 | 18 | $+3.5$ | $+1.6$ | 2.31 | 25 | $+3.9$ | $+1.7$ | 2.37 | 22 | $+3.7$ | $+1.7$ | 2.17 | 31 | $+4.2$ | $+1.9$ | | | Contradiction | Coding | 2.34 | 16 | $+3.6$ | $+0.6$ | 2.18 | 21 | $+3.9$ | $+0.8$ | 2.24 | 18 | $+3.8$ | $+0.7$ | 2.04 | 26 | $+4.2$ | $+0.9$ | | QA | 2.52 | 11 | $+3.3$ | $+0.4$ | 2.36 | 14 | $+3.6$ | $+0.6$ | 2.42 | 12 | $+3.4$ | $+0.5$ | 2.22 | 17 | $+3.8$ | $+0.7$ | | | Planning | 2.12 | 26 | $+4.1$ | $+0.9$ | 1.96 | 34 | $+4.5$ | $+1.1$ | 2.02 | 30 | $+4.4$ | $+1.0$ | 1.82 | 43 | $+4.9$ | $+1.3$ | | | Reasoning | 2.22 | 21 | $+3.9$ | $+0.8$ | 2.06 | 28 | $+4.3$ | $+0.9$ | 2.12 | 24 | $+4.1$ | $+0.9$ | 1.92 | 34 | $+4.6$ | $+1.1$ | | Table 3: Tail heterogeneity across task types and communication topologies. For each observable and task–topology condition, we report the fitted truncated power-law exponent $\hat{α}$ , cutoff parameter $\hat{x}_c$ , and log-likelihood ratios LR T/LN and LR T/PL comparing the truncated power law (TPL) against the log-normal (LN) and pure power-law (PL) alternatives, respectively. Lower $\hat{α}$ and larger $\hat{x}_c$ indicate broader, less sharply truncated coordination tails. Planning and reasoning tasks consistently exhibit heavier tails than coding and QA across all topology conditions, and denser topologies (mesh, star) support longer-lived cascades than locally connected structures (chain), with the planning $×$ mesh combination producing the heaviest tails in every observable. This mechanism interacts jointly with task structure and topology. As shown in Fig. 3, tasks with deeper claim dependency graphs (e.g., planning) provide more opportunities for recursive expansion, producing heavier delegation and contradiction tails, while merge remains comparatively insensitive to task depth. Topology determines how far these expansions propagate: denser interaction graphs enable repeated engagement with active trajectories, extending cascades further, whereas sparse structures restrict propagation. The largest cascades arise when these factors align; deep task structure combined with high interaction bandwidth, while as $N$ increases the observable cascade range expands without altering the bounded heavy-tailed form or the TPL preference. <details> <summary>2604.02674v1/x3.png Details</summary>  ### Visual Description ## Line Graphs: Probability Distributions Across Event Sizes and Scenarios ### Overview The image contains 16 line graphs arranged in a 4x4 grid, each representing probability distributions (P(X ≥ x)) across different event sizes (x) and scenarios. Graphs are labeled with scenario names (e.g., "Delegation Cascade," "Total Effort (TCE)"), and each includes four colored lines representing distinct categories: Reasoning (blue), Coding (red), QA (green), and Coordination (purple). All axes use logarithmic scales, and alpha (α) value ranges are provided for each graph. --- ### Components/Axes - **X-axis**: Event size (x), logarithmic scale (10¹ to 10²). - **Y-axis**: Probability (P(X ≥ x)), logarithmic scale (10⁻⁴ to 10⁰). - **Legend**: Located at the top, mapping colors to categories: - Blue: Reasoning - Red: Coding - Green: QA - Purple: Coordination - **Graph Titles**: Scenario names (e.g., "Delegation Cascade," "Revision Wave"). - **Alpha (α) Ranges**: Provided for each graph (e.g., α ∈ [2.35, 2.72] for "Delegation Cascade"). --- ### Detailed Analysis #### Delegation Cascade - **Lines**: All four categories show decreasing trends. - **Reasoning (blue)**: Starts near 10⁻¹ at x=10, drops to ~10⁻³ at x=100. - **Coding (red)**: Similar trend, slightly lower than Reasoning. - **QA (green)**: Slightly higher than Coding, ~10⁻² at x=10. - **Coordination (purple)**: Highest initial value (~10⁻⁰ at x=10), steepest decline. - **α**: [2.35, 2.72] #### Revision Wave - **Lines**: Similar decreasing trends. - **Reasoning (blue)**: ~10⁻¹ at x=10, ~10⁻³ at x=100. - **Coding (red)**: Slightly lower than Reasoning. - **QA (green)**: ~10⁻² at x=10, ~10⁻⁴ at x=100. - **Coordination (purple)**: Highest initial value (~10⁻⁰), gradual decline. - **α**: [2.02, 2.45] #### Contradiction Burst - **Lines**: - **Reasoning (blue)**: ~10⁻¹ at x=10, ~10⁻³ at x=100. - **Coding (red)**: Slightly lower than Reasoning. - **QA (green)**: ~10⁻² at x=10, ~10⁻⁴ at x=100. - **Coordination (purple)**: Highest initial value (~10⁻⁰), steep decline. - **α**: [2.30, 2.70] #### Total Effort (TCE) - **Lines**: Aggregated trends. - **Reasoning (blue)**: ~10⁻¹ at x=10, ~10⁻³ at x=100. - **Coding (red)**: Slightly lower than Reasoning. - **QA (green)**: ~10⁻² at x=10, ~10⁻⁴ at x=100. - **Coordination (purple)**: Highest initial value (~10⁻⁰), gradual decline. - **α**: [2.41, 2.85] #### Star - **Lines**: - **Reasoning (blue)**: ~10⁻¹ at x=10, ~10⁻³ at x=100. - **Coding (red)**: Slightly lower than Reasoning. - **QA (green)**: ~10⁻² at x=10, ~10⁻⁴ at x=100. - **Coordination (purple)**: Highest initial value (~10⁻⁰), steep decline. - **α**: [2.30, 2.65] #### Hierarchical - **Lines**: - **Reasoning (blue)**: ~10⁻¹ at x=10, ~10⁻³ at x=100. - **Coding (red)**: Slightly lower than Reasoning. - **QA (green)**: ~10⁻² at x=10, ~10⁻⁴ at x=100. - **Coordination (purple)**: Highest initial value (~10⁻⁰), gradual decline. - **α**: [2.12, 2.35] #### Dynamic Reputation - **Lines**: - **Reasoning (blue)**: ~10⁻¹ at x=10, ~10⁻³ at x=100. - **Coding (red)**: Slightly lower than Reasoning. - **QA (green)**: ~10⁻² at x=10, ~10⁻⁴ at x=100. - **Coordination (purple)**: Highest initial value (~10⁻⁰), gradual decline. - **α**: [2.10, 2.50] --- ### Key Observations 1. **Universal Decline**: All categories show decreasing probabilities as event size increases, consistent with logarithmic scaling. 2. **Coordination Dominance**: The purple line (Coordination) consistently starts at the highest probability (~10⁰) across most graphs, suggesting it dominates smaller event sizes. 3. **QA Variability**: QA (green) shows the steepest declines in some graphs (e.g., "Revision Wave"), indicating lower resilience at larger event sizes. 4. **Alpha Ranges**: α values vary by scenario, with "Total Effort (TCE)" having the highest upper bound (2.85), implying greater uncertainty or broader applicability. --- ### Interpretation The data suggests that **Coordination** is the most robust category across scenarios, maintaining higher probabilities at smaller event sizes. **QA** and **Coding** exhibit similar trends but with lower initial probabilities, while **Reasoning** bridges the gap. The **Total Effort (TCE)** graph aggregates these categories, highlighting their combined impact. The varying α ranges indicate scenario-specific confidence intervals, with "Total Effort" reflecting the highest uncertainty. This could imply that larger events require more coordinated efforts, while smaller events are dominated by individual category contributions. The logarithmic scales emphasize exponential decay in probabilities, underscoring the importance of early-stage event management. </details> Figure 3: Topology- and task-specific heavy-tailed coordination cascades in multi-agent LLM systems. Complementary cumulative distribution functions (CCDF) of coordination-event sizes $P(X≥ x)$ across four coordination observables: Delegation Cascade, Revision Wave, Contradiction Burst, and Total Coordination Effort (TCE) under four agent interaction topologies (Chain, Star, Hierarchical, and Dynamic Reputation) and four task families (Reasoning, Coding, QA, and Coordination). Each curve represents the empirical distribution of coordination-event sizes for a given task family within a topology. Across all settings, the distributions exhibit broad heavy-tailed behavior with estimated scaling exponents $2<\hat{α}<3$ in the intermediate regime (values shown per panel), consistent with scale-free coordination dynamics. While the precise tail exponent varies modestly across tasks and architectures, the heavy-tailed form persists across all topologies, indicating that complex coordination in LLM multi-agent systems produces heterogeneous cascades spanning multiple scales. Deviations at the largest event sizes reflect finite-size truncation due to system constraints such as limited agent attention, bounded communication bandwidth, and task decomposition depth. Across model families (Table 20), stronger models exhibit lower $\hat{α}$ and larger $\hat{x}_c$ , operating further into the tail, but the TPL form itself is invariant. The task-topology based heterogeneities across different model families show persistent patterns too (Tables 22 and 21). H1 is supported: coordination in LLM multi-agent systems follows a bounded heavy-tailed cascade structure, in which cascade size is governed by the joint interaction of task decomposability, interaction topology, system scale, and coordination primitives. ### 5.2 H2: Emergence of Intellectual Elites We test whether coordination self-organizes into unequal contribution patterns by analyzing how coordination effort distributes across agents and how this distribution evolves with scale, task structure, and topology. Figure 4 provides the primary evidence for concentration. The effort shares of the top- $k$ active agents, $E^active_10$ , $E^active_25$ , and $E^active_50$ , lie well above their egalitarian baselines across all scales, and this gap widens systematically with $N$ : the top-10% excess reaches +24pp at large $N$ . The cumulative concentration curves $S_p$ become increasingly convex, showing that larger societies develop broader and more dominant elite tiers rather than converging toward uniform participation. Elite formation is therefore not a finite-size artifact but a scale-amplified structural property. <details> <summary>2604.02674v1/x4.png Details</summary>  ### Visual Description ## Line Charts: Agent Effort Distribution Across Society Sizes ### Overview Three line charts analyze how effort distribution and inequality evolve in agent societies of varying sizes (N=8 to 512). Chart (a) shows total effort shares, (b) quantifies excess effort by active agents, and (c) visualizes cumulative effort concentration. All charts use logarithmic scaling on the x-axis for society size. ### Components/Axes **Chart (a): Share of Total Effort** - **Y-axis**: Share of total effort (0-60%) - **X-axis**: Agent society size N (log scale: 8, 16, 32, 64, 128, 256, 512) - **Legend**: - Green: E₁₀ (active agents in top 10%) - Red: E₂₅ (active agents in top 25%) - Blue: E₅₀ (active agents in top 50%) - Dashed black: E_all (all agents) **Chart (b): Excess Share of Total Effort** - **Y-axis**: Excess share Δ_k (0-25%) - **X-axis**: Agent society size N (same log scale) - **Legend**: - Green: Δ₁₀ (excess by top 10%) - Red: Δ₂₅ (excess by top 25%) - Blue: Δ₅₀ (excess by top 50%) **Chart (c): Cumulative Share of Total Effort** - **Y-axis**: Cumulative share (0-100%) - **X-axis**: Fraction of agents ranked by influence (0-100%) - **Legend**: - Dashed black: Egalitarian baseline (S_p=p) - Light blue: N=32 - Dark blue: N=128 - Black: N=512 ### Detailed Analysis **Chart (a) Trends** - E₅₀ (blue) consistently holds the highest share, rising from 50% (N=8) to 60% (N=512) - E₂₅ (red) increases from 25% to 45%, while E₁₀ (green) grows from 15% to 30% - E_all (dashed) remains flat at ~15%, indicating diminishing per-agent contribution in larger societies **Chart (b) Trends** - Δ₁₀ (green) shows steepest growth: 4% (N=8) → 24% (N=512) - Δ₂₅ (red) increases from 5% to 21%, Δ₅₀ (blue) from 1% to 13% - All excess shares correlate with society size, with top 10% agents driving disproportionate effort **Chart (c) Trends** - All N sizes show concave curves, but slope steepness increases with N - N=512 reaches 98% cumulative share at 40% of agents (most influential), while N=32 requires 80% of agents for same share - Egalitarian line (dashed) is consistently below real data, highlighting systemic inequality ### Key Observations 1. **Effort Concentration**: Larger societies (N=512) show 3x higher effort share for top 10% agents vs. N=8 2. **Excess Contribution**: Top 10% agents contribute 24% excess effort in N=512 societies (Δ₁₀) 3. **Inequality Magnification**: Cumulative effort curves become steeper with N, deviating further from egalitarian baselines ### Interpretation The data reveals emergent hierarchical structures in agent societies: 1. **Scaling Dynamics**: As society size grows, effort becomes concentrated in smaller fractions of agents (top 10% in N=512 vs. top 50% in N=8) 2. **Inequality Mechanisms**: The widening gap between E_all (flat line) and active agent shares (E₁₀/E₂₅/E₅₀) suggests diminishing returns for peripheral agents 3. **Power Law Emergence**: Chart (c)'s concave curves mirror real-world power-law distributions, where a small elite controls disproportionate resources 4. **Egalitarian Benchmark**: The persistent deviation from S_p=p indicates inherent systemic biases toward inequality, even in simplified agent models These patterns align with observed social dynamics in human organizations and animal colonies, where leadership roles and effort concentration scale with group size. The model suggests that decentralized coordination mechanisms may struggle to maintain equitable participation in larger populations. </details> Figure 4: Scale-dependent emergence of broad elite tiers. (a) (a) Top- $k$ active agents ( $E^active_10$ , $E^active_25$ , $E^active_50$ ) capture disproportionate shares of coordination effort relative to egalitarian baselines; $E^all_10$ (dashed) confirms the result is not driven by inactive agents. of coordination effort relative to egalitarian baselines. (b) Excess concentration $Δ^active_k$ above equal participation increases with $N$ , with strongest gains in the top decile and quartile. (c) Cumulative concentration curves vs $N$ increasingly bow above the equality line, indicating broader and more dominant elite tiers at scale. The mechanism underlying this concentration is preferential attachment in claim selection, evidenced directly in Figure 5. This is consistent with the reinforced routing model in Eq. (4) and the attachment-slope definition in Eq. (6). The routing ratio $R(x,N)$ rises above the null baseline once a claim accumulates prior engagement and strengthens with $N$ , implying $\hat{β}>0$ . This induces a self-reinforcing dynamic: early-selected claims attract further delegation and contradiction, generating recursive revision loops in which agents repeatedly return to the same active trajectories. Figure 5 (c) shows that delegation and contradiction occupy the high-amplification, high-continuation region of this attachment landscape, while merge fan-in remains local and weakly reinforced. Agents whose claims enter these high- $\hat{β}$ loops early remain central over time, giving rise to elite agents. Across conditions, $\hat{β}$ predicts $S_10$ with $r=0.97$ , linking local reinforcement directly to global concentration. <details> <summary>2604.02674v1/x5.png Details</summary>  ### Visual Description ## Multi-Panel Figure: Societal Amplification of Claims and Reinforcement Dynamics ### Overview The image presents a multi-panel technical analysis of how societal size, topology, and task type influence claim engagement, reinforcement strength, and elite concentration. Key components include: 1. A main chart showing routing ratio vs. claim engagement across society sizes 2. Subfigures analyzing task-topology reinforcement, event heterogeneity effects, and elite concentration predictions 3. Scatter plots with cluster annotations and statistical metrics ### Components/Axes **Main Chart (a):** - **Title:** "Larger Societies Amplify Already-Engaged Claims More Strongly" - **X-axis:** "Claim engagement (prior events)" (log scale: 8 → 10²) - **Y-axis:** "Routing ratio R(x,N)" (linear scale: 1.00 → 1.14) - **Legend:** - Solid lines: Society sizes N=8 (light blue) to N=512 (dark blue) - Dashed line: Null (R=1) - Shaded envelope: 20-80th percentile variability - **Inset:** "Estimated Slope β(N)" (log-log plot: N=8 → 512) **Subfigure (b):** - **Title:** "Topology-Task Type Influence Reinforcement Strength" - **X-axis:** Task types (Planning, Reasoning, Coding, QA) - **Y-axis:** "Slope β̂" (0.00 → 0.40) - **Panels:** - Topologies: Star, Hierarchical, Fully Connected, Sparse Mesh, Chain, Hybrid Modular - Color coding: Red (Planning), Yellow (Reasoning), Green (Coding), Purple (QA) **Subfigure (c):** - **Title:** "Event Heterogeneity Shapes Cascade Sustainability" - **X-axis:** "Event-Specific Attachment Slope β_e" (0.00 → 0.32) - **Y-axis:** "Continuation Probability P_cont" (0.00 → 0.80) - **Clusters:** - "Stable But Local" (bottom-left) - "Elite-Forming Engines" (top-right) - "Weak Amplifiers" (bottom-center) - "Attention Traps" (middle-left) **Subfigure (d):** - **Title:** "Stronger Local Reinforcement Predicts Stronger Elite Concentration" - **X-axis:** "Condition-Level Attachment Slope β" (0.00 → 0.32) - **Y-axis:** "Top-10% Effort Share E_top10%" (10 → 40) - **Legend:** - Topologies: Star (orange), Hierarchical (blue), Fully Connected (brown), Sparse Mesh (gray), Chain (purple), Hybrid Modular (green) - Tasks: Planning (circle), Reasoning (square), Coding (triangle), QA (diamond) - **Metrics:** R=0.97, R²=0.94, n=168 conditions ### Detailed Analysis **Main Chart (a):** - Routing ratio increases with claim engagement (R²=0.94) - Larger societies (N≥128) show steeper slopes (β(N) inset: 0.12 → 0.32) - 20-80th percentile envelope narrows at low engagement (<10 events) - Null line (R=1) intersects all N=8 data points **Subfigure (b):** - Planning shows highest β̂ in Star (0.33) and Fully Connected (0.33) - QA has lowest β̂ in Chain (0.08) and Hybrid Modular (0.09) - Hierarchical topology shows consistent β̂ across tasks (0.15-0.22) **Subfigure (c):** - "Elite-Forming Engines" cluster: β_e=0.22, P_cont=0.75 - "Attention Traps" cluster: β_e=0.10, P_cont=0.30 - "Weak Amplifiers" cluster: β_e=0.05, P_cont=0.20 **Subfigure (d):** - Strong positive correlation (R²=0.94) between β and E_top10% - Star topology shows highest effort share (38%) at β=0.25 - Hybrid Modular shows lowest effort share (22%) at β=0.15 ### Key Observations 1. **Societal Amplification:** Claims with >100 prior engagements show 30-40% higher routing ratios in N=512 vs N=8 2. **Task-Specific Reinforcement:** Planning tasks demonstrate 2-3x stronger reinforcement than QA in most topologies 3. **Elite Concentration:** Condition-level attachment slope explains 94% of variance in top-10% effort share 4. **Cluster Dynamics:** "Elite-Forming Engines" occupy the upper-right quadrant (β_e>0.15, P_cont>0.60) ### Interpretation The data demonstrates that: 1. **Societal Size Matters:** Larger societies disproportionately amplify already-popular claims, creating feedback loops (chart a) 2. **Topology Shapes Outcomes:** Star and Fully Connected topologies enable stronger reinforcement for Planning tasks, while Chain/Hybrid Modular limit this effect (subfigure b) 3. **Heterogeneity Drives Sustainability:** Events with moderate attachment slopes (β_e=0.10-0.20) show highest continuation probabilities, suggesting optimal balance between novelty and familiarity (subfigure c) 4. **Elite Formation Mechanisms:** Stronger local reinforcement (higher β) directly correlates with concentrated effort among top agents, indicating self-reinforcing elite formation (subfigure d) The findings suggest that claim dynamics are shaped by both network structure and task characteristics, with societal size acting as an amplifier for pre-existing engagement patterns. </details> Figure 5: Preferential attachment is a core micro-mechanism behind heavy-tailed coordination and elite concentration in LLM agent societies. (a) The routing ratio $R(x,N)$ rises above the null baseline once a claim accumulates prior engagement, and the effect strengthens with system size $N$ , revealing scale-dependent preferential amplification before saturating in the tail. (b) Estimated attachment slopes $\hat{β}$ vary systematically across topology and task type, with stronger reinforcement in star, fully connected, and modular societies than in tree or chain settings. (c) Event types differ in cascade-sustaining power: delegation and contradiction occupy the high-amplification, high-continuation region, while revision is intermediate and merge fan-in remains comparatively local. (d) Conditions with larger condition-level attachment slope $\hat{β}$ also exhibit larger top-10% effort share $E^active_10$ , linking local reinforcement directly to macro-level elite concentration. Figure 11 provides the structural explanation for why this concentration intensifies with scale. As cascade size and $N$ increase, the merge conversion ratio degrades jointly, from 0.21 at small $N$ and short cascades to 0.07 at $N=512$ in the top-1% tail. Large cascades are therefore increasingly expansion-heavy and merge-poor: delegation and contradiction compound through recursive revision while integration lags. This integration bottleneck concentrates unresolved coordination onto a shrinking subset of highly engaged agents and their recursive claim loops, amplifying elite dominance as systems scale. Figure 6 shows the consequence of this structure. Task success peaks at moderate coordination intensity and degrades sharply in the high-intensity tail, where 68% of runs fail. Failed high-intensity runs exhibit elevated contradiction shares and reduced merge shares relative to successful ones, indicating that elite-dominated, expansion-heavy coordination leads to accumulation without effective consolidation. Across model families (Table 20), $\hat{β}$ strongly predicts $E^active_10$ ( $r=0.97$ ) <details> <summary>2604.02674v1/x6.png Details</summary>  ### Visual Description ## Line Chart: Task Success Trends Across Coordination Regimes ### Overview A line chart showing mean task success across five coordination regimes (Delegation, Contradiction, Revision, Merge, Contradiction Burst) plotted against task-level coordination intensity (Very low to High). Includes error bars, shaded regions, and annotations. ### Components/Axes - **X-axis**: Task-Level Coordination Intensity (categories: Very low, Low-mid, Mid, Mid-high, High) - **Y-axis**: Mean Task Success (0.3 to 0.55) - **Legend**: - Delegation (solid blue) - Contradiction (solid green) - Revision (solid red) - Merge (solid orange) - Contradiction Burst (dashed green) - Merge Conversion (solid orange, separate trend) - **Annotations**: - "Plateau → Decline" (dashed arrow) - "Conflict Region" (vertical pink band) ### Detailed Analysis 1. **Delegation (blue)**: - Starts at ~0.34 (Very low), peaks at ~0.48 (Mid), declines to ~0.43 (High). - Error bars: ±0.02–0.03. 2. **Contradiction (green)**: - Flat at ~0.38 (Very low), rises to ~0.47 (Mid-high), then drops to ~0.42 (High). 3. **Revision (red)**: - Not explicitly plotted; legend may indicate missing data or unshown series. 4. **Merge (orange)**: - Declines from ~0.38 (Very low) to ~0.30 (High). 5. **Contradiction Burst (dashed green)**: - Starts at ~0.35 (Very low), rises sharply to ~0.55 (High). 6. **Merge Conversion (orange)**: - Parallel to Merge but steeper decline (from ~0.38 to ~0.28). ### Key Observations - **Peak Success**: Delegation and Contradiction Burst show highest success at Mid intensity. - **Decline**: All regimes except Contradiction Burst decline at High intensity. - **Conflict Region**: Vertical pink band (Mid-high to High) correlates with declining success. - **Error Bars**: Largest uncertainty in Delegation (Mid) and Contradiction Burst (High). ### Interpretation - **Coordination Intensity Impact**: Success peaks at Mid intensity for most regimes, suggesting optimal coordination at moderate levels. - **Contradiction Burst**: Emerges as a high-performing regime at High intensity, possibly indicating adaptive conflict resolution. - **Merge Conversion**: Steeper decline than Merge suggests compounding inefficiencies at high intensity. - **Uncertainty**: Error bars highlight variability, especially in Delegation and Contradiction Burst trends. ## Bar Chart: High-Intensity Outcome Skew ### Overview A bar chart comparing success (32%) and failure (68%) rates at High coordination intensity. ### Components/Axes - **X-axis**: Outcome categories (Success, Failure) - **Y-axis**: Proportion (0–0.7) - **Bars**: - Success (blue, 32%) - Failure (red, 68%) ### Key Observations - **Skew Toward Failure**: 68% failure rate at High intensity indicates significant challenges in high-coordination tasks. ## Stacked Bar Chart: Elite Share Composition By Outcome ### Overview A stacked bar chart showing elite share composition for successful vs. unsuccessful High-Intensity tasks. ### Components/Axes - **X-axis**: Outcome categories (Successful High-Intensity, Unsuccessful High-Intensity) - **Y-axis**: Proportion (0–100%) - **Stacked Segments**: - **Successful**: - Delegation (40%) - Contradiction (35%) - Revision (15%) - Merge (11%) - Contradiction Burst (9%) - **Unsuccessful**: - Delegation (45%) - Contradiction (40%) - Revision (7%) - Merge (7%) - Contradiction Burst (1%) ### Key Observations - **Successful Outcomes**: Dominated by Delegation and Contradiction. - **Unsuccessful Outcomes**: Higher Delegation and Contradiction shares, but lower overall elite contributions (e.g., Contradiction Burst negligible). ### Interpretation - **Elite Contribution**: Successful tasks rely more on Contradiction Burst (9% vs. 1%), suggesting its role in resolving conflicts. - **Failure Drivers**: High Delegation/Contradiction shares in failures may indicate over-reliance on these regimes without adaptive strategies. ## Cross-Regime Analysis 1. **Contradiction Burst**: - Emerges as a critical regime for High-intensity success, contrasting with its minimal role in failures. 2. **Delegation**: - Consistently high in both success and failure, but peaks at Mid intensity. 3. **Merge vs. Merge Conversion**: - Merge Conversion’s steeper decline suggests it is less robust than Merge at high intensity. ## Final Notes - **Language**: All text is in English. - **Missing Data**: Revision regime lacks plotted data despite being in the legend. - **Design Choices**: Shaded regions and annotations emphasize critical intensity thresholds. </details> Figure 6: Conflict-integration dynamics and performance degradation in the high-intensity regime. (a) Mean task success across coordination intensity regimes reveals a non-monotonic signature: performance plateaus at moderate intensity before undergoing significant degradation in the high-intensity tail. This decline is strongly correlated with an elevated contradiction burden and a concomitant collapse in merge conversion efficiency. The vertical dashed line demarcates the transition from productive coordination to the conflict-dominated regime. (b1) Outcome distribution among high-intensity tasks, illustrating a distinct skew toward failure as coordination complexity increases. (b2) Decomposition of elite contribution shares in high-intensity regimes. Successful runs maintain higher integration capacity, whereas unsuccessful runs are characterized by an increased share of contradictory interactions and diminished merge contributions, suggesting that systemic failure is driven by an inability to resolve dense coordination conflicts. $M$ denotes the merge-event share of total elite coordination effort. H2 is supported: intellectual elites emerge endogenously through preferential attachment and recursive revision loops, and their dominance is sustained by an integration bottleneck that intensifies with scale and directly shapes coordination outcomes in large LLM multi-agent systems. ### 5.3 H3: Expansion of Extreme Coordination Cascades We test whether the magnitude of extreme coordination cascades grows systematically with agent society size by analyzing how $⟨ x_\max⟩$ scales with $N$ across coordination primitives. <details> <summary>2604.02674v1/x7.png Details</summary>  ### Visual Description ## Line Chart: Average Maximum Event Size vs. Number of Agents ### Overview The chart illustrates the relationship between the number of agents (N) and the average maximum event size ⟨x_max⟩ for five distinct strategies: Delegation, Revision, Contradiction, Merge Fan-In, and Total Effort. Each strategy is represented by a distinct line with markers, and a 95% confidence interval is shaded around the Total Effort line. The x-axis ranges from 8 to 512 agents, while the y-axis spans 0 to 500. ### Components/Axes - **X-axis**: "Number of Agents (N)" with values: 8, 16, 32, 64, 128, 256, 512. - **Y-axis**: "Average Maximum Event size ⟨x_max⟩" with values from 0 to 500. - **Legend**: Located on the right, with five strategies: - **Delegation** (blue, circles, γ̂=0.60, γ_th=0.78) - **Revision** (red, squares, γ̂=0.54, γ_th=0.71) - **Contradiction** (green, triangles, γ̂=0.60, γ_th=0.86) - **Merge Fan-In** (orange, diamonds, γ̂=0.42, γ_th=0.58) - **Total Effort** (purple, pentagons, γ̂=0.85, γ_th=0.82) - **Confidence Interval**: Shaded gray band around the Total Effort line. ### Detailed Analysis - **Total Effort (Purple Line)**: - Starts at ~15 ⟨x_max⟩ for N=8 and rises to ~500 ⟨x_max⟩ at N=512. - Slope is steep and linear, with a 95% confidence interval (gray band) that widens slightly as N increases. - At N=64, ⟨x_max⟩ ≈ 90; at N=256, ~250; at N=512, ~500. - **Contradiction (Green Line)**: - Begins at ~5 ⟨x_max⟩ for N=8, reaching ~80 ⟨x_max⟩ at N=512. - Slope is moderate, with a slight upward curve. - **Revision (Red Line)**: - Starts at ~8 ⟨x_max⟩ for N=8, reaching ~75 ⟨x_max⟩ at N=512. - Slope is slightly steeper than Contradiction but less than Total Effort. - **Delegation (Blue Line)**: - Begins at ~10 ⟨x_max⟩ for N=8, reaching ~110 ⟨x_max⟩ at N=512. - Slope is linear but less steep than Total Effort. - **Merge Fan-In (Orange Line)**: - Starts at ~6 ⟨x_max⟩ for N=8, reaching ~35 ⟨x_max⟩ at N=512. - Slope is the shallowest, with minimal growth. ### Key Observations 1. **Total Effort** consistently outperforms all other strategies, with the highest ⟨x_max⟩ across all N values. 2. **Contradiction** and **Revision** show similar performance, with Contradiction slightly ahead at higher N. 3. **Delegation** and **Merge Fan-In** lag behind, with Delegation performing better than Merge Fan-In. 4. The **95% confidence interval** for Total Effort is widest at N=512, indicating increased uncertainty at larger scales. ### Interpretation The data suggests that **Total Effort** is the most effective strategy for maximizing event size as the number of agents grows. Its steep slope and high ⟨x_max⟩ values imply a strong scaling relationship. In contrast, **Merge Fan-In** is the least effective, with minimal growth. The confidence interval for Total Effort highlights variability in its performance, possibly due to the complexity of the strategy or external factors. The parameters (γ̂ and γ_th) in the legend may reflect strategy-specific thresholds, with higher γ̂ values (e.g., Total Effort’s γ̂=0.85) correlating with better performance. This chart underscores the importance of strategy selection in agent-based systems, where Total Effort’s scalability could be critical for large-scale applications. </details> Figure 7: Extreme-value scaling of coordination cascades. Mean maximum event size $⟨ x_\max⟩$ vs. agent count $N$ (log–log). Solid curves show empirical values with 95% CIs; dashed lines denote power-law fits ( $\hat{γ}$ ). All observables scale with $N$ , with TCE showing the strongest growth and closest alignment to EVT predictions ( $\hat{γ}_TCE≈ 0.85$ vs. $γ_th≈ 0.82$ ), indicating systematic expansion of the coordination tail. Figure 7 provides the primary evidence. $⟨ x_\max⟩$ increases systematically with $N$ across all observables on log-log axes, with TCE exhibiting the strongest growth ( $\hat{γ}≈ 0.85$ ) and merge fan-in the weakest ( $\hat{γ}≈ 0.42$ ). Larger LLM agent societies, therefore, do not merely produce more coordination; they produce qualitatively larger cascades, with the reachable coordination tail expanding by nearly two orders of magnitude from $N=8$ to $N=512$ for TCE. This scaling is anchored by Extreme-Value Theory (EVT) Embrechts et al. (2013); De Haan and Ferreira (2006). Under the truncated power-law form established in H1, the expected maximum scales as $⟨ x_\max⟩∝ N^γ$ with $γ_th=1/(\hat{α}-1)$ . The observed TCE exponent $\hat{γ}≈ 0.85$ closely matches the theoretical prediction $γ_th≈ 0.82$ , showing that extreme cascade growth follows directly from the heavy-tailed coordination structure. Other observables fall below their EVT predictions, consistent with finite system constraints suppressing the growth of individual primitives, while TCE, aggregating across all primitives, tracks the theoretical bound most closely. The divergence in $\hat{γ}$ across primitives reflects differences in how coordination processes scale. Delegation and contradiction exhibit stronger scaling because additional agents introduce more opportunities for branching and claim contestation, which compound through preferential attachment and recursive revision loops as $N$ increases. In contrast, merge is integrative and non-generative, lacking a comparable compounding mechanism; its growth is limited to consolidating existing branches rather than creating new ones. As a result, the system becomes increasingly capable of reaching extreme coordination through expansion, while integrative processes scale more slowly, widening the gap between generative and integrative primitives and concentrating extreme cascade mass in the former. Across model families (Table 20), stronger models reach larger $x_\max$ (e.g., GPT-4o-mini at 1320 versus Qwen 2.5 7B at 440), but the scaling structure itself remains invariant. H3 is supported: extreme coordination cascades expand systematically with society size, governed by the heavy-tailed cascade structure of H1 and shaped by the expansion-integration asymmetry of H2. H1-H3 reveal a coherent pattern; Coordination in LLM MAS is skewed toward expansion over consolidation, linking scaling failures Cemri et al. (2025) to a measurable mechanism and motivating regulation of the expansion-integration balance. We examine this next. ## 6 Law-Aware Intervention: Deficit-Triggered Integration (DTI) To directly test whether regulating the expansion–integration balance improves coordination outcomes, we introduce Deficit-Triggered Integration (DTI), a targeted intervention that modifies coordination routing under sustained imbalance. DTI operates at the cascade level by monitoring expansion–integration balance (Appendix C); when the integration deficit $Δ_r$ exceeds a condition-specific threshold $δ_c$ , it temporarily prioritizes integration (Fig. 8). Expansion actions are deferred and agents are routed to merge existing branches, increasing merge fan-in and enforcing consolidation. The intervention is local and state-dependent, activated only under imbalance, and does not alter agent capabilities or impose global constraints. <details> <summary>2604.02674v1/x8.png Details</summary>  ### Visual Description ## Flowchart: Process Stages in a Technical System ### Overview The image depicts a four-stage process flow diagram titled **"[Expansion] → [Deficit] → [Integration] → [Continuation]"**, illustrating a hierarchical decision-making or system monitoring workflow. Each stage contains a labeled diagram with nodes, arrows, and textual annotations. The flow progresses linearly from left to right, with each stage feeding into the next. --- ### Components/Axes #### Stage 1: Branch Proliferation - **Title**: "1. Branch Proliferation" (blue box) - **Diagram**: - A central node labeled **"Cascade r"** branches into three sub-nodes: - **Revision** (left) - **Contradiction** (center) - **Delegation** (right) - Sub-nodes further branch into smaller nodes. - **Text**: - "Exploration Dominates; Merge Lags" (bottom) - Arrows labeled **"Revision"**, **"Contradiction"**, and **"Delegation"** connect nodes. #### Stage 2: DTI Monitors Imbalance - **Title**: "2. DTI Monitors Imbalance" (red box) - **Diagram**: - A central node labeled **"Cascade r"** branches into three sub-nodes: - **Active Branch Heads** (highlighted in red) - Two gray nodes (inactive branches) - Arrows labeled **"Cascade Local Deficit"** point to sub-nodes. - **Text**: - "Cascade Local Deficit: Δ_r(t_r) = P_r(t_r) – M_r" (center) - "Expansion Outpaces Integration" (bottom) #### Stage 3: Integration Trigger - **Title**: "3. Integration Trigger" (black box) - **Diagram**: - A funnel-like structure labeled **"Consolidate Active Positions"**. - Three colored nodes (red, orange, gray) feed into the funnel. - A red box highlights **"Δ_r(t_r) > δ_c"** (threshold condition). - **Text**: - "Active Branch Heads" (top) - "Consolidate Active Positions" (bottom) #### Stage 4: Consolidated Continuation - **Title**: "4. Consolidated Continuation" (green box) - **Diagram**: - A merged node labeled **"Merged Claim"**. - Two gray sub-nodes branch from the merged node. - **Text**: - "Restart Cascade" (bottom) --- ### Detailed Analysis #### Stage 1: Branch Proliferation - **Nodes**: Hierarchical expansion from a single root ("Cascade r") into three primary branches (Revision, Contradiction, Delegation), each further subdivided. - **Key Text**: "Exploration Dominates; Merge Lags" suggests prioritization of exploration over integration at this stage. #### Stage 2: DTI Monitors Imbalance - **Nodes**: Central node ("Cascade r") with active (red) and inactive (gray) branches. - **Key Text**: - "Cascade Local Deficit" formula: Δ_r(t_r) = P_r(t_r) – M_r (likely measures discrepancy between production and monitoring). - "Expansion Outpaces Integration" implies imbalance between growth and consolidation. #### Stage 3: Integration Trigger - **Nodes**: Funnel structure consolidating active branches (red/orange nodes) into a single output. - **Key Text**: - Threshold condition: Δ_r(t_r) > δ_c (triggers integration when deficit exceeds a critical value δ_c). #### Stage 4: Consolidated Continuation - **Nodes**: Single merged node ("Merged Claim") with two sub-nodes, indicating streamlined output. - **Key Text**: "Restart Cascade" implies cyclical re-initiation of the process. --- ### Key Observations 1. **Sequential Flow**: The process cycles through Expansion → Deficit → Integration → Continuation, with each stage dependent on the prior. 2. **Color Coding**: - Red nodes in Stage 2 highlight active branches. - Gray nodes represent inactive or merged branches. 3. **Threshold Logic**: Integration is triggered only when the deficit (Δ_r) exceeds a critical value (δ_c). 4. **Cyclical Nature**: The final stage ("Restart Cascade") suggests the process repeats iteratively. --- ### Interpretation This flowchart models a **feedback-driven system** where: 1. **Expansion** prioritizes exploration (e.g., generating hypotheses or data branches). 2. **Deficit Monitoring** identifies imbalances between exploration and integration (via Δ_r). 3. **Integration** consolidates active components only when deficits surpass a threshold, preventing premature merging. 4. **Continuation** restarts the cycle, enabling adaptive refinement. The system likely applies to **machine learning**, **scientific research**, or **decision-making frameworks**, where balancing exploration and exploitation is critical. The use of "Cascade" terminology suggests hierarchical or tree-like structures (e.g., neural networks, knowledge graphs). The threshold δ_c acts as a safeguard against premature integration, ensuring robustness. </details> Figure 8: Deficit-Triggered Integration (DTI) in coordination cascades. A cascade initially expands through parallel revision, contradiction, and delegation branches, leading to increasing fragmentation (left). DTI monitors this imbalance and triggers integration when it exceeds a threshold, consolidating active branch heads into a unified representation (middle). The cascade then resumes from this integrated state, enabling continued exploration with improved coherence and reduced fragmentation (right). Figure 9 shows that this reallocation produces measurable structural changes. The merge conversion ratio (merge events as a fraction of total expansion events per cascade) increases in high-intensity cascades, reversing the degradation observed in Fig. 11, while contradiction density decreases, indicating improved consolidation of expansion-heavy trajectories. The heavy-tailed distribution of cascade sizes is preserved, showing that large-scale reasoning remains intact while its composition changes. <details> <summary>2604.02674v1/x9.png Details</summary>  ### Visual Description ## Line Charts: Multi-Variable Analysis of Event Distributions and Elite Concentration ### Overview Three comparative line charts analyze different aspects of event distributions and elite concentration across agent-based systems. Panel (a) examines tail behavior, panel (b) shows extreme-value scaling, and panel (c) tracks elite concentration dynamics. All charts use logarithmic scales for quantitative precision. ### Components/Axes **Panel (a): Tail Behavior (TCE)** - X-axis: Event size (x) [log scale, 10¹ to 10³] - Y-axis: P(X ≥ x) [log scale, 10⁻⁴ to 10⁰] - Legend: - Pure PL (α=2.22) - dashed gray - Baseline - solid blue - DTI - solid green - Fixed-interval - dashed red - Excess tail mass - shaded blue - Spatial grounding: Legend positioned right, χ_c markers (48/57) annotated near curves **Panel (b): Extreme-value scaling** - X-axis: Number of agents (N) [log scale, 8 to 512] - Y-axis: Avg. max event size (X_max) [log scale, 10¹ to 10³] - Legend: - Baseline - blue circles - DTI - green circles - Spatial grounding: Legend right, crossover marker at N=32 **Panel (c): Elite concentration** - X-axis: Number of agents (N) [log scale, 8 to 512] - Y-axis: Top-10% share of TCE [linear scale, 0.1 to 0.35] - Legend: - Baseline - blue squares - DTI - green squares - Excess - shaded blue - Egalitarian (10%) - dashed gray - Spatial grounding: Legend right, excess annotations (+0.17/+0.21) near curves ### Detailed Analysis **Panel (a) Trends:** - Pure PL (dashed gray) shows steepest decay, with χ_c=57 - DTI (solid green) demonstrates faster tail decay (χ_c=48) - Baseline (solid blue) has α=2.22 vs DTI's α=2.21 - Fixed-interval (dashed red) intersects DTI at ~x=10² - Excess tail mass (shaded blue) spans x=10¹ to 10² **Panel (b) Trends:** - Both models show logarithmic growth in X_max with N - Baseline (blue) consistently outperforms DTI (green) - DTI crosses below Baseline at N=32 (24% excess) - γ values: Baseline=0.82 vs DTI=0.83 **Panel (c) Trends:** - Both models show linear increase in elite concentration - Baseline reaches 0.32 at N=512 (24% excess) - DTI reaches 0.27 at N=512 (17% excess) - Egalitarian line (10%) remains constant ### Key Observations 1. DTI demonstrates superior tail behavior (lower χ_c) but lags in extreme-value scaling after N=32 2. Baseline maintains higher elite concentration growth (+24% vs +17%) 3. Fixed-interval model shows critical intersection with DTI at mid-scale events 4. Excess tail mass dominates lower event sizes (<100) 5. Elite concentration grows logarithmically with agent count in both models ### Interpretation The data suggests: - DTI optimizes tail event management but becomes less effective at extreme scales - Baseline model exhibits stronger scaling properties but accumulates more elite concentration - Fixed-interval model's performance is context-dependent, excelling at mid-scale events - The 24% excess in Baseline's max event size at N=32 indicates critical threshold behavior - Elite concentration growth patterns suggest different resource distribution mechanisms between models The charts collectively demonstrate trade-offs between tail risk management and scaling efficiency, with DTI prioritizing tail behavior at the cost of extreme-scale performance, while Baseline maintains better scalability at the expense of tail risk mitigation. </details> Figure 9: Impact of Deficit-Triggered Integration (DTI) on collective cognition dynamics. (a) DTI preserves the heavy-tailed structure of coordination cascades while shifting truncation earlier, reducing excess tail mass without altering the intermediate scaling regime. Fixed-interval intervention, in contrast, introduces premature truncation and distorts the tail. (b) The growth of extreme coordination events with system size is preserved under DTI, but large cascades are systematically attenuated, leading to more controlled scaling behavior. (c) DTI reduces the concentration of cognitive effort among top agents, moderating elite dominance while maintaining a non-uniform and productive coordination structure. DTI converts late-stage expansion into earlier integration, yielding more stable and balanced collective reasoning without disrupting the underlying heavy-tailed organization of agent coordination. <details> <summary>2604.02674v1/x10.png Details</summary>  ### Visual Description ## Heatmap: DTI gain: Δ task success over baseline (%) ### Overview The heatmap visualizes the percentage improvement in task success rates for different cognitive tasks (Planning, Reasoning, Coding, QA) across five methods (Mesh/FC, Star, Dyn. Rep., Hierarchical, Chain). Darker green shades represent higher percentage gains, with values ranging from 2% to 12%. ### Components/Axes - **X-axis (Tasks)**: Planning, Reasoning, Coding, QA - **Y-axis (Methods)**: Mesh/FC, Star, Dyn. Rep., Hierarchical, Chain - **Color Legend**: Right-aligned vertical bar (2% to 12%, darker green = higher gain) - **Row Means**: Bottom row (average gain per method across tasks) - **Column Means**: Right column (average gain per task across methods) - **Asterisk**: Appears in Dyn. Rep. row under Reasoning task (unexplained in image) ### Detailed Analysis #### Task-Specific Gains - **Planning**: - Mesh/FC: +12.34% (darkest green) - Star: +11.23% - Dyn. Rep.: +8.76% - Hierarchical: +6.54% - Chain: +5.23% - **Reasoning**: - Mesh/FC: +9.87% - Star: +9.14% - Dyn. Rep.: +9.43% (asterisk) - Hierarchical: +5.87% - Chain: +4.61% - **Coding**: - Mesh/FC: +7.52% - Star: +6.89% - Dyn. Rep.: +6.21% - Hierarchical: +4.93% - Chain: +3.84% - **QA**: - Mesh/FC: +4.81% - Star: +5.12% - Dyn. Rep.: +3.94% - Hierarchical: +3.71% - Chain: +2.07% #### Row/Column Means - **Row Means (Method Averages)**: - Mesh/FC: 8.63% - Star: 8.10% - Dyn. Rep.: 7.08% - Hierarchical: 5.26% - Chain: 3.94% - **Column Means (Task Averages)**: - Planning: 8.82% - Reasoning: 7.78% - Coding: 5.88% - QA: 3.93% ### Key Observations 1. **Mesh/FC** dominates in Planning (+12.34%) and Reasoning (+9.87%), with the highest overall average (8.63%). 2. **Chain** underperforms across all tasks, with the lowest gains (e.g., +2.07% in QA). 3. **Dyn. Rep.** shows a notable asterisk in Reasoning (+9.43%), suggesting potential statistical significance or outlier status. 4. **QA task** has the lowest average gains (3.93%), indicating weaker performance across all methods. 5. **Planning** task has the highest average gain (8.82%), followed by Reasoning (7.78%). ### Interpretation The data suggests that **Mesh/FC** and **Star** methods excel in cognitively demanding tasks (Planning/Reasoning), while **Chain** struggles across all domains. The **QA task** shows minimal gains overall, possibly due to its reliance on domain-specific knowledge rather than general cognitive skills. The asterisk on Dyn. Rep. in Reasoning warrants further investigation but is unexplained in the image. The heatmap highlights a clear hierarchy in method effectiveness, with Planning tasks benefiting most from advanced reasoning frameworks. </details> Figure 10: Heterogeneity of DTI gains across topology and task family. Relative improvement in task success (%) under DTI versus baseline, reported per topology-task condition. Gains range from +2.07% (QA $×$ Chain) to +12.34% (Planning $×$ Mesh/FC). DTI produces the largest improvements in conditions exhibiting the strongest expansion-integration imbalance in baseline coordination dynamics. Row and column marginals show topology- and task-level averages. These structural improvements translate into performance gains. Figure 10 shows that gains are largest in high-imbalance settings (Planning $×$ Mesh) and smallest where imbalance is weakest (QA $×$ Chain), confirming that DTI targets the identified failure mode rather than producing uniform improvements. These results establish that the expansion–integration imbalance is causal: selectively increasing integration improves outcomes without suppressing large cascades. DTI thus provides a proof of principle that coordination structure can be directly regulated. Implementation details and the full algorithm are provided in Appendix C. ## 7 Discussion and Implications The central finding of this work is that coordination in LLM multi-agent systems self-organizes into a pattern that is simultaneously productive and self-limiting. The heavy-tailed cascade structure, elite concentration, and systematic growth of extreme events are not independent failure modes; they arise from the same reinforcement dynamics that enable complex collective reasoning. These dynamics amplify coordination while progressively weakening consolidation, leading to non-monotonic returns that cannot be resolved by improving individual agents alone. This has direct implications for how LLM MAS are designed and evaluated. Current practice treats scaling failures as capability gaps, addressable through better models, prompts, or benchmarks. Our results suggest an additional axis: coordination structure. The tail exponents, attachment slopes, and merge conversion ratios identified here provide a quantitative vocabulary for diagnosing coordination health that is orthogonal to task performance. A system may achieve high accuracy while operating in a structurally fragile configuration, or fail despite sufficient capability if coordination is misallocated. Evaluation frameworks that measure only outcomes miss this dimension. DTI demonstrates that the coordination structure is regulable, but it is a proof of principle rather than a complete solution. It targets a single imbalance: expansion over consolidation through threshold-triggered integration. A fuller account of coordination regulation would require dynamic topology adaptation, control of reinforcement dynamics, and mechanisms that couple elite formation with effective integration over longer horizons to better distribute utility across agents as the system size increases. The laws developed here provide a quantitative foundation for this broader design space. ## 8 Limitations Our analysis focuses on a controlled set of coordination primitives and topology-task configurations; while the observed patterns are consistent across these settings, additional coordination mechanisms and longer-horizon interactions may introduce dynamics not captured here. Our measurements are derived from discrete event abstractions of coordination, which, while interpretable and comparable across conditions, may not fully capture finer-grained semantic aspects of reasoning quality. DTI is intentionally minimal and targets a single form of imbalance; it does not address all factors influencing coordination outcomes, nor does it guarantee optimal performance across all regimes. Finally, while scaling behavior is consistent across models and settings, our conclusions are empirical and finite-sample in nature, and further theoretical and large-scale validation would strengthen their generality. ## 9 Conclusion We show that coordination in LLM MAS follows a consistent structural pattern: heavy-tailed cascades, reinforcement-driven concentration, and systematic growth of extreme events. These are coupled effects of how coordination propagates and accumulates, leading, as systems scale, to an increasing imbalance between expansion and integration and to large but weakly consolidated reasoning trajectories. This perspective shifts the focus from agent capability to coordination structure. Scaling failures are not solely due to insufficient reasoning ability, but to how coordination is distributed and reinforced. By identifying measurable laws-tail behavior, attachment dynamics, and integration efficiency, we provide a framework for diagnosing coordination at scale. Our intervention demonstrates that these dynamics are regulable: selectively rebalancing coordination improves outcomes without suppressing large-scale reasoning. Future progress in LLM MAS will therefore depend not only on stronger agents, but on mechanisms that shape how collective reasoning unfolds. ## References - [1] K. An (1933) Sulla determinazione empirica di una legge didistribuzione. Giorn Dell’inst Ital Degli Att 4, pp. 89–91. Cited by: §3.4. - [2] P. Bak, C. Tang, and K. Wiesenfeld (1987) Self-organized criticality: an explanation of the 1/f noise. Physical review letters 59 (4), pp. 381. Cited by: §2. - [3] E. Bakshy, J. M. Hofman, W. A. Mason, and D. J. Watts (2011) Everyone’s an influencer: quantifying influence on twitter. In Proceedings of the fourth ACM international conference on Web search and data mining, pp. 65–74. Cited by: §2. - [4] A. Barabási and R. Albert (1999) Emergence of scaling in random networks. science 286 (5439), pp. 509–512. Cited by: §1, §1, §2. - [5] A. Barabasi (2005) The origin of bursts and heavy tails in human dynamics. Nature 435 (7039), pp. 207–211. Cited by: §1, §2. - [6] M. Cemri, M. Z. Pan, S. Yang, L. A. Agrawal, B. Chopra, R. Tiwari, K. Keutzer, A. Parameswaran, D. Klein, K. Ramchandran, et al. (2025) Why do multi-agent llm systems fail?. arXiv preprint arXiv:2503.13657. Cited by: §1, §1, §1, §2, §5.3. - [7] M. Cha, H. Haddadi, F. Benevenuto, and K. Gummadi (2010) Measuring user influence in twitter: the million follower fallacy. In Proceedings of the international AAAI conference on web and social media, Vol. 4, pp. 10–17. Cited by: §2. - [8] C. Chan, W. Chen, Y. Su, J. Yu, W. Xue, S. Zhang, J. Fu, and Z. Liu (2023) Chateval: towards better llm-based evaluators through multi-agent debate. arXiv preprint arXiv:2308.07201. Cited by: §2. - [9] LangGraph: building stateful, multi-agent applications with llms External Links: Link Cited by: §3.1. - [10] J. Chen, S. Saha, and M. Bansal (2024) Reconcile: round-table conference improves reasoning via consensus among diverse llms. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 7066–7085. Cited by: §2. - [11] L. Chen, J. Davis, B. Hanin, P. Bailis, I. Stoica, M. Zaharia, and J. Zou (2024) Are more llm calls all you need? towards the scaling properties of compound ai systems. Advances in Neural Information Processing Systems 37, pp. 45767–45790. Cited by: §1, §1, §1, §2. - [12] W. Chen, Y. Su, J. Zuo, C. Yang, C. Yuan, C. Chan, H. Yu, Y. Lu, Y. Hung, C. Qian, et al. (2023) Agentverse: facilitating multi-agent collaboration and exploring emergent behaviors. In The Twelfth International Conference on Learning Representations, Cited by: §1. - [13] A. Clauset, C. R. Shalizi, and M. E. Newman (2009) Power-law distributions in empirical data. SIAM review 51 (4), pp. 661–703. Cited by: §1, §2, §3.4. - [14] R. Crane and D. Sornette (2008) Robust dynamic classes revealed by measuring the response function of a social system. Proceedings of the National Academy of Sciences 105 (41), pp. 15649–15653. Cited by: §2. - [15] L. De Haan and A. Ferreira (2006) Extreme value theory: an introduction. Springer. Cited by: §5.3. - [16] Y. Du, S. Li, A. Torralba, J. B. Tenenbaum, and I. Mordatch (2024) Improving factuality and reasoning in language models through multiagent debate. In Forty-first international conference on machine learning, Cited by: §1, §1, §2. - [17] P. Embrechts, C. Klüppelberg, and T. Mikosch (2013) Modelling extremal events: for insurance and finance. Vol. 33, Springer Science & Business Media. Cited by: §2, §5.3. - [18] L. Geng and E. Y. Chang (2025) Realm-bench: a benchmark for evaluating multi-agent systems on real-world, dynamic planning and scheduling tasks. arXiv preprint arXiv:2502.18836. Cited by: §2, §3.1. - [19] C. Gini (1921) Measurement of inequality of incomes. The economic journal 31 (121), pp. 124–125. Cited by: §2. - [20] K. Goh, B. Kahng, and D. Kim (2001) Universal behavior of load distribution in scale-free networks. Physical review letters 87 (27), pp. 278701. Cited by: §1, §2. - [21] M. L. Goldstein, S. A. Morris, and G. G. Yen (2004) Problems with fitting to the power-law distribution. The European Physical Journal B-Condensed Matter and Complex Systems 41 (2), pp. 255–258. Cited by: §2. - [22] Y. Gu, K. Zhang, Y. Ning, B. Zheng, B. Gou, T. Xue, C. Chang, S. Srivastava, Y. Xie, P. Qi, et al. (2024) Is your llm secretly a world model of the internet? model-based planning for web agents. arXiv preprint arXiv:2411.06559. Cited by: §1. - [23] T. Guo, X. Chen, Y. Wang, R. Chang, S. Pei, N. V. Chawla, O. Wiest, and X. Zhang (2024) Large language model based multi-agents: a survey of progress and challenges. arXiv preprint arXiv:2402.01680. Cited by: §1, §1, §2. - [24] A. Halfaker, R. S. Geiger, J. T. Morgan, and J. Riedl (2013) The rise and decline of an open collaboration system: how wikipedia’s reaction to popularity is causing its decline. American behavioral scientist 57 (5), pp. 664–688. Cited by: §2. - [25] S. Hong, M. Zhuge, J. Chen, X. Zheng, Y. Cheng, J. Wang, C. Zhang, Z. Wang, S. K. S. Yau, Z. Lin, et al. (2023) MetaGPT: meta programming for a multi-agent collaborative framework. In The twelfth international conference on learning representations, Cited by: §2. - [26] C. E. Jimenez, J. Yang, A. Wettig, S. Yao, K. Pei, O. Press, and K. Narasimhan (2023) Swe-bench: can language models resolve real-world github issues?. arXiv preprint arXiv:2310.06770. Cited by: §2, §3.1. - [27] S. Kapoor, B. Stroebl, Z. S. Siegel, N. Nadgir, and A. Narayanan (2024) Ai agents that matter. arXiv preprint arXiv:2407.01502. Cited by: §2. - [28] Y. Kim, K. Gu, C. Park, C. Park, S. Schmidgall, A. A. Heydari, Y. Yan, Z. Zhang, Y. Zhuang, M. Malhotra, et al. (2025) Towards a science of scaling agent systems. arXiv preprint arXiv:2512.08296. Cited by: §2. - [29] K. Klemm and V. M. Eguiluz (2002) Highly clustered scale-free networks. Physical Review E 65 (3), pp. 036123. Cited by: §2. - [30] E. La Malfa, G. La Malfa, S. Marro, J. M. Zhang, E. Black, M. Luck, P. Torr, and M. Wooldridge (2025) Large language models miss the multi-agent mark. arXiv preprint arXiv:2505.21298. Cited by: §2. - [31] J. Z. Leibo, V. Zambaldi, M. Lanctot, J. Marecki, and T. Graepel (2017) Multi-agent reinforcement learning in sequential social dilemmas. arXiv preprint arXiv:1702.03037. Cited by: §2. - [32] J. Leskovec, L. A. Adamic, and B. A. Huberman (2007) The dynamics of viral marketing. ACM Transactions on the Web (TWEB) 1 (1), pp. 5–es. Cited by: §2. - [33] G. Li, H. Hammoud, H. Itani, D. Khizbullin, and B. Ghanem (2023) Camel: communicative agents for" mind" exploration of large language model society. Advances in neural information processing systems 36, pp. 51991–52008. Cited by: §2. - [34] T. Liang, Z. He, W. Jiao, X. Wang, Y. Wang, R. Wang, Y. Yang, S. Shi, and Z. Tu (2024) Encouraging divergent thinking in large language models through multi-agent debate. In Proceedings of the 2024 conference on empirical methods in natural language processing, pp. 17889–17904. Cited by: §1, §2. - [35] X. Liu, H. Yu, H. Zhang, Y. Xu, X. Lei, H. Lai, Y. Gu, H. Ding, K. Men, K. Yang, et al. (2023) Agentbench: evaluating llms as agents. arXiv preprint arXiv:2308.03688. Cited by: §1. - [36] Z. Liu, Y. Zhang, P. Li, Y. Liu, and D. Yang (2023) Dynamic llm-agent network: an llm-agent collaboration framework with agent team optimization. arXiv preprint arXiv:2310.02170. Cited by: §2. - [37] M. O. Lorenz (1905) Methods of measuring the concentration of wealth. Publications of the American statistical association 9 (70), pp. 209–219. Cited by: §2. - [38] R. Lowe, Y. I. Wu, A. Tamar, J. Harb, O. Pieter Abbeel, and I. Mordatch (2017) Multi-agent actor-critic for mixed cooperative-competitive environments. Advances in neural information processing systems 30. Cited by: §2. - [39] T. W. Malone and M. Bernstein (2015) Handbook of collective intelligence. MIT press. Cited by: §2. - [40] G. Mialon, C. Fourrier, T. Wolf, Y. LeCun, and T. Scialom (2023) Gaia: a benchmark for general ai assistants. In The Twelfth International Conference on Learning Representations, Cited by: §2, §3.1. - [41] M. Mitzenmacher (2004) A brief history of generative models for power law and lognormal distributions. Internet mathematics 1 (2), pp. 226–251. Cited by: §2. - [42] M. E. Newman (2003) The structure and function of complex networks. SIAM review 45 (2), pp. 167–256. Cited by: §2. - [43] M. E. Newman (2005) Power laws, pareto distributions and zipf’s law. Contemporary physics 46 (5), pp. 323–351. Cited by: §1, §1, §2, §3.4. - [44] E. Nisioti, C. Glanois, E. Najarro, A. Dai, E. Meyerson, J. W. Pedersen, L. Teodorescu, C. F. Hayes, S. Sudhakaran, and S. Risi (2024) From text to life: on the reciprocal relationship between artificial life and large language models. In Artificial Life Conference Proceedings 36, Vol. 2024, pp. 39. Cited by: §2. - [45] R. Nordenlöw et al. (2025) The influence of scaffolds on coordination scaling laws in LLM agents. In NeurIPS 2025 Workshop on Multi-Turn Interactions in Large Language Models (MTI-LLM), Cited by: §2. - [46] C. Packer, V. Fang, S. Patil, K. Lin, S. Wooders, and J. Gonzalez MemGPT: towards llms as operating systems. arxiv 2023. arXiv preprint arXiv:2310.08560. Cited by: §1. - [47] V. Pareto (1964) Cours d’économie politique. Vol. 1, Librairie Droz. Cited by: §2. - [48] J. S. Park, J. O’Brien, C. J. Cai, M. R. Morris, P. Liang, and M. S. Bernstein (2023) Generative agents: interactive simulacra of human behavior. In Proceedings of the 36th annual acm symposium on user interface software and technology, pp. 1–22. Cited by: §2. - [49] T. Piketty (2014) Capital in the twenty-first century. Harvard University Press. Cited by: §2. - [50] C. Qian, W. Liu, H. Liu, N. Chen, Y. Dang, J. Li, C. Yang, W. Chen, Y. Su, X. Cong, et al. (2024) Chatdev: communicative agents for software development. In Proceedings of the 62nd annual meeting of the association for computational linguistics (volume 1: Long papers), pp. 15174–15186. Cited by: §1, §2. - [51] C. Qian, Z. Xie, Y. Wang, W. Liu, K. Zhu, H. Xia, Y. Dang, Z. Du, W. Chen, C. Yang, et al. (2024) Scaling large language model-based multi-agent collaboration. arXiv preprint arXiv:2406.07155. Cited by: §2. - [52] N. Shinn, F. Cassano, A. Gopinath, K. Narasimhan, and S. Yao (2023) Reflexion: language agents with verbal reinforcement learning. Advances in neural information processing systems 36, pp. 8634–8652. Cited by: §2. - [53] N. Smirnov (1948) Table for estimating the goodness of fit of empirical distributions. The annals of mathematical statistics 19 (2), pp. 279–281. Cited by: §3.4. - [54] M. P. Stumpf and M. A. Porter (2012) Critical truths about power laws. Science 335 (6069), pp. 665–666. Cited by: §1, §2. - [55] J. Surowiecki (2005) The wisdom of crowds. Vintage. Cited by: §2. - [56] K. Tran, D. Dao, M. Nguyen, Q. Pham, B. O’Sullivan, and H. D. Nguyen (2025) Multi-agent collaboration mechanisms: a survey of llms. arXiv preprint arXiv:2501.06322. Cited by: §2. - [57] K. Venkatesh, Y. He, J. Li, and J. Cui (2026) PhysicsAgentABM: physics-guided generative agent-based modeling. arXiv preprint arXiv:2602.06030. Cited by: §1. - [58] Y. S. Virkar (2012) Power-law distributions and binned empirical data. Master’s Thesis, University of Colorado at Boulder. Cited by: §2. - [59] Q. H. Vuong (1989) Likelihood ratio tests for model selection and non-nested hypotheses. Econometrica: journal of the Econometric Society, pp. 307–333. Cited by: §1, §2, §3.4. - [60] L. Wang, C. Ma, X. Feng, Z. Zhang, H. Yang, J. Zhang, Z. Chen, J. Tang, X. Chen, Y. Lin, et al. (2024) A survey on large language model based autonomous agents. Frontiers of Computer Science 18 (6), pp. 186345. Cited by: §2. - [61] X. Wang, J. Wei, D. Schuurmans, Q. Le, E. Chi, S. Narang, A. Chowdhery, and D. Zhou (2022) Self-consistency improves chain of thought reasoning in language models. arXiv preprint arXiv:2203.11171. Cited by: §2. - [62] D. J. Watts and S. H. Strogatz (1998) Collective dynamics of ‘small-world’networks. nature 393 (6684), pp. 440–442. Cited by: §2. - [63] D. J. Watts (2002) A simple model of global cascades on random networks. Proceedings of the National Academy of Sciences 99 (9), pp. 5766–5771. Cited by: §2. - [64] J. Wei, X. Wang, D. Schuurmans, M. Bosma, F. Xia, E. Chi, Q. V. Le, D. Zhou, et al. (2022) Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems 35, pp. 24824–24837. Cited by: §1, §2. - [65] A. W. Woolley, C. F. Chabris, A. Pentland, N. Hashmi, and T. W. Malone (2010) Evidence for a collective intelligence factor in the performance of human groups. science 330 (6004), pp. 686–688. Cited by: §2. - [66] Q. Wu, G. Bansal, J. Zhang, Y. Wu, B. Li, E. Zhu, L. Jiang, X. Zhang, S. Zhang, J. Liu, et al. (2024) Autogen: enabling next-gen llm applications via multi-agent conversations. In First conference on language modeling, Cited by: §2. - [67] Z. Xi, W. Chen, X. Guo, W. He, Y. Ding, B. Hong, M. Zhang, J. Wang, S. Jin, E. Zhou, et al. (2025) The rise and potential of large language model based agents: a survey. Science China Information Sciences 68 (2), pp. 121101. Cited by: §2. - [68] S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. R. Narasimhan, and Y. Cao (2022) React: synergizing reasoning and acting in language models. In The eleventh international conference on learning representations, Cited by: §1, §2. - [69] K. Zhu, H. Du, Z. Hong, X. Yang, S. Guo, D. Z. Wang, Z. Wang, C. Qian, R. Tang, H. Ji, et al. (2025) Multiagentbench: evaluating the collaboration and competition of llm agents. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 8580–8622. Cited by: §2, §3.1. - [70] M. Zhuge, W. Wang, L. Kirsch, F. Faccio, D. Khizbullin, and J. Schmidhuber (2024) Gptswarm: language agents as optimizable graphs. In Forty-first International Conference on Machine Learning, Cited by: §1, §2. ## Appendix ## Appendix A Additional Qualitative Results In this section, we provide additional qualitative results pertaining to each of the hypotheses tested: <details> <summary>2604.02674v1/x11.png Details</summary>  ### Visual Description ## Bar Chart: Event Composition By Cascade Size ### Overview A stacked bar chart showing the proportion of four event types (Delegation, Contradiction, Revision, Merge) across four cascade size bins (0-50%, 50-90%, 90-99%, Top 1%). ### Components/Axes - **X-axis**: Cascade Size Bin (TCQ Quantile) with categories: - 0-50% - 50-90% - 90-99% - Top 1% - **Y-axis**: Event Fraction (0% to 100%) - **Legend**: - Delegation (blue) - Contradiction (green) - Revision (red) - Merge (yellow) ### Detailed Analysis - **0-50% Bin**: - Delegation: ~35% (blue) - Contradiction: ~20% (green) - Revision: ~25% (red) - Merge: ~20% (yellow) - **50-90% Bin**: - Delegation: ~40% (blue) - Contradiction: ~25% (green) - Revision: ~20% (red) - Merge: ~15% (yellow) - **90-99% Bin**: - Delegation: ~45% (blue) - Contradiction: ~30% (green) - Revision: ~15% (red) - Merge: ~10% (yellow) - **Top 1% Bin**: - Delegation: ~50% (blue) - Contradiction: ~35% (green) - Revision: ~10% (red) - Merge: ~5% (yellow) ### Key Observations - Delegation dominates smaller cascade bins (0-50%) and decreases as cascade size shrinks. - Merge events are most frequent in the 0-50% bin (~20%) and drop sharply in smaller cascades. - Contradiction increases slightly in smaller cascades (e.g., ~20% in 0-50% vs. ~35% in Top 1%). ## Heatmap: Integration Weakens Jointly With Size And Scale ### Overview A heatmap showing merge conversion ratios across agent-society sizes (N) and cascade size bins (0-50%, 50-90%, 90-99%, Top 1%). ### Components/Axes - **X-axis**: Cascade Size Bin (TCQ Quantile) with categories: - 0-50% - 50-90% - 90-99% - Top 1% - **Y-axis**: Agent-Society Size (N) with values: - 8 - 16 - 32 - 64 - 128 - 256 - 512 - **Color Scale**: Merge Conversion Ratio (0.08 to 0.21, darker blue = higher values) ### Detailed Analysis - **Cascade Size Bin: 0-50%** - N=8: 0.21 - N=16: 0.20 - N=32: 0.19 - N=64: 0.18 - N=128: 0.16 - N=256: 0.15 - N=512: 0.13 - **Cascade Size Bin: 50-90%** - N=8: 0.18 - N=16: 0.17 - N=32: 0.16 - N=64: 0.15 - N=128: 0.14 - N=256: 0.12 - N=512: 0.10 - **Cascade Size Bin: 90-99%** - N=8: 0.15 - N=16: 0.14 - N=32: 0.13 - N=64: 0.12 - N=128: 0.11 - N=256: 0.09 - N=512: 0.08 - **Cascade Size Bin: Top 1%** - N=8: 0.13 - N=16: 0.12 - N=32: 0.11 - N=64: 0.10 - N=128: 0.09 - N=256: 0.08 - N=512: 0.07 ### Key Observations - Merge conversion ratios decrease as both cascade size and agent-society size increase. - Largest cascades (Top 1%) have the lowest merge ratios (~0.07 at N=512). - Smaller cascades (0-50%) show higher merge ratios (~0.21 at N=8). ## Interpretation 1. **Bar Chart Insights**: - Delegation becomes more prevalent in smaller cascades, suggesting it is a primary mechanism for information spread in less impactful cascades. - Merge events dominate larger cascades but diminish in the smallest cascades, implying merging is less critical for low-impact cascades. 2. **Heatmap Insights**: - Integration (via merging) weakens as both cascade and agent-society sizes grow. This suggests larger systems struggle to maintain cohesive integration, possibly due to complexity or fragmentation. - The steepest decline in merge ratios occurs in the Top 1% cascade bin, highlighting a critical threshold where integration becomes ineffective. 3. **Cross-Chart Relationships**: - The bar chart’s decline in Merge events aligns with the heatmap’s trend of lower merge ratios in smaller cascades. - Both visualizations emphasize that cascade size and system scale are inversely correlated with effective integration. 4. **Anomalies**: - Contradiction events increase in smaller cascades (e.g., ~35% in Top 1% vs. ~20% in 0-50%), suggesting smaller cascades may involve more conflicting interactions. - The heatmap’s sharp drop in merge ratios for Top 1% cascades (e.g., 0.07 at N=512) indicates a potential tipping point for integration failure. </details> Figure 11: Internal composition of claim-level coordination cascades and the scale-conditioned integration bottleneck. (a) Claim-rooted cascades are grouped by total cognitive effort (TCE) quantile, pooling all tasks, topologies, and agent scales. As cascades move into the far tail, their internal event composition shifts toward delegation and contradiction, while merge remains comparatively weak and increasingly subproportional; revision plays an intermediate role. (b) The same bottleneck appears in the merge conversion ratio across both cascade size and society scale: integration is strongest for smaller cascades in smaller societies and weakens progressively toward extreme cascades in larger societies. Together, these results show that large coordination cascades are increasingly expansion-heavy and merge-poor, and that this integration deficit strengthens with scale. ## Appendix B Notation We summarize the mathematical notation used throughout the paper. We use $β$ for the theoretical routing strength and $\hat{β}$ for empirically estimated scaling exponents. In practice, the theoretical EVT prediction $γ_th=1/(α-1)$ is evaluated by substituting the empirical estimate $\hat{α}$ . ### B.1 Heavy-Tail Modeling | Symbol | Meaning | | --- | --- | | $X$ | Random variable representing an event-size observable | | $x$ | Realized value of $X$ | | $P(X≥ x)$ | Complementary cumulative distribution function (CCDF) of $X$ | | $α$ | Tail exponent of the power-law / truncated power-law model | | $\hat{α}$ | MLE estimate of $α$ | | $x_\min$ | Lower cutoff above which tail fitting is performed | | $x_c$ | Exponential cutoff scale in the truncated power-law model | | $\hat{x}_c$ | MLE estimate of $x_c$ | | $n_tail$ | Number of observations satisfying $x≥ x_\min$ | | $LR$ | Log-likelihood ratio between two candidate models | | $p$ | $p$ -value associated with the likelihood-ratio comparison | Table 4: Notation for heavy-tail modeling and model comparison (H1). ### B.2 Elite Concentration | Symbol | Meaning | | --- | --- | | $TCE(c_r)$ | Total Cognitive Effort: total number of downstream events from root claim $c_r$ | | $S_k(c_r)$ | Top- $k$ contribution share within cascade $C_r$ | | $E^active_k$ | Top- $k$ % effort share; denominator = active agents only | | $E^all_k$ | Top- $k$ % effort share; denominator = all $N$ agents | | $Δ^active_k$ | Excess share above egalitarian baseline $k/N$ | | $S_p$ | Cumulative concentration curve (Lorenz-style) | | $A(N)$ | Active-agent fraction at society size $N$ | | $M$ | Fraction of elite coordination effort attributed to merge events | Table 5: Notation for elite concentration and inequality (H2). ### B.3 Extreme-Event Scaling | Symbol | Meaning | | --- | --- | | $x_\max(N)$ | Maximum cascade size in a system of $N$ agents | | $⟨ x_\max⟩$ | Expected maximum event size (averaged over runs) | | $\hat{γ}$ | Empirically estimated extreme-value scaling exponent | | $γ_th=1/(α-1)$ | Theoretical EVT prediction for scaling exponent | Table 6: Notation for extreme-event scaling (H3). ### B.4 Intervention (DTI) | Symbol | Meaning | | --- | --- | | $R(x,N)$ | Routing ratio: relative likelihood a claim with activity $x$ is selected | | $β$ | Reinforcement strength in the routing rule (Eq. 6) | | $\hat{β}(N)$ | Empirical condition-level attachment slope | | $\hat{β}_e$ | Event-specific attachment slope | | $\hat{β}_c$ | Contradiction scaling exponent used in DTI pressure model | | $p_cont,e$ | Continuation probability per event type | | $A_e=\hat{β}_e· p_cont,e$ | Amplification potential per event type | | $t_r$ | Coordination events elapsed in active cascade segment | | $M_r$ | Realized merge events in current cascade segment | | $P_r(t_r)$ | Contradiction-driven exploration pressure (Eq. A1) | | $Δ_r(t_r)$ | Integration deficit (Eq. A2) | | $δ_c$ | Condition-specific deficit threshold (Eq. A3) | | $a_c$ | Normalization constant for condition class $c$ | | $B_r$ | Active branch heads for root claim $r$ | Table 7: Notation for preferential attachment and Deficit-Triggered Integration (DTI). ## Appendix C Additional Details on Deficit-Triggered Integration (DTI) We provide a complete formal specification of Deficit-Triggered Integration (DTI), introduced in Section X. DTI is a cascade-local intervention that monitors the imbalance between exploration and integration and triggers integration when this imbalance exceeds a condition-specific threshold. DTI operates at the level of individual coordination cascades. Let $r$ denote a root claim, and consider the cascade defined by all events whose causal ancestry traces to $r$ . For each active cascade, we maintain a local state consisting of the number of coordination events observed so far, denoted by $t_r$ , and the number of realized merge events within the current cascade segment, denoted by $M_r$ . These quantities are updated incrementally as events are generated. To quantify expansion within the cascade, we model contradiction-driven exploration pressure as $$ P_r(t_r)=a_c t_r^\hat{β_c}, $$ where $\hat{β}_c$ is the empirically observed scaling exponent for contradiction events, and $a_c$ is a normalization constant defined for each condition class $c$ (topology $×$ task family). Algorithm 1 Deficit-Triggered Integration (DTI) 1: Event stream $E=\{e_1,\dots,e_T\}$ ; contradiction scaling coefficient $\hat{β}_c$ ; condition-specific normalization $a_c$ and threshold $δ_c$ estimated from baseline logs 2: 3: For each active root claim $r$ , initialize local cascade state: $$ t_r← 0, M_r← 0 $$ 4: for $t=1$ to $T$ do 5: Observe event $e_t$ 6: Determine its root claim $r←root(e_t)$ 7: Determine its condition class $c←cond(r)$ $\triangleright$ topology $×$ task family 8: Update local cascade length: $$ t_r← t_r+1 $$ 9: if $type(e_t)=\textsc{merge}$ then 10: $M_r← M_r+1$ 11: end if 12: Compute contradiction-driven exploration pressure: $$ P_r← a_c t_r^\hat{β_c} $$ 13: Compute integration deficit: $$ Δ_r← P_r-M_r $$ 14: if $Δ_r>δ_c$ then 15: $B_r←ActiveBranches(r)$ $\triangleright$ most recent branch-head outputs causally attached to root claim $r$ 16: Invoke integration over $B_r$ to produce merged claim $\tilde{e}$ 17: Log $\tilde{e}$ as a merge event attached to root claim $r$ 18: Broadcast $\tilde{e}$ as updated shared context for the cascade rooted at $r$ 19: Update merge count: $$ M_r← M_r+1 $$ 20: Restart the local cascade segment: $$ t_r← 0, M_r← 1 $$ 21: end if 22: end for Integration is measured directly through the realized merge count $M_r$ . The difference between exploration pressure and realized integration defines the integration deficit: $$ Δ_r(t_r)=P_r(t_r)-M_r. $$ DTI triggers an integration step when the deficit exceeds a condition-specific threshold: $$ Δ_r(t_r)>δ_c. $$ At this point, the set of active branch heads is collected as $$ B_r=ActiveBranches(r), $$ where $B_r$ consists of the most recent agent outputs whose causal ancestry traces to root claim $r$ . A structured integration prompt is applied to $B_r$ , consolidating active positions, identifying agreement, and resolving remaining disagreement into a single merged claim. The resulting output is logged as a merge event and broadcast as updated shared context. Following integration, the local cascade segment is restarted by setting $$ t_r← 0, M_r← 1, $$ which reflects that one integration event has already been realized and prevents immediate retriggering. The parameters $a_c$ and $δ_c$ are estimated directly from baseline coordination traces for each condition class. The normalization $a_c$ captures the empirical relationship between cascade growth and merge activity, while $δ_c$ is defined as the mean plus one standard deviation of the integration deficit observed at cascade termination points. These parameters are estimated directly from baseline coordination traces for each condition class and are fixed prior to intervention, introducing no outcome-tuned quantities. DTI maintains independent state for each active root claim and therefore requires only $O(|R|)$ additional memory, where $|R|$ is the number of active cascades. Each event incurs constant-time updates to $(t_r,M_r)$ , and no additional model calls are made except when the deficit threshold is exceeded. Because both the normalization and threshold are defined per condition class, the frequency of integration adapts automatically to the underlying coordination regime. Cascades with stronger expansion dynamics accumulate deficit more rapidly and therefore trigger integration more frequently, while cascades with weaker imbalance evolve largely unaffected. ## Appendix D Additional Quantitative Results This section provides additional statistical analyses supporting the empirical laws presented in the main text. Each subsection addresses a specific aspect of robustness, inequality, mechanism, or experimental validity. ### D.1 Statistical Validity of Heavy-Tail Fits To assess the robustness of heavy-tail estimates, we report bootstrap confidence intervals, tail fractions, and goodness-of-fit statistics for each observable. All observables exhibit stable exponents within the range $α∈[2.1,2.7]$ , with sufficient tail support and low KS distances, indicating reliable heavy-tail estimation. | Observable | $\hat{α}$ | CI | $n_tail/n$ | KS | | --- | --- | --- | --- | --- | | Delegation | 2.28 | [2.24, 2.32] | 0.27 | 0.042 | | Revision | 2.41 | [2.36, 2.46] | 0.31 | 0.047 | | Contradiction | 2.16 | [2.11, 2.21] | 0.22 | 0.039 | | Merge | 2.71 | [2.63, 2.79] | 0.14 | 0.051 | | TCE | 2.22 | [2.18, 2.26] | 0.30 | 0.035 | Table 8: Robustness of heavy-tail fits across observables. Confidence intervals are obtained via bootstrap resampling. ### D.2 Inequality and Elite Concentration Beyond top- $k$ share curves, we quantify inequality using the Gini coefficient and effective number of agents. As system size increases, both metrics indicate increasing concentration of reasoning effort, with fewer agents accounting for a larger fraction of total coordination activity. | $N$ | Top-1 | Top-10% | Gini | $N_eff/N$ | | --- | --- | --- | --- | --- | | 8 | 0.04 | 0.17 | 0.20 | 0.88 | | 32 | 0.07 | 0.21 | 0.25 | 0.81 | | 128 | 0.08 | 0.23 | 0.31 | 0.73 | | 512 | 0.11 | 0.29 | 0.39 | 0.64 | Table 9: Concentration of reasoning effort across agent scales. Top- $k$ shares increase while the effective number of contributing agents decreases with $N$ . | Metric | Mean | Std (across seeds) | | --- | --- | --- | | Gini | 0.37 | 0.018 | | Top-10% share | 0.29 | 0.017 | | $N_eff/N$ | 0.64 | 0.015 | Table 10: Stability of inequality metrics across random seeds (averaged over all conditions). ### D.3 Tail Anatomy of Coordination Cascades To understand the structure of large coordination events, we analyze the composition of cascades across size percentiles. Larger cascades are increasingly dominated by expansion dynamics (delegation and contradiction), while merge activity declines sharply, indicating a structural imbalance in integration. | Percentile | Delegation | Contradiction | Merge | Merge ratio | | --- | --- | --- | --- | --- | | Median | 0.30 | 0.21 | 0.19 | 0.37 | | 90th | 0.36 | 0.26 | 0.15 | 0.24 | | 99th | 0.41 | 0.31 | 0.11 | 0.15 | | Top 1% | 0.45 | 0.34 | 0.08 | 0.10 | Table 11: Event composition across cascade size percentiles. Expansion dominates the tail while merge activity diminishes, revealing an integration bottleneck. ### D.4 Task Expansion Validation We report statistics of the benchmark-conditioned task expansion module. The module generates only workload and dependency structure; coordination events are not prescribed and are instead extracted from realized execution traces. | Benchmark | Seeds | Expanded tasks | Avg. dependencies | | --- | --- | --- | --- | | GAIA | 30 | 150 | 2.1 | | SWE-bench | 30 | 150 | 2.4 | | REALM | 11 | 55 | 2.0 | | MultiAgentBench | 30 | 150 | 2.3 | Table 12: Statistics of the task expansion module. Event structure is not injected but emerges from agent interaction during execution. ## Appendix E Event-Level Coordination Formulation and Trace Construction ### E.1 Coordination Hierarchy We distinguish four levels of structure in multi-agent reasoning: - Task: the global problem instance to be solved. - Subtask: a decomposed work unit created via delegation. - Claim: a unit of reasoning, such as a proposed solution, critique, or intermediate result. - Event: a single coordination step that creates, modifies, routes, or combines claims and subtasks. This hierarchy separates what is being solved (tasks and subtasks) from how reasoning evolves (events acting on claims). Our analysis operates at the event level: all coordination observables are defined over collections of events rather than over entire tasks. Importantly, claims represent reasoning artifacts, while events represent transitions between them. | Claim Type | Description | | --- | --- | | Proposed Claim | An initial statement or solution generated by an agent. | | Revised Claim | A modification of a prior claim that refines or corrects it. | | Contradictory Claim | A claim that challenges or disputes an existing claim. | | Merged Claim | A claim produced by combining multiple parent claims. | Table 13: Types of claims observed in coordination traces. Claims represent reasoning artifacts that are created and transformed through events. Task Subtask Subtask Subtask Claim Claim Claim Claim Claim Figure 12: Hierarchy of coordination structures in a multi-agent system. A task defines the global objective, which is decomposed into subtasks; subtasks produce claims; and claims evolve through event-level coordination steps. Our analysis operates on these events rather than on whole tasks. ### E.2 Claim and Event Definitions We formalize claims and events as the fundamental elements of coordination dynamics. #### Claims: A claim represents a unit of reasoning produced by an agent, such as a proposed solution, refinement, critique, or synthesis. Each claim is assigned a unique identifier and may reference one or more parent claims, forming a directed lineage structure. Formally, a claim $c_i$ is associated with a set of parent claims $P(c_i)$ , where $|P(c_i)|≥ 0$ . A claim with no parents is considered a root claim. #### Events: An event is a coordination action that operates on claims or subtasks. Events define how claims are created, modified, and connected, and therefore determine the structure of coordination. Each event is associated with: - an event type (e.g., delegate_subtask, revise_claim, contradict_claim, merge_claims), - an acting agent, - a target claim or subtask, - and a resulting claim (if applicable). #### Event-Induced Claim Transitions: Each event type induces a specific transformation in the claim structure: - Revision: creates a new claim with a single parent, forming a chain. - Contradiction: creates a new claim that challenges an existing claim, introducing branching. - Merge: creates a new claim with multiple parent claims, introducing multi-parent dependencies. - Delegation: creates a new subtask and initiates new claims within that subtask. These transitions define the edges of the claim graph and collectively produce a directed acyclic graph (DAG) over claims. | Event Type | Operation on Claims | Resulting Structure | | --- | --- | --- | | revise_claim | single parent $→$ child | chain | | contradict_claim | parent $→$ multiple children | branching | | merge_claims | multiple parents $→$ child | multi-parent (DAG) | | delegate_subtask | creates new subtask context | hierarchical tree | Table 14: Event types and their induced transformations on the claim structure. These operations define how the claim graph evolves from chains to branching structures and ultimately to a directed acyclic graph through merge operations. #### Key Property: The coordination structure is not imposed a priori but emerges from event-induced claim transitions. In particular, merge operations introduce multi-parent dependencies, converting tree-like reasoning structures into directed acyclic graphs. Revision (Chain) Contradiction (Branching) Merge (Multi-parent) Figure 13: Event-induced transformations of the claim structure. Revision produces linear chains, contradiction introduces branching around a claim, and merge combines multiple parent claims into a single node, yielding a directed acyclic graph. Delegation (Subtask Tree) Cascade (Total Cognitive Effort) Figure 14: Delegation and cascade structure. Delegation events construct a subtask tree (left), defining how work is decomposed. Coordination cascades (right) capture the total downstream activity triggered by a root claim, combining revision, contradiction, and merge dynamics. Total Cognitive Effort (TCE) is defined as the size of this reachable cascade. ### E.3 Trace Logging Schema We record fine-grained coordination traces at the event level to enable reconstruction of coordination structures. Each interaction step produces a structured record containing event metadata, claim lineage, subtask context, and derived coordination attributes. #### Overview: Each logged entry corresponds to a single coordination event and includes identifiers that link it to claims, subtasks, and other events. These records collectively define the inputs required to reconstruct both the subtask tree and the claim DAG. #### Event-Level Fields. | Field | Description | | --- | --- | | run_id | Identifier for the experiment run | | step_id | Temporal ordering of events | | agent_id | Acting agent | | event_type | Type of coordination event | | target_claim_id | Referenced claim (if applicable) | | target_subtask_id | Referenced subtask (if applicable) | | timestamp | Event time | | message_length | Token count (proxy for cost) | Table 15: Event-level fields recorded for each coordination step. #### Claim Graph Fields: | Field | Description | | --- | --- | | claim_id | Unique identifier for each claim | | parent_claim_ids | Parent claims defining DAG edges | | root_claim_id | Root ancestor of the claim | | claim_depth | Depth within the claim DAG | | claim_status | Proposed, revised, contradictory, or merged | Table 16: Fields defining the claim-level DAG structure. The root_claim_id is propagated across lineage and enables reconstruction of full coordination cascades. #### Subtask Tree Fields. | Field | Description | | --- | --- | | subtask_id | Unique identifier for each subtask | | parent_subtask_id | Parent subtask in hierarchy | | subtask_depth | Depth in subtask tree | | assigned_agent | Responsible agent | | subtask_status | Active or completed | Table 17: Fields defining the hierarchical subtask decomposition. #### Derived Coordination Fields. | Field | Description | | --- | --- | | revision_chain_id | Groups claims in a revision sequence | | contradiction_group_id | Groups claims targeting the same parent claim | | merge_id | Identifier for merge operations | | merge_parent_ids | Parent claims involved in merge | Table 18: Derived fields used to group events into coordination structures. These fields are computed from raw interaction traces and are not directly provided by the system. They enable identification of revision waves, contradiction bursts, and merge operations during post-processing. #### Reconstructability: Together, these fields provide sufficient information to reconstruct: - the subtask tree from delegation events, - the claim DAG from parent–child relationships, - and coordination cascades from root claim identifiers. Event Traces revise_claim claim_id: c2 parent: [c1] contradict_claim claim_id: c3 parent: [c1] merge_claims claim_id: c5 parents: [c2,c4] Claim DAG $c_1$ $c_2$ $c_3$ $c_4$ $c_5$ Cascade Figure 15: From structured event traces to coordination cascades. Logged event fields define parent–child claim relationships, from which we reconstruct the claim DAG. Cascades are then extracted as root-centered reachable subgraphs, enabling computation of event-level observables such as revision waves, contradiction bursts, merge fan-in, and total cognitive effort. ### E.4 DAG Construction Pipeline We reconstruct coordination structures from event traces in two stages: (i) subtask-tree construction from delegation events, and (ii) claim-DAG construction from claim-level lineage fields. Figure 15 summarizes this pipeline. #### Subtask Tree Construction. Delegation events define a hierarchical decomposition over work units. For each delegate_subtask event, we create a new subtask node and add a directed edge from parent_subtask_id to subtask_id. This produces a rooted tree over subtasks, where depth corresponds to recursive decomposition depth. The subtask tree therefore captures what agents are asked to work on. #### Claim DAG Construction. Claims form a separate structure that captures how reasoning evolves. Each claim is represented as a node indexed by claim_id. Directed edges are created from every element of parent_claim_ids to the current claim. This yields three canonical cases: - Revision: a claim has exactly one parent, producing a chain. - Contradiction: multiple child claims may reference the same parent, producing branching. - Merge: a claim has multiple parents, producing a multi-parent node. Because merge operations introduce multiple incoming edges, the resulting structure is in general a directed acyclic graph (DAG), rather than a tree. #### Root Claim Assignment. Each claim is associated with a root_claim_id, inherited from its earliest ancestor. Claims with no parents are initialized as root claims. For descendant claims, the root identifier is propagated through lineage during post-processing. This field is critical because it makes cascades reconstructable from local parent–child relationships. #### Derived Coordination Grouping. Several higher-level coordination structures are not directly emitted by the system and must be derived from raw traces: - Revision chains are formed by grouping claims linked through iterative single-parent revision steps. - Contradiction groups are formed by grouping claims that reference the same parent claim within a temporal window. - Merge groups are formed by collecting all parent claims participating in a merge_claims event. These derived identifiers are used to extract revision waves, contradiction bursts, and merge fan-in during analysis. The trace schema therefore records both raw lineage fields and post-processed grouping fields needed for event-level measurement. #### Cascade Extraction. Given a root claim $c_root$ , we define its coordination cascade as the reachable subgraph of all downstream claim and event instances associated with that root. Operationally, cascade extraction begins from root_claim_id and traverses all descendant claims connected through revision, contradiction, merge, and delegation-linked activity. This reachable subgraph is the object on which aggregate observables, such as total cognitive effort, are defined. #### Subtask Tree vs. Claim DAG. The subtask tree and claim DAG serve different purposes and should not be conflated. The subtask tree records task decomposition induced by delegation, while the claim DAG records the emergent propagation and integration of reasoning. In particular, the subtask tree prescribes work structure, whereas the claim DAG captures coordination structure. Our event-level observables are defined primarily on the claim DAG and its associated cascades, with delegation cascades obtained from the subtask tree. #### Reproducibility. This construction procedure ensures that all coordination observables reported in the paper are computed from structured traces rather than manually annotated or heuristically imposed interaction graphs. Given the logged fields in Section E.3, the subtask tree, claim DAG, and cascade assignments are fully reconstructable. ### E.5 Worked Example: From Task Expansion to Coordination Cascade We illustrate the full coordination pipeline using a representative configuration from our experimental setup. We consider a system with $N=16$ agents operating on a GAIA-style multi-step reasoning task. As described in Section 3, each task is expanded into an interdependent task tree using a structured reasoning procedure. #### Task Expansion. Given an input task requiring multi-step reasoning and constraint satisfaction, the expansion module generates the following interdependent task structure: - T0: Solve the full problem - T1: Extract key entities and constraints from the prompt - T2: Generate candidate reasoning paths - T3: Evaluate candidates under extracted constraints - T4: Refine top candidates - T5: Integrate reasoning into final answer Dependencies are not purely hierarchical: T3 depends on both T1 and T2, T4 depends on T3, and T5 integrates outputs from T2 and T4. This produces a directed task graph (referred to as a task tree for simplicity) with cross-subtask dependencies. #### Task Tree. Figure 16 (left) shows the resulting task structure. #### Agent Execution and Event Trace. Agents are assigned to subtasks and generate claims through interaction. A representative trace excerpt is: - c1: propose_claim (T2) — initial reasoning path - c2: revise_claim(c1) (T3) — adjusted using constraints from T1 - c3: contradict_claim(c1) (T3) — alternative reasoning path - c4: revise_claim(c2) (T4) — refined evaluation - c5: merge_claims(c2, c3, c4) (T5) — integrated final reasoning All claims inherit root_claim_id = c1, forming a single coordination cascade. #### Coordination Structures. Figure 16 shows the full pipeline: (left) task expansion into an interdependent structure, (center) claim-level DAG constructed from event traces, and (right) the cascade extracted from the root claim. T0 T1 T2 T3 T4 T5 Task Expansion Claim DAG Cascade (root $c_1$ ) Figure 16: End-to-end coordination pipeline in our experimental setup. Left: task expansion produces an interdependent task tree with cross-subtask dependencies. Center: agent interactions generate claims and event-induced edges, forming a claim DAG. Right: the cascade extracted from the root claim captures the full coordination effort used to compute event-level observables. #### Observable Computation. From the cascade rooted at $c_1$ , we compute: - Revision Wave: $c_1→ c_2→ c_4$ (length = 3) - Contradiction Burst: claim $c_1$ receives a competing claim $c_3$ (size = 1) - Merge Fan-in: $c_5$ integrates $c_2,c_3,c_4$ (fan-in = 3) - Total Cognitive Effort (TCE): all reachable claims $\{c_1,\dots,c_5\}$ (size = 5) #### Interpretation. This example reflects the coordination dynamics induced by our workload expansion procedure: task decomposition introduces interdependent subtasks, agents generate competing and refined reasoning across these subtasks, and merge operations integrate multiple branches. The resulting cascade structure is the fundamental object used to study scaling laws of coordination in our experiments. ### E.6 Observable Trigger Conditions We define the exact extraction rules used to compute coordination observables from reconstructed structures. All observables are computed from either the claim DAG, the subtask tree, or root-centered cascades as described in Sections E.4 and E.5. | Observable | Trigger Condition | Structure | Output | | --- | --- | --- | --- | | Delegation Cascade | Subtree rooted at a delegate_subtask event | Subtask tree | Node count | | Revision Wave | Maximal chain of claims with identical revision_chain_id | Claim DAG | Length | | Contradiction Burst | Claims referencing the same parent claim within a temporal window $τ$ | Claim DAG + timestamps | Count | | Merge Fan-in | Number of parent_claim_ids in a merge_claims event | Claim DAG | In-degree | | Total Cognitive Effort (TCE) | Reachable subgraph from root_claim_id | Cascade | Size | Table 19: Formal trigger conditions for coordination observables. Each observable is computed from structured traces via deterministic extraction rules applied to reconstructed coordination structures. #### Notes. All grouping variables (e.g., revision_chain_id, contradiction_group_id) are derived from raw traces during post-processing and are not directly emitted by the system. Temporal windows for contradiction grouping are defined relative to event timestamps. Observables are computed consistently across all tasks, topologies, and system scales. ## Appendix F LLM Ablation | | Tail structure | LR tests | Pref. Reinf. | Concentration | Outcome | | | | | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | Model | $\hat{α}$ | $\hat{x}_c$ | $x_\max$ | $LR_T/\mathrm{LN}$ | $LR_T/\mathrm{PL}$ | $\hat{β}$ | $E^all_10$ | Active | Task Succ. | | GPT-4o-mini | 2.22 | 57 | 1320 | +5.2 | +2.8 | 0.16 | 25% | 81% | 0.48 | | Qwen 2.5 72B | 2.27 | 44 | 1035 | +5.0 | +2.7 | 0.15 | 23% | 79% | 0.43 | | Llama 3.1 70B | 2.34 | 30 | 1012 | +4.8 | +2.5 | 0.13 | 19% | 78% | 0.41 | | Qwen 2.5 7B | 2.74 | 9 | 440 | +3.5 | +1.7 | 0.07 | 14% | 72% | 0.27 | Table 20: Global pooled TCE robustness across models. All 16 topology $×$ task conditions are pooled per model. For all cross-model TCE fits, we fix the tail onset threshold at $x_\min=8$ to maintain a common fitting regime across models. Tail statistics report the fitted truncated-power-law parameters for total collective effort (TCE), together with likelihood-ratio comparisons against log-normal and pure power-law alternatives. Preferential reinforcement is summarized by $\hat{β}$ , concentration by the top-10% effort share and active-agent fraction, and outcome by overall task success. | | | Tail structure | LR tests | Concentration | Outcome | | | | --- | --- | --- | --- | --- | --- | --- | --- | | Topology | Model | $\hat{α}$ | $\hat{x}_c$ | $LR_T/\mathrm{LN}$ | $LR_T/\mathrm{PL}$ | $E^all_10$ | Task succ. | | Chain | GPT-4o-mini | 2.49 | 23 | +4.6 | +2.6 | 17% | 0.43 | | Qwen 2.5 72B | 2.52 | 21 | +4.5 | +2.5 | 16% | 0.40 | | | Llama 3.1 70B | 2.61 | 18 | +4.2 | +2.3 | 14% | 0.36 | | | Qwen 2.5 7B | 2.88 | 9 | +3.0 | +1.5 | 11% | 0.19 | | | Star | GPT-4o-mini | 2.21 | 44 | +5.2 | +2.8 | 32% | 0.47 | | Qwen 2.5 72B | 2.24 | 41 | +5.1 | +2.7 | 30% | 0.44 | | | Llama 3.1 70B | 2.33 | 36 | +4.9 | +2.5 | 27% | 0.42 | | | Qwen 2.5 7B | 2.63 | 11 | +3.6 | +1.7 | 20% | 0.26 | | | Hierarchical | GPT-4o-mini | 2.16 | 35 | +5.1 | +2.7 | 21% | 0.53 | | Qwen 2.5 72B | 2.19 | 32 | +5.0 | +2.6 | 18% | 0.49 | | | Llama 3.1 70B | 2.28 | 28 | +4.8 | +2.4 | 15% | 0.46 | | | Qwen 2.5 7B | 2.58 | 9 | +3.4 | +1.6 | 13% | 0.31 | | | Fully Connected | GPT-4o-mini | 2.15 | 61 | +5.7 | +3.2 | 32% | 0.48 | | Qwen 2.5 72B | 2.18 | 56 | +5.6 | +3.1 | 31% | 0.46 | | | Llama 3.1 70B | 2.27 | 49 | +5.4 | +2.9 | 28% | 0.42 | | | Qwen 2.5 7B | 2.57 | 16 | +4.1 | +2.1 | 15% | 0.29 | | Table 21: TCE heavy-tail structure by topology and model. Results are pooled across task types within each topology. For all cross-model TCE fits, we fix the tail onset threshold at $x_\min=8$ to maintain a common fitting regime across models. Tail statistics report the fitted truncated-power-law parameters for total collective effort (TCE), together with likelihood-ratio comparisons against log-normal and pure power-law alternatives. Concentration is summarized by the top-10% effort share, and outcome by pooled task success. <details> <summary>2604.02674v1/x12.png Details</summary>  ### Visual Description ## Radar Charts: Model Performance Comparison ### Overview The image contains four radar charts comparing the performance of four AI models: **GPT-4o-mini**, **Qwen 2.5 72B**, **Llama 3.1 70B**, and **Qwen 2.5 7B**. Each chart evaluates five categories: **Delegation**, **TCE**, **Revision**, **Merge**, and **Contradiction**, with performance metrics represented by colored bars. Parameters **β** (beta) and **E10%** (error rate at 10% threshold) are provided for each model. ### Components/Axes - **Axes**: - **Delegation** (blue) - **TCE** (purple) - **Revision** (green) - **Merge** (red) - **Contradiction** (orange) - **Legend**: - Colors correspond to the five categories (blue, purple, green, red, orange). - Positioned at the top of each chart. - **Parameters**: - **β** (beta): A numerical value indicating a model-specific metric (e.g., 0.16 for GPT-4o-mini). - **E10%**: Error rate at 10% threshold (e.g., 25% for GPT-4o-mini). - Positioned at the bottom of each chart. ### Detailed Analysis #### GPT-4o-mini - **β**: 0.16 | **E10%**: 25% - **Delegation**: Longest bar (highest performance). - **Contradiction**: Second-longest bar. - **TCE**: Moderate length. - **Revision**: Shorter than TCE. - **Merge**: Shortest bar. #### Qwen 2.5 72B - **β**: 0.15 | **E10%**: 23% - **Delegation**: Slightly shorter than GPT-4o-mini. - **Contradiction**: Similar to GPT-4o-mini. - **TCE**: Slightly shorter than GPT-4o-mini. - **Revision**: Similar to GPT-4o-mini. - **Merge**: Slightly shorter than GPT-4o-mini. #### Llama 3.1 70B - **β**: 0.13 | **E10%**: 19% - **Delegation**: Shorter than GPT-4o-mini and Qwen 2.5 72B. - **Contradiction**: Similar to Qwen 2.5 72B. - **TCE**: Slightly shorter than Qwen 2.5 72B. - **Revision**: Similar to Qwen 2.5 72B. - **Merge**: Slightly shorter than Qwen 2.5 72B. #### Qwen 2.5 7B - **β**: 0.07 | **E10%**: 14% - **Delegation**: Shortest among all models. - **Contradiction**: Shorter than Llama 3.1 70B. - **TCE**: Very short. - **Revision**: Very short. - **Merge**: Very short. ### Key Observations 1. **GPT-4o-mini** dominates in **Delegation** and **Contradiction**, with the highest β and E10% values. 2. **Qwen 2.5 72B** performs similarly to GPT-4o-mini but with slightly lower β and E10%. 3. **Llama 3.1 70B** shows reduced performance in **Delegation** and **Merge** compared to GPT-4o-mini. 4. **Qwen 2.5 7B** has the lowest β and E10%, with minimal performance across all categories. 5. **β** and **E10%** values decrease progressively from GPT-4o-mini to Qwen 2.5 7B, suggesting a trade-off between performance and error rates. ### Interpretation The data suggests that **GPT-4o-mini** and **Qwen 2.5 72B** are the most robust models, excelling in **Delegation** and **Contradiction** tasks. **Llama 3.1 70B** and **Qwen 2.5 7B** show diminishing returns, with **Qwen 2.5 7B** performing poorly across all categories. The **β** parameter likely reflects a model's ability to handle complex tasks, while **E10%** indicates error rates under specific conditions. The trend of decreasing β and E10% with smaller models (e.g., Qwen 2.5 7B) implies that larger models may prioritize performance over efficiency or error resilience. </details> Figure 17: Coordination-law flower signatures across models. Each panel summarizes one model using five global event observables: delegation cascade, revision wave, contradiction burst, merge fan-in, and total cognitive effort (TCE). Petal extent jointly reflects four law dimensions: heavier tails (lower $\hat{α}$ ), larger truncation scale $\hat{x}_c$ , stronger preferential reinforcement $\hat{β}$ , and greater elite concentration $E^all_10$ . Across all four models, the qualitative ordering is preserved: TCE remains the strongest composite coordination signal, delegation and contradiction form the next tier of broad coordination, revision is intermediate, and merge is the weakest and most localized. Moving from GPT-4o-mini to Qwen 2.5 72B, Llama 3.1 70B, and Qwen 2.5 7B, the petals contract inward rather than changing shape abruptly, indicating that heavy-tailed coordination and elite formation persist across model families and scales, but with shorter tails, lower cutoff scales, and weaker concentration in smaller models owing to reduced model-inherent resources. | | | Tail structure | LR tests | Concentration | Outcome | | | | --- | --- | --- | --- | --- | --- | --- | --- | | Task type | Model | $\hat{α}$ | $\hat{x}_c$ | $LR_T/\mathrm{LN}$ | $LR_T/\mathrm{PL}$ | $E^all_10$ | Task succ. | | Planning | GPT-4o-mini | 2.11 | 54 | +5.2 | +2.2 | 30% | 0.45 | | Qwen 2.5 72B | 2.14 | 50 | +5.1 | +2.1 | 27% | 0.41 | | | Llama 3.1 70B | 2.23 | 44 | +4.8 | +1.9 | 22% | 0.40 | | | Qwen 2.5 7B | 2.53 | 14 | +3.6 | +1.1 | 16% | 0.23 | | | Reasoning | GPT-4o-mini | 2.20 | 45 | +5.2 | +2.7 | 23% | 0.56 | | Qwen 2.5 72B | 2.23 | 42 | +5.0 | +2.6 | 22% | 0.52 | | | Llama 3.1 70B | 2.32 | 36 | +4.8 | +2.4 | 19% | 0.51 | | | Qwen 2.5 7B | 2.62 | 11 | +3.6 | +1.6 | 14% | 0.34 | | | Coding | GPT-4o-mini | 2.31 | 34 | +5.2 | +3.0 | 24% | 0.46 | | Qwen 2.5 72B | 2.34 | 31 | +5.0 | +2.9 | 21% | 0.44 | | | Llama 3.1 70B | 2.43 | 27 | +4.8 | +2.7 | 18% | 0.42 | | | Qwen 2.5 7B | 2.72 | 9 | +3.5 | +1.9 | 13% | 0.29 | | | QA | GPT-4o-mini | 2.40 | 25 | +5.1 | +3.3 | 20% | 0.51 | | Qwen 2.5 72B | 2.44 | 23 | +5.0 | +3.2 | 19% | 0.47 | | | Llama 3.1 70B | 2.52 | 20 | +4.8 | +3.0 | 18% | 0.44 | | | Qwen 2.5 7B | 2.80 | 9 | +3.4 | +2.2 | 12% | 0.33 | | Table 22: TCE heavy-tail structure by task type and model. Results are shown for four representative task families and are pooled across topologies, seeds, and agent-society sizes within each task-type $×$ model condition. For all cross-model TCE fits, we fix the tail onset threshold at $x_\min=8$ to maintain a common fitting regime across models. Tail statistics report the fitted truncated-power-law parameters for total collective effort (TCE), together with likelihood-ratio comparisons against log-normal and pure power-law alternatives. Concentration is summarized by the top-10% effort share $E^all_10$ , and outcome by pooled task success. ## Appendix G Additional Details on Experimental Setup | Component | Configuration | | --- | --- | | Benchmarks | GAIA, SWE-bench Verified, REALM-Bench, MultiAgentBench | | Task types | QA, reasoning, coding, planning | | Total tasks | $∼$ 400 (stratified across benchmarks and difficulty levels) | | Agent counts ( $N$ ) | $\{8,16,32,64,128,256,512\}$ | | Topologies | Chain, Star, Tree, Hierarchical, Fully Connected, Sparse Mesh, Dynamic Reputation | | Agent model | Shared LLM (GPT-4o-mini) | | Execution steps | 20 per run | | Seeds | 5 independent random seeds per configuration | | Task expansion | Benchmark-conditioned expansion module (Appendix H) | | Trace granularity | Event-level (delegation, revision, contradiction, merge, endorsement) | | Total runs | $≈ 400× 7× 7× 5≈ 98{,}000$ | Table 23: Experimental configuration summary. | Observable | Samples | Mean/run | | --- | --- | --- | | Delegation cascades | $∼ 3.0× 10^5$ | $∼ 3.1$ | | Revision waves | $∼ 2.8× 10^5$ | $∼ 2.9$ | | Contradiction bursts | $∼ 3.2× 10^5$ | $∼ 3.3$ | | Merge events | $∼ 2.5× 10^5$ | $∼ 2.6$ | | TCE (root cascades) | $∼ 1.7× 10^5$ | $∼ 1.7$ | | Total | $>1.5× 10^6$ | $∼ 15.3$ | Table 24: Coordination-event samples extracted from $∼ 98{,}000$ runs. Each run produces multiple event instances depending on the realized interaction trace. ## Appendix H Workload Expansion Module To study coordination across agent societies of varying size, we introduce a benchmark-conditioned workload expansion module that scales the number of tasks with $N$ while preserving task diversity and executability. The module is explicitly constrained to generate only workload and does not encode or bias any coordination structure. All coordination events (delegation, revision, contradiction, merge, and total cognitive effort) are extracted solely from the realized interaction traces during execution. <details> <summary>2604.02674v1/x13.png Details</summary>  ### Visual Description ## Line Graph and Bar Chart: Active-Agent Fraction and Agents per Subtask Across Agent Society Sizes ### Overview The image contains two charts analyzing the relationship between agent society size (N) and two metrics: (a) the active-agent fraction (A(N)) and (b) agents per subtask. Both charts use agent society sizes (N = 8, 16, 32, 64, 128, 256, 512) on the x-axis and distinct metrics on the y-axis. Four task categories (QA, Reasoning, Coding, Planning) are compared using color-coded lines (a) and bars (b). --- ### Components/Axes #### Chart (a): Line Graph - **X-axis**: "Agent society size N" (logarithmic scale: 8, 16, 32, 64, 128, 256, 512). - **Y-axis**: "Active-agent fraction A(N)" (percentage, 50%–100%). - **Legend**: - QA (blue, circles) - Reasoning (green, diamonds) - Coding (red, squares) - Planning (orange, triangles) - **Markers**: Each category uses distinct geometric shapes for data points. #### Chart (b): Bar Chart - **X-axis**: "Agent society size N" (same logarithmic scale as Chart (a)). - **Y-axis**: "Agents per subtask" (0–10, linear scale). - **Legend**: Same four categories as Chart (a), with color coding. --- ### Detailed Analysis #### Chart (a): Active-Agent Fraction Trends - **Planning (orange)**: Starts at ~99% (N=8) and declines to ~86% (N=512). Slope is consistently downward but flattens slightly at larger N. - **Coding (red)**: Begins at ~96% (N=8) and drops to ~84% (N=512). Steeper decline than Planning. - **Reasoning (green)**: Starts at ~94% (N=8) and falls to ~82% (N=512). Similar trend to Coding. - **QA (blue)**: Declines from ~95% (N=8) to ~80% (N=512). Most pronounced drop among all categories. #### Chart (b): Agents per Subtask Trends - **Planning (orange)**: Tallest bars across all N. Values increase from ~2 (N=8) to ~9.8 (N=512). - **Coding (red)**: Second tallest. Rises from ~2 (N=8) to ~8.8 (N=512). - **Reasoning (green)**: Third tallest. Grows from ~2 (N=8) to ~7.5 (N=512). - **QA (blue)**: Shortest bars. Increases from ~1.8 (N=8) to ~8.0 (N=512). --- ### Key Observations 1. **Active-Agent Fraction (Chart a)**: - All categories show a decline in active-agent fraction as N increases. - Planning maintains the highest active fraction throughout, suggesting it is the most robust task under scaling. - QA experiences the steepest decline, indicating sensitivity to larger society sizes. 2. **Agents per Subtask (Chart b)**: - All categories require more agents as N grows, with Planning demanding the most resources. - The gap between Planning and other categories widens at larger N (e.g., at N=512, Planning requires ~9.8 agents vs. QA’s ~8.0). --- ### Interpretation - **Scalability Trade-offs**: - Larger agent societies reduce the proportion of active agents across tasks, but Planning remains the most efficient, possibly due to its structured nature. - The bar chart implies that Planning’s effectiveness scales with society size, requiring exponentially more agents to maintain performance. This could reflect complex coordination needs. - **Task-Specific Dynamics**: - QA’s sharp decline in active fraction (Chart a) and moderate agent growth (Chart b) suggest it may rely on fewer but highly specialized agents. - Coding and Reasoning show intermediate trends, balancing resource use and scalability. - **Anomalies**: - No outliers detected; trends are consistent across all N values. - The logarithmic x-axis in both charts emphasizes exponential growth in society size, highlighting scalability challenges. --- ### Spatial Grounding & Verification - **Legend Placement**: Right-aligned in both charts, ensuring clear color-to-category mapping. - **Data Point Consistency**: - Chart (a): Orange (Planning) lines and markers align with the legend; no mismatches. - Chart (b): Bar colors match legend labels exactly. - **Trend Verification**: - Chart (a): All lines slope downward; Planning’s decline is the gentlest. - Chart (b): Bars increase monotonically with N for all categories. --- ### Conclusion The data demonstrates that Planning is the most scalable and resource-intensive task, maintaining higher active-agent fractions while requiring exponentially more agents in larger societies. QA, while initially efficient, becomes less viable as society size grows. These insights suggest task-specific optimization strategies for agent-based systems. </details> Figure 18: Workload-expansion validation across agent society size. (a) Active-agent fraction $A(N)$ for four task families remains high across scales, staying above 80% even at $N=512$ , indicating sustained participation. (b) Agents per subtask induced by the expansion rule, compared to the target scaling $N/\lceil N^0.65\rceil$ . The gradual increase from $∼$ 2 to $∼$ 9 agents per subtask shows that workload grows with $N$ without over-concentrating agents. Together, these results verify that the expansion module maintains balanced workload and broad agent utilization while not prescribing coordination structure. For each benchmark $b$ and task family $d$ , we sample $K=\min(5,|B(b,d)|)$ seed tasks defining a shared problem context. A generator LLM produces related tasks, which are filtered by a validator using criteria of same-world consistency, non-paraphrase, independent meaningfulness, executability, and additive informativeness. The number of expanded tasks per seed is $$ M=≤ft\lceil\frac{N}{K· A}\right\rceil, $$ with target $A=5$ agents per task, yielding a total workload of $K× M$ tasks. Tasks are connected via sparse, randomly sampled dependency edges, forming a shallow DAG independent of the communication topology. Figure 18 shows that this procedure maintains high agent utilization ( $>80\$ active at $N=512$ ) and balanced agents-per-subtask scaling, confirming that workload grows with $N$ without over-concentration. ## Appendix I Agent Configuration and Experimental Protocol All agents share a standardized configuration across all topologies, task families, scales, and seeds. No agent-level hyperparameters are tuned per condition, ensuring that observed differences arise solely from interaction structure and workload. ### I.1 Agent Configuration | Component | Configuration | | --- | --- | | Orchestration | LangGraph (uniform routing, state, and execution) | | Base prompt | Task, neighbors, structured history | | Topology addendum | Topology-specific routing behavior (chain, star, tree, hierarchical, mesh, reputation) | | Task addendum | Benchmark-specific instructions (QA, coding, planning, reasoning) | | Tool access | Restricted to benchmark-native tools | | Context budget | 4000-token window | | Completion budget | 1000 tokens | | Memory | No cross-run persistence; structured state only | | Seeds | 5 per configuration | Table 25: Standardized agent configuration used across all experiments. ### I.2 Benchmarks | Benchmark | Task type | Approx. tasks | Difficulty | | --- | --- | --- | --- | | GAIA | QA / multimodal reasoning | $∼$ 150 | Medium–Hard | | SWE-bench Verified | Code debugging / patching | $∼$ 235 | Hard | | REALM-Bench | Planning / constraint reasoning | $∼$ 14 | Hard | | MultiAgentBench | Coordination / interaction tasks | $∼$ 6 scenarios | Variable | Table 26: Benchmarks used for workload generation and evaluation. ### I.3 Prompt Structure Each agent prompt consists of three layers: (i) a shared base prompt, (ii) a topology-specific addendum, and (iii) a task-family-specific addendum. The base prompt is identical across all agents and does not prescribe any coordination strategy. #### Base prompt. You are an AI agent participating in a multi-agent reasoning system. Your goal is to contribute high-quality reasoning to solve the task. Core behaviors: - Think step by step before answering. - Identify and correct errors in other agents’ outputs when necessary. - Build on useful prior reasoning rather than repeating it. - Be concise but complete. Output format: Provide reasoning followed by a final answer labeled: ANSWER: <your answer> This prompt is intentionally minimal and strategy-agnostic. No explicit instructions for delegation, critique, or merging are included, ensuring that coordination patterns emerge from interaction rather than prompt design. #### Example topology addendum (reputation routing). You are agent {agent_id} in a reputation-routed network (step {step} of {max_steps}). You have consulted a set of peers selected by reputation. - Review consulted outputs critically. - Do not blindly trust high-reputation agents. - Revise your reasoning using useful information. - Prefer correction and synthesis over agreement. At intermediate steps, produce an improved claim. At the final step, synthesize the best answer. Topology-specific addenda define communication and routing behavior but do not impose specific coordination patterns. Task-specific addenda provide domain context (e.g., QA, coding, planning) while maintaining the same interaction structure. Overall, this design ensures that coordination dynamics arise from agent interaction under shared constraints, rather than from prompt engineering or task-specific scripting.