Governing Emergent Role Specialization: Stability Laws for Agentic Companies Under Constraint Density

1. Introduction

1.1 The Agentic Company

An agentic company is an organization in which a significant fraction of operational decisions are made by autonomous AI agents rather than human employees. Unlike traditional automation — which replaces specific, well-defined tasks with deterministic programs — agentic operation replaces open-ended judgment with learned policies. An agent in an agentic company does not follow a script; it observes its environment, updates its beliefs, selects actions based on expected utility, and adapts its strategy in response to outcomes. The critical distinction is that agents interact with each other. A procurement agent's decision to switch suppliers affects the logistics agent's routing optimization, which affects the finance agent's cash flow projection, which feeds back into the procurement agent's supplier evaluation. These interaction effects are not incidental — they are the defining characteristic of agentic companies and the source of both their power and their instability.

Traditional organizational theory addresses coordination through hierarchy, standardization, and formal communication channels. These mechanisms were designed for human cognitive constraints: bounded rationality (Simon, 1955), limited span of control (Urwick, 1956), and communication overhead that grows super-linearly with team size (Brooks, 1975). Agents face none of these constraints. An agent can maintain awareness of every other agent's state. It can process thousands of coordination signals per second. It can instantaneously adopt any role for which it has a trained policy. This flexibility is precisely what makes agentic companies unstable: without the natural friction of human cognition, organizational structure can change faster than it can be governed.

1.2 The Role Specialization Problem

In any multi-agent system, agents must decide what to do. When multiple task types exist — planning, execution, auditing, negotiation, research, communication — agents must allocate themselves across these roles. Centralized assignment (a scheduler assigns roles) is simple but brittle: it creates a single point of failure, cannot adapt to local conditions, and requires global knowledge that is expensive to maintain. Decentralized assignment (each agent chooses its own role based on local information) is robust and adaptive but introduces a coordination problem: how do agents converge on an efficient division of labor without oscillating, clustering, or fragmenting?

This is the role specialization problem, and it is the central challenge of agentic company design. We want agents to spontaneously differentiate into roles that collectively cover all necessary functions, allocate capacity proportionally to demand, and maintain this allocation in the presence of perturbations. We want this specialization to emerge from local agent interactions rather than global planning. And we want formal guarantees that the emergence process converges rather than oscillating or diverging.

1.3 Governance as a Control Input

The key insight of this paper is that governance is not merely an overhead imposed on the system from outside — it is a control input that shapes the dynamics of role specialization. Governance constraints reduce the action space available to each agent. An agent that is constrained by an approval requirement before changing roles will change roles less frequently. An agent that must provide evidence for its role choice will specialize in roles for which evidence is easy to generate. An agent operating under a budget constraint will gravitate toward cost-effective roles.

These effects are not side effects of governance — they are the mechanism by which governance produces order. The question is how much governance is needed. Too little governance (low constraint density D) leaves the influence propagation matrix unchecked, allowing cascading role changes that destabilize the organization. Too much governance (high D) suppresses the very flexibility that makes agentic companies valuable, freezing agents into suboptimal roles. In this paper we distinguish two thresholds: the exact contraction condition (1 − D)λ_max(A) < 1, which determines whether the linearized dynamic converges at all, and the buffered specialization envelope λ_max(A) < 1 − D, which is stricter but preserves operational headroom against model error, asynchronous updates, and transient coupling spikes.

1.4 Contributions

This paper makes five contributions: 1. Model Definition. We formalize the agentic company as a time-varying graph G_t = (V, E_t, S_t, Π_t, R_t, D_t) with a five-dimensional state vector and governance constraint density (Section 2). 2. Influence Propagation Analysis. We define the influence propagation matrix A_t and characterize the spectral properties that determine system stability (Section 3). 3. Two-Level Stability Criterion. We separate the exact contraction condition (1 − D_t)λ_max(A_t) < 1 from the buffered specialization envelope λ_max(A_t) < 1 − D_t, and derive a four-regime phase diagram spanning Stagnation, Buffered Specialization, Fragile Specialization, and Cascade (Sections 5–6). 4. Multi-Layer Extension. We extend the framework to agentic companies operating within civilization-level governance layers, deriving effective constraint density and distinguishing pure contraction from buffered operation (Section 8). 5. Empirical Validation. We validate the buffered operating boundary on the MARIA OS Planet-100 simulation with 111 agents and 10 role types, achieving 96.8% classification accuracy (Section 10).

2. Model Definition

2.1 The Agentic Company Graph

Definition 1 (Agentic Company). An agentic company at time t is a tuple: G_t = (V, E_t, S_t, Π_t, R_t, D_t) where: - V = {v_1, v_2, ..., v_N} is the set of N agents (fixed population). - E_t ⊆ V × V is the set of directed influence edges at time t. An edge (v_i, v_j) ∈ E_t indicates that agent v_i has a non-zero influence on agent v_j's role choice at time t. - S_t: V → ℝ^5 assigns each agent a five-dimensional state vector. - Π_t: V → Δ(Actions) assigns each agent a probability distribution over available actions (its policy). - R_t: V × Actions → ℝ is the reward function mapping agent-action pairs to scalar rewards. - D_t ∈ [0, 1] is the governance constraint density.

2.2 The State Vector

Each agent v_i has a state vector S_t(v_i) = [F_t, K_t, H_t, L_t, C_t] with five components: | Component | Symbol | Description | Range | |-----------|--------|-------------|-------| | Financial Capital | F_t | Budget, revenue capacity, resource allocation | [0, ∞) | | Knowledge Capital | K_t | Accumulated expertise, trained skills, model quality | [0, 1] | | Health Capital | H_t | Operational reliability, uptime, error rate inverse | [0, 1] | | Legitimacy Capital | L_t | Trust score from governance, audit pass rate | [0, 1] | | Coordination Capital | C_t | Network position value, influence centrality | [0, 1] | The state vector evolves according to: S_{t+1}(v_i) = f(S_t(v_i), π_t(v_i), R_t(v_i), D_t, {S_t(v_j) : (v_j, v_i) ∈ E_t}) where f is the state transition function. The dependence on neighbors' states {S_t(v_j)} is the mechanism through which influence propagates. The dependence on D_t is the mechanism through which governance shapes dynamics.

2.3 Governance Constraint Density

Definition 2 (Governance Constraint Density). The governance constraint density at time t is: D_t = |Constraints_t| / |ActionSpace_t| where |Constraints_t| is the number of active constraints (approval gates, evidence requirements, budget limits, role-change cooldowns, audit triggers) and |ActionSpace_t| is the total number of available actions across all agents. Intuitively, D_t measures the fraction of the action space that is restricted by governance. When D_t = 0, agents face no constraints and can take any action at any time. When D_t = 1, every action requires approval and the system is fully locked. In practice, operational agentic companies operate in the range D_t ∈ [0.15, 0.70]. The constraint density is not merely a count of rules. It accounts for the interaction between constraints and the action space. Adding a constraint that restricts an action no agent would take does not increase D_t. Removing an action that was already constrained does not decrease D_t. The density is a genuine ratio that reflects the effective governance burden on agent behavior.

2.4 Role Space and Assignment

Definition 3 (Role Space). The role space ℛ = {r_1, r_2, ..., r_M} is a finite set of M functional roles. Each role r_k is characterized by a task distribution, a skill requirement vector, and a reward profile. A role assignment at time t is a function ρ_t: V → ℛ mapping each agent to a role. The aggregate role distribution is the vector ρ̂_t ∈ Δ^M where ρ̂_t(k) = |{v_i : ρ_t(v_i) = r_k}| / N is the fraction of agents assigned to role r_k. An important modeling choice is that agents can change roles at each time step, subject to governance constraints. A role-change cooldown constraint, for example, prevents an agent from switching roles more than once every τ steps. This is a governance mechanism that directly reduces the effective action space for agents who have recently switched roles, thereby increasing D_t locally.

2.5 The Markov Decision Process Formulation

From each agent's perspective, the agentic company is a partially observable Markov decision process (POMDP). Agent v_i at time t observes a local state o_t(v_i) comprising its own state S_t(v_i), the states of its neighbors {S_t(v_j) : (v_j, v_i) ∈ E_t}, and the current governance parameters D_t. Based on this observation, it selects a role r_i(t+1) and an action within that role. The reward R_t(v_i, a) depends on the agent's action, the actions of other agents (through task completion and coordination effects), and the governance context. The key challenge is that the MDP is non-stationary: the transition dynamics change as other agents change their roles. Agent v_i's optimal policy depends on the policies of all other agents, which depend on v_i's policy — a classic Nash equilibrium problem. Our stability analysis addresses whether the system of coupled MDPs converges to a fixed point (stable specialization) or cycles indefinitely (chaos).

3. Influence Propagation

3.1 The Influence Matrix

Definition 4 (Influence Matrix). The influence propagation matrix A_t ∈ ℝ^{N×N} is defined as: A_t[i, j] = ∂U_j(r_j | ρ_t) / ∂ρ_t(v_i) where U_j(r_j | ρ_t) is agent v_j's utility for its current role r_j given the current role assignment ρ_t, and the partial derivative measures how a marginal change in agent v_i's role choice affects agent v_j's utility. Intuitively, A_t[i, j] measures how much agent v_i's role change would perturb agent v_j's incentives. Large positive values indicate strong complementarity (if v_i changes to a role that makes v_j's current role more valuable). Large negative values indicate substitution effects (if v_i changes to the same role as v_j, reducing v_j's utility through competition). The diagonal is zero by convention: A_t[i, i] = 0.

The influence matrix captures three types of inter-agent effects: 1. Task complementarity. If agent v_i specializes in planning and agent v_j specializes in execution, v_i's planning output feeds v_j's execution pipeline. Changes in v_i's role disrupt this pipeline, creating a positive off-diagonal entry. 2. Resource competition. If v_i and v_j both specialize in the same role, they compete for the same task pool. Each additional agent in a role reduces the marginal return, creating negative entries. 3. Information effects. Agent v_i's role choice signals information about the state of the environment (e.g., if v_i switches to an auditing role, it may signal that error rates are high). This information affects v_j's utility estimates even if there is no direct task or resource interaction.

3.2 Spectral Radius and Propagation Dynamics

Definition 5 (Spectral Radius). The spectral radius of A_t is: λ_max(A_t) = max{|λ| : λ ∈ spectrum(A_t)} where spectrum(A_t) is the set of eigenvalues of A_t. The spectral radius controls how influence perturbations propagate through the network. Consider a perturbation δρ_0 to the role assignment at time t = 0. After one round of best-response updates, the perturbation to agent utilities is approximately A_t · δρ_0. After k rounds, the cumulative perturbation is: δU_k ≈ A_t^k · δρ_0 The norm of this perturbation grows as ||δU_k|| ≤ ||A_t||^k · ||δρ_0||. For large k, this is dominated by the spectral radius: ||δU_k|| ∼ λ_max(A_t)^k · ||δρ_0|| If λ_max(A_t) < 1, perturbations decay exponentially: each round of best-response updates shrinks the displacement, and the system converges to a fixed point. If λ_max(A_t) > 1, perturbations grow exponentially: each round amplifies the displacement, and the system diverges. If λ_max(A_t) = 1, the system is marginally stable and requires higher-order analysis.

3.3 Governance Damping

Governance constraints act as a damping mechanism on influence propagation. When an agent faces an approval requirement before changing roles, the effective influence on that agent is reduced because the agent cannot immediately respond to the incentive change — it must wait for approval, during which time the incentive may have shifted again. When an agent must provide evidence for its role choice, the agent is less responsive to transient fluctuations in the utility landscape because evidence collection introduces a smoothing delay. Formally, governance with constraint density D_t reduces the effective influence matrix to: A_t^{eff} = (1 − D_t) · A_t The factor (1 − D_t) uniformly scales all influence strengths. This is a first-order approximation; in practice, different constraints affect different agents and different influence channels asymmetrically. The uniform scaling captures the aggregate effect: a fraction D_t of the action space is constrained, so a fraction D_t of influence-induced role changes are blocked. The effective spectral radius is: λ_max(A_t^{eff}) = (1 − D_t) · λ_max(A_t) The exact first-order contraction condition is therefore: (1 − D_t) · λ_max(A_t) < 1 which is equivalent to: λ_max(A_t) < 1 / (1 − D_t) This is the mathematically correct local stability condition for the linearized system. But enterprise architects usually need something stricter than bare contraction. A system with loop gain 0.99 is technically stable and still operationally brittle: convergence is slow, estimation error can flip the sign, and bursty or asynchronous updates can push the organization into oscillation. For that reason we define the Buffered Specialization Law: λ_max(A_t) < 1 − D_t Because 1 − D_t < 1 / (1 − D_t) for D_t ∈ (0, 1), this law is conservative. It guarantees contraction and preserves adaptation headroom, creating a region where specialization is not merely stable in theory but robust in operation.

4. Role Specialization Dynamics

4.1 The Role Selection Rule

Each agent selects its role at each time step according to a utility-maximizing rule: Definition 6 (Role Selection). Agent v_i at time t selects: r_i(t+1) = argmax_r U_i(r | C_task, B_comm, D_t) where U_i is the role utility function, C_task is the current task context (available tasks, deadlines, priorities), B_comm is the communication bandwidth available to v_i, and D_t is the governance constraint density. This selection rule is myopic: the agent maximizes immediate utility without planning ahead. This is a deliberate simplification. In practice, agents may use multi-step lookahead (reinforcement learning policies), but the stability analysis applies to the best-response dynamics of the myopic rule, which forms the foundation for more sophisticated policies. If the myopic dynamics are unstable, no amount of lookahead can stabilize them without changing the influence structure itself.

4.2 The Utility Function

The role utility function decomposes into three components: U_i(r) = α · Eff_i(r) + β · Impact_i(r) − γ · Cost_i(r, D_t) where α, β, γ > 0 are weighting parameters with α + β + γ = 1. Efficiency `Eff_i(r)`. This measures how well agent v_i's capabilities match role r's requirements. It is a function of the agent's knowledge capital K_t(v_i) and the skill profile of role r: Eff_i(r) = 1 − ||K_t(v_i) − K_req(r)||_2 / ||K_req(r)||_2 where K_req(r) is the required skill vector for role r. An agent whose knowledge profile exactly matches the role requirements achieves Eff = 1. An agent with no relevant skills achieves Eff ≤ 0. Impact `Impact_i(r)`. This measures the marginal contribution of agent v_i in role r to the overall organizational output. It depends on the current role distribution: if many agents are already in role r, the marginal impact of one more is low (diminishing returns). If no agents are in role r and there is demand for it, the marginal impact is high: Impact_i(r) = Demand(r) / (1 + n_r) where Demand(r) is the current task demand for role r and n_r is the number of agents currently in role r. This creates a natural load-balancing effect: excess agents in one role are drawn toward under-served roles. Cost `Cost_i(r, D_t)`. This measures the governance burden of agent v_i operating in role r under constraint density D_t. Higher constraint density increases the cost of every role because more actions require approval, evidence, or waiting: Cost_i(r, D_t) = D_t · (1 + SwitchCost(r, ρ_t(v_i))) where SwitchCost(r, ρ_t(v_i)) is the cost of switching from the current role ρ_t(v_i) to role r. This is zero if the agent is already in role r and positive otherwise, reflecting the governance overhead of role transitions (approval delays, re-certification, evidence requirements). The cost term creates a stickiness effect: under high D_t, agents are reluctant to change roles because the governance cost of switching is high. This is the direct mechanism through which governance damping operates at the agent level.

4.3 Best-Response Dynamics

The system of N agents simultaneously applying the role selection rule defines a best-response dynamic. At each time step, every agent computes its utility for every role and switches to the best one (subject to governance constraints). The question is whether this dynamic converges. Let ρ_t ∈ ℛ^N be the role assignment vector at time t. The best-response map is: BR(ρ_t) = (argmax_r U_1(r | ρ_t, D_t), ..., argmax_r U_N(r | ρ_t, D_t)) A stable role assignment is a fixed point of BR: a role vector ρ* such that BR(ρ*) = ρ*. At a fixed point, no agent has an incentive to change its role given the roles of all other agents. This is precisely a Nash equilibrium of the role selection game. The existence of a fixed point is guaranteed by Brouwer's theorem when we extend to mixed strategies (probability distributions over roles). The question is whether the best-response dynamic converges to this fixed point from arbitrary initial conditions. This is where the spectral radius condition enters.

4.4 Linearized Dynamics Near Equilibrium

Near a fixed point ρ*, the best-response dynamic can be linearized. Let δρ_t = ρ_t − ρ* be the deviation from equilibrium. The linearized update is: δρ_{t+1} = J(BR) · δρ_t where J(BR) is the Jacobian of the best-response map at ρ*. The Jacobian captures how a small change in the role assignment propagates through the best-response updates of all agents. The matrix J(BR) is directly related to the influence matrix A_t through the utility function: J(BR)[i, j] = ∂(argmax_r U_i(r | ρ))[j] / ∂ρ_j Under the smooth utility approximation (where the argmax is replaced by a softmax to avoid discontinuities), the Jacobian is proportional to the effective influence matrix: J(BR) ≈ (1 − D_t) · A_t The linearized dynamic converges if and only if all eigenvalues of J(BR) have modulus less than 1, which requires (1 − D_t) · λ_max(A_t) < 1. The buffered specialization condition λ_max(A_t) < 1 − D_t identifies the subset of that stable region with explicit governance reserve against perturbations in D_t, estimation error in A_t, and asynchronous update jitter.

5. The Stability Law

5.1 Main Theorem

Theorem 1 (Exact Local Stability Law). Let G_t = (V, E_t, S_t, Π_t, R_t, D_t) be an agentic company with N agents, M roles, influence matrix A_t, and governance constraint density D_t ∈ (0, 1). Under Assumptions A1–A4 (stated below), the linearized best-response dynamic converges locally to a stable role assignment ρ* if and only if: (1 − D_t) · λ_max(A_t) < 1 Moreover, when the condition holds, convergence is exponential with rate r = 1 − (1 − D_t) · λ_max(A_t), and the number of steps to reach an ε-neighborhood of ρ* is at most: T(ε) = ⌈log(||δρ_0|| / ε) / (-log((1 − D_t) · λ_max(A_t)))⌉

Assumptions: - A1 (Smooth Utilities). The utility function U_i(r | ρ, D) is twice continuously differentiable in the role distribution ρ for all i, r, and D. - A2 (Bounded Influence). The influence matrix satisfies ||A_t||_F ≤ B for some finite bound B independent of t, where ||.||_F is the Frobenius norm. - A3 (Non-Degenerate Governance). The constraint density satisfies 0 < D_t < 1 for all t. No system is completely ungoverned or completely frozen. - A4 (Synchronous Updates). All agents update their role choices simultaneously at each time step. Asynchronous variants are discussed in Section 7.

5.2 Proof Sketch

Necessity (`(1 − D)λ_max ≥ 1` implies non-contraction). Suppose (1 − D_t) · λ_max(A_t) ≥ 1. Then there exists an eigenvector ξ of A_t with eigenvalue λ such that |(1 − D_t) · λ| ≥ 1. Consider a perturbation δρ_0 = εξ for small ε > 0. The linearized update gives: δρ_1 = (1 − D_t) · A_t · εξ = (1 − D_t) · λ · εξ The perturbation does not shrink in this eigen-direction, so the linearized map cannot be contractive. If the modulus is strictly larger than 1, perturbations grow exponentially and the equilibrium is locally unstable. Sufficiency (`(1 − D)λ_max < 1` implies convergence). Suppose (1 − D_t) · λ_max(A_t) < 1. Then the effective spectral radius of the Jacobian satisfies: ρ(J(BR)) = (1 − D_t) · λ_max(A_t) < 1 By the contraction mapping theorem, the best-response map BR is a contraction on a neighborhood of ρ* with rate (1 − D_t) · λ_max(A_t). The Banach fixed-point theorem guarantees local existence, uniqueness, and exponential convergence of the iterates ρ_t = BR^t(ρ_0) to ρ*. The stronger buffered specialization condition λ_max(A_t) < 1 − D_t is not the exact necessity threshold; it is a conservative design corollary. It carves out the portion of the stable region where governance retains explicit reserve against finite-sample uncertainty and operational perturbations.

5.3 Intuition

Two scalar quantities matter in practice: - Loop gain g = (1 − D) · λ_max(A). This is the exact contraction diagnostic. If g < 1, perturbations decay. If g ≥ 1, perturbations persist or grow. - Buffer margin δ_buffer = 1 − D − λ_max(A). This is the conservative operating reserve. If δ_buffer > 0, the organization is not just contractive but comfortably inside the buffered specialization envelope. These quantities resolve a common confusion. More governance always reduces the loop gain because it damps influence. But more governance also reduces freedom, and therefore shrinks the buffer available for productive adaptation. A company can be mathematically stable (g < 1) and still operationally brittle (δ_buffer ≈ 0). The buffered law is therefore a governance design rule, not merely a mathematical curiosity.

6. Phase Diagram

6.1 The Four Regimes

The combined exact and buffered laws partition the (λ_max, D) parameter space into four practically distinct regimes: Phase I: Stagnation (D > D_stag, typically D_stag ≈ 0.7) In this phase, governance constraint density is so high that agents cannot effectively adapt their roles. The cost term γ · Cost(r, D_t) dominates, making role switching prohibitively expensive. The system may be extremely stable in the contraction sense, but it is not organizationally healthy. Observable metrics in the Stagnation phase: - Role change frequency ≈ 0 - Task completion rate declining under demand shift - Governance overhead ratio > 60% - Innovation rate ≈ 0 Phase II: Buffered Specialization (λ_max < 1 − D, with D < D_stag) This is the desired operating regime. Agents have enough freedom to adapt, the loop gain is comfortably below 1, and the organization retains explicit governance reserve. Perturbations are damped quickly, and specialization patterns remain legible under moderate shocks. Observable metrics in the Buffered Specialization phase: - Role distribution converges within 80–200 steps - Task completion rate > 90% - Role entropy stabilizes at an intermediate value - Perturbation recovery time remains bounded and predictable Phase III: Fragile Specialization (1 − D ≤ λ_max < 1 / (1 − D), with D < D_stag) Here the organization is still locally contractive, but only barely. It converges under the nominal model, yet small topology changes, delayed approvals, or asynchronous bursts can trigger long oscillation tails. This is the regime that often looks healthy in a dashboard until a mild stress event exposes the missing buffer. Observable metrics in the Fragile Specialization phase: - Convergence occurs but only after long settling times - Recovery time is highly variable across trials - Role entropy overshoots before settling - Alert frequency rises even though the system eventually reconverges Phase IV: Cascade ((1 − D)λ_max ≥ 1) In this phase, influence propagation dominates governance damping. When one agent changes roles, the utility perturbation propagates through the network, causing multiple other agents to change roles, which generates further perturbations, creating a cascade that does not contract. Observable metrics in the Cascade phase: - Role assignment entropy approaches its maximum - Task completion rate < 40% - Influence cascade length is effectively unbounded - Coordination capital C_t collapses toward zero

6.2 Phase Boundaries

Two boundaries matter: - The buffered operating boundary is the straight line λ_max = 1 − D. Points below this line lie in Buffered Specialization. - The exact contraction boundary is the hyperbola λ_max = 1 / (1 − D). Crossing this boundary moves the system from Fragile Specialization into Cascade. The boundary between Buffered Specialization and Stagnation is less sharp. We define the stagnation threshold as the constraint density D_stag beyond which the expected role change rate drops below one change per 1,000 agent-steps. Empirically, D_stag ≈ 0.70 for the utility function parameters used in our experiments, but this threshold depends on the specific values of α, β, γ and the switch-cost function. | Phase | Region | Behavior | Convergence | |-------|--------|----------|-------------| | Stagnation | D > D_stag | Frozen roles | Trivial | | Buffered Specialization | λ_max < 1 − D, D < D_stag | Robust convergent specialization | Exponential with healthy reserve | | Fragile Specialization | 1 − D ≤ λ_max < 1 / (1 − D), D < D_stag | Convergent but brittle | Slow / variance-sensitive | | Cascade | (1 − D)λ_max ≥ 1 | Oscillatory or divergent | None | The phase diagram reveals a fundamental trade-off. Increasing governance lowers loop gain and therefore helps contraction, but it also shrinks the operating buffer and can eventually push the organization into Stagnation. The practical optimum lies in the buffered region with D in the range [0.30, 0.55] — enough structure to prevent cascades, enough freedom to preserve adaptive specialization.

6.3 Critical Behavior

Two kinds of critical slowing matter: - Near the exact contraction boundary, the loop gain approaches unity and convergence time scales as: T(ε) ∼ 1 / (1 - (1 − D)λ_max) as ((1 − D)λ_max) → 1^- - Near the buffered boundary, the buffer margin vanishes and operational variance rises as: Var(Δρ) ∼ 1 / (1 − D − λ_max)^2 The first quantity captures mathematical loss of contraction; the second captures practical loss of governance reserve. In networks with structured topology (e.g., the MARIA coordinate hierarchy), the exponents may differ, but the distinction between exact stability and buffered operation remains essential.

7. Convergence Analysis

7.1 Main Convergence Result

Theorem 2 (Exponential Convergence). Under the exact stability condition (1 − D_t) · λ_max(A_t) < 1, the expected state deviation converges exponentially: lim_{t → ∞} E[||S_{t+1} − S_t||] = 0 Moreover, the convergence rate is: E[||S_{t+1} − S_t||] ≤ c_0 · ((1 − D) · λ_max)^t where c_0 = ||S_1 − S_0|| is the initial state change magnitude. Proof. The state vector S_t(v_i) evolves according to the transition function f defined in Section 2.2. Near the fixed point S*, the linearized dynamics are governed by the Jacobian: δS_{t+1} = J_f · δS_t where J_f is the Jacobian of the state transition function with respect to the state vector. The key observation is that J_f decomposes as: J_f = J_self + (1 − D_t) · J_influence where J_self captures each agent's intrinsic state dynamics (bounded below 1 for any stable agent) and J_influence captures the inter-agent influence terms mediated by A_t. When the combined loop gain remains below 1, the linearized operator is a contraction and the deviation norm decays geometrically. Exponential convergence follows from the submultiplicativity of the operator norm under iteration.

7.2 Necessary Conditions for Convergence

The convergence result requires four necessary conditions: 1. Individual Agent Stability. Each agent, considered in isolation (with fixed neighbor states), must converge to a stable state. This excludes agents with internally chaotic dynamics (e.g., oscillating reward estimates due to non-stationary exploration policies). Formally: ρ(J_self(v_i)) < 1 for all v_i. 2. Bounded Influence. The influence matrix must have bounded spectral radius. This is guaranteed by Assumption A2 (bounded Frobenius norm) and is satisfied in practice for any finite network with finite utility gradients. 3. Non-Zero Governance. The constraint density must be strictly positive: D_t > 0. A completely ungoverned system (D = 0) has stability condition λ_max < 1, which is generically violated in densely connected networks. Some governance is always necessary for stability in multi-agent systems. 4. Consistent Constraints. Governance constraints must be consistent: they must not create cycles where an agent is forced to change roles to satisfy one constraint and then forced to change back to satisfy another. Consistent constraints can be verified by checking that the constraint graph is acyclic.

7.3 Asynchronous Updates

Theorem 1 assumes synchronous updates (Assumption A4). In practice, agents may update asynchronously — each agent updates at its own rate, possibly triggered by events rather than a global clock. Proposition 1 (Asynchronous Stability). If the exact stability condition (1 − D_t) · λ_max(A_t) < 1 holds, then the best-response dynamic converges under any asynchronous update schedule in which every agent updates infinitely often. Proof sketch. Under asynchronous updates, the effective update operator at each step affects only a subset of agents. The spectral radius of any principal submatrix of A_t is at most λ_max(A_t) (eigenvalue interlacing). Therefore, each partial update remains contractive when the global loop gain is below 1, and the composition of contractions is itself a contraction. Convergence follows from the standard theory of asynchronous iterations on paracontracting operators. The practical implication is that the exact gain condition governs mathematical convergence regardless of update ordering, while the buffered envelope remains the recommended target for robust production operation.

7.4 Convergence Speed

The convergence speed is controlled by the effective loop gain λ_{eff} = (1 − D) · λ_max. Faster convergence requires either: 1. Lower `λ_max` — weaker inter-agent influence (sparser network, weaker complementarities) 2. Higher `D` — stronger governance damping (more constraints, slower role changes) Option 1 is a design choice (network topology, utility design). Option 2 is a governance choice. The trade-off is that faster contraction via higher D comes at the cost of reduced adaptivity and, beyond a point, stagnation. In the Planet-100 experiments (Section 10), convergence to within ε = 0.01 of the buffered specialization distribution required 80–200 steps in the buffered regime. Systems in the fragile regime also converged, but with much higher variance and much longer settling times.

8. Civilization Extension: Multi-Layer Stability

8.1 Governance Layers

An agentic company does not operate in isolation. It exists within regulatory frameworks, industry standards, market conditions, and — in the MARIA OS context — potentially within a civilization simulation that imposes its own governance constraints. These external layers add additional constraint density that must be accounted for in the stability analysis. Consider a two-layer system: an agentic company with internal governance density D_company operating within a civilization (or regulatory environment) with external governance density D_civ. The company-level constraints restrict the actions of individual agents (approval gates, evidence requirements, role-change cooldowns). The civilization-level constraints restrict the actions of the company as a whole (regulatory compliance, market rules, treaty obligations).

8.2 Effective Constraint Density

Definition 7 (Effective Constraint Density). For a two-layer governance system with company-level density D_company and civilization-level density D_civ, the effective constraint density is: D_eff = 1 − (1 − D_company)(1 − D_civ) Expanding: D_eff = D_company + D_civ − D_company · D_civ This formula has an intuitive interpretation. The freedom of an agent is the fraction of its action space that is unconstrained. Company-level governance leaves a fraction (1 − D_company) unconstrained. Civilization-level governance further constrains a fraction D_civ of the remaining freedom. The residual freedom is (1 − D_company)(1 − D_civ), so the effective density is 1 − (1 − D_company)(1 − D_civ). Note that D_eff > max(D_company, D_civ) whenever both are non-zero: multiple governance layers always increase effective constraint density. This has important implications for multi-layer stability.

8.3 Multi-Layer Stability Law

Theorem 3 (Multi-Layer Exact Stability). For a two-layer governance system, the exact contraction condition becomes: (1 − D_company)(1 − D_civ) · λ_max(A_t) < 1 Equivalently: λ_max(A_t) < 1 / (1 − D_eff) Adding a civilization layer with D_civ = 0.2 to a company with D_company = 0.3 gives D_eff = 0.44, so the exact contraction condition becomes λ_max < 1 / 0.56 ≈ 1.79. Corollary 1 (Buffered Multi-Layer Operation). The conservative buffered envelope becomes: λ_max(A_t) < 1 − D_eff = (1 − D_company)(1 − D_civ) This is the recommended production condition for robust specialization across layers. Corollary 2. Additional governance layers reduce the buffered operating region even while they improve pure damping. In other words, layered regulation can make contraction easier but still push the organization toward stagnation by exhausting adaptation headroom. Corollary 3. There exists a maximum number of governance layers L_max beyond which buffered specialization is no longer possible for a given λ_max: L_max = ⌈log(λ_max) / log(1 − D_avg)⌉ where D_avg is the average constraint density across layers. For typical values (λ_max = 0.7, D_avg = 0.2), this gives L_max ≈ 3 layers before the system exits the buffered region even though exact contraction may still hold.

8.4 Civilization Simulation Mapping

In the MARIA OS Civilization simulation (Section 10), nations correspond to agentic companies, and the civilization-level governance includes: - Market rules (free market land economy, trading constraints) - Election cycles (political transitions that reset governance parameters) - Treaty obligations (inter-nation constraints on resource allocation) - LOGOS AI advisor recommendations (soft constraints that influence but do not mandate policy) Each of these contributes to D_civ. The effective constraint density for a nation is: D_eff(nation) = 1 − (1 − D_internal)(1 − D_market)(1 − D_political)(1 − D_treaty)(1 − D_LOGOS) where each sub-density captures a different governance channel. This decomposition allows the Civilization simulation to model how different governance structures (authoritarian vs. democratic, regulated vs. free-market) produce different effective constraint densities and therefore different stability properties.

9. MARIA OS Implementation

9.1 Architecture Mapping

The stability framework maps directly onto the MARIA OS architecture. The MARIA coordinate system G.U.P.Z.A (Galaxy, Universe, Planet, Zone, Agent) provides the graph structure G_t = (V, E_t). The influence edges E_t correspond to the communication and dependency links between agents within and across zones. The governance constraint density D_t is computed from the active gate configurations, approval policies, and evidence requirements at each hierarchical level. The mapping is hierarchical. Each level in the coordinate system contributes to the effective constraint density: ``yaml # MARIA OS Constraint Density Configuration galaxy: D_tenant: 0.10 # Enterprise-wide policies constraints: - global_compliance_standards - tenant_budget_limits - cross_universe_approval_gates universe: D_business_unit: 0.12 # Business unit policies constraints: - unit_spending_authority - role_assignment_policies - inter_planet_coordination_rules planet: D_domain: 0.15 # Domain-specific governance constraints: - domain_expertise_requirements - quality_gate_thresholds - audit_frequency_policies zone: D_ops: 0.08 # Operational constraints constraints: - task_priority_rules - resource_allocation_caps - agent_cooldown_periods agent: D_individual: 0.05 # Per-agent constraints constraints: - role_change_cooldown - evidence_requirements - escalation_triggers # Effective constraint density for agent at G1.U2.P3.Z1.A4: # D_eff = 1 - (1-0.10)(1-0.12)(1-0.15)(1-0.08)(1-0.05) = 0.41 # Exact loop gain check: g = D_free * lambda_max(A_t)

9.2 Gate Engine as Governance Density Controller

The MARIA OS Gate Engine (implemented in lib/engine/decision-pipeline.ts and lib/engine/responsibility-gates.ts) is the primary mechanism for controlling governance constraint density. Each gate type contributes to D_t: - Approval Gates increase D by restricting actions that require human sign-off. The number of active approval gates divided by total action count directly contributes to D_t. - Evidence Gates increase D by requiring agents to collect and present evidence before acting. Each evidence requirement adds a constraint to the action space. - Budget Gates increase D by capping the financial resources available for role changes and task execution. - Cooldown Gates increase D by imposing temporal constraints on how frequently agents can change roles. The gate engine provides real-time monitoring of D_t across all organizational levels, enabling administrators to tune governance intensity to maintain the stability condition. When λ_max is estimated to be rising (e.g., due to increased network connectivity or stronger complementarities), D_t can be increased by activating additional gates. When D_t is too high (risk of Stagnation), gates can be relaxed. This is the core operational insight: governance gates are not bureaucratic checkpoints — they are control inputs in a dynamical system. Tuning gate parameters is equivalent to choosing the damping coefficient in a control loop.

9.3 Evidence Layer as Influence Damper

The MARIA OS evidence layer (implemented in lib/engine/evidence.ts) serves a dual purpose in the stability framework. First, it provides the audit trail required for accountability. Second, it acts as an influence damper by introducing delay between an agent's decision to change roles and the execution of that change. When an agent decides to switch roles, the evidence requirement forces it to: 1. Collect evidence supporting the switch (task demand data, capability match scores, coordination impact estimates) 2. Bundle the evidence into an evidence package 3. Submit the package for review (automated or human) 4. Wait for approval before executing the switch This delay prevents agents from responding instantaneously to utility perturbations. The smoothing effect is analogous to a low-pass filter: high-frequency role oscillations are filtered out because the evidence collection process takes longer than the oscillation period. Only sustained, genuine shifts in utility survive the evidence filter and produce actual role changes.

9.4 Anomaly Detection: Stability Monitoring

MARIA OS implements real-time stability monitoring through the analytics engine (lib/engine/analytics.ts). The key metrics tracked are: 1. Spectral Radius Estimate. The influence matrix A_t is estimated from observed agent interactions (role changes, utility perturbations). The spectral radius is computed at regular intervals using power iteration on the empirical influence matrix. 2. Constraint Density Measurement. D_t is computed from the active gate configuration and the current action space size. 3. Loop Gain. The exact stability diagnostic g_t = (1 − D_t) · λ_max(A_t) is tracked in real time. When g_t approaches 1, the system is nearing loss of contraction. 4. Buffer Margin. The conservative operating reserve δ_buffer = 1 − D_t − λ_max(A_t) is tracked in parallel. When δ_buffer approaches zero, the organization is entering the fragile regime even if contraction still holds. 5. Role Change Frequency. A sudden increase in role change frequency is an early indicator of approaching the cascade boundary. 6. Perturbation Recovery Time. The time for the system to return to steady state after a perturbation is measured. Increasing recovery time indicates critical slowing down near the boundary. When either g_t > 0.95 or δ_buffer < 0.10, the anomaly detection system triggers an alert and can activate additional governance gates to increase D_t. This creates a self-stabilizing feedback loop: instability triggers governance, governance restores contraction and, where possible, rebuilds operating buffer.

9.5 Universe Dashboard Integration

The stability metrics are surfaced in the MARIA OS Universe Dashboard through the dashboard data provider (lib/contexts/dashboard-data-context.tsx). Each Universe view includes: - Loop-Gain Gauge: A real-time display of g_t = (1 − D_t)λ_max(A_t), color-coded green (safe), amber (warning), red (critical). - Buffer Gauge: A display of δ_buffer = 1 − D_t − λ_max(A_t), showing whether the organization is buffered or fragile. - Phase Indicator: Current operating phase (Stagnation / Buffered Specialization / Fragile Specialization / Cascade) based on the (λ_max, D) coordinates. - Convergence Timer: Estimated steps to steady-state role distribution, computed from T(ε) = log(||δρ_0|| / ε) / (-log(λ_{eff})). - Role Distribution Chart: Real-time histogram of agent-to-role assignments, showing convergence toward the equilibrium distribution. - Influence Heatmap: Visualization of the N × N influence matrix A_t, highlighting the dominant eigenvector (the direction of maximum instability).

10. Planet-100 Experiments

10.1 Experimental Setup

We validate the stability law using the MARIA OS Planet-100 simulation environment (app/experimental/planet-100/). Planet-100 simulates a self-organizing society of autonomous agents, providing a controlled testbed for studying emergent role specialization. Configuration: | Parameter | Value | |-----------|-------| | Agent Count (N) | 111 | | Role Types (M) | 10 (Planner, Executor, Auditor, Negotiator, Researcher, Communicator, Analyst, Guardian, Optimizer, Coordinator) | | Simulation Steps | 1,000 per trial | | Trials per Configuration | 50 | | Utility Weights | α = 0.4, β = 0.35, γ = 0.25 | | Influence Topology | Scale-free (preferential attachment, m = 3) | | PRNG | Deterministic seeded (mulberry32) for reproducibility | The 111 agents correspond to the Planet-100 population (100 primary agents plus 11 governance observers). The 10 role types represent the functional roles identified in the MARIA OS agent taxonomy. The scale-free topology produces a power-law degree distribution, which is representative of real organizational networks where some agents (hubs) have disproportionate influence.

10.2 Parameter Sweeps

We conduct two parameter sweeps: Sweep 1: Constraint Density `D` ∈ [0.05, 0.90] at fixed topology. The influence matrix A_t is fixed (same topology for all trials), and D is varied in increments of 0.05. For each value of D, we run 50 trials with random initial role assignments and measure: - Whether the role distribution converges (defined as ||S_{t+1} − S_t|| < 0.01 for 20 consecutive steps) - The convergence time (number of steps to reach the convergence criterion) - The final role entropy H(ρ̂) = −Σ_k ρ̂(k) · log(ρ̂(k)) - The task completion rate at steady state Sweep 2: Spectral Radius `λ_max` ∈ [0.2, 1.5] at fixed `D`. The constraint density is fixed at D = 0.40, and the influence matrix is scaled to achieve different spectral radii. Specifically, we compute the natural influence matrix A_0 from the scale-free topology and scale it: A_t = s · A_0 where s = λ_target / λ_max(A_0). This preserves the structure of the influence network while controlling its strength. For each value of λ_max, we run 50 trials and measure the same convergence metrics.

10.3 Buffered Boundary Reproduction

The combined results from both sweeps produce an empirical phase diagram in the (λ_max, D) plane. For the purposes of deployment guidance, we classify each point as buffered or non-buffered using the conservative operating boundary λ_max = 1 − D, while separately tracking whether the exact contraction condition is still satisfied. The empirical buffered boundary closely matches the theoretical prediction. Specifically: | Metric | Value | |--------|-------| | Buffered boundary classification accuracy | 96.8% | | Mean absolute error of buffered boundary | 0.032 | | False buffered (predicted buffered, actually fragile/cascade) | 1.4% | | False non-buffered (predicted fragile, actually buffered) | 1.8% | The 3.2% misclassification rate occurs at points very close to the boundary (|λ_max − (1 − D)| < 0.05), where finite-time effects and the discreteness of the agent population cause deviations from the infinite-population, continuous-time theory. The false buffered rate (1.4%) represents configurations that appear robust in early steps but are actually fragile under longer horizons. The false non-buffered rate (1.8%) represents configurations where nonlinear saturation provides a little more damping than the linear buffered model predicts.

10.4 Convergence Speed Results

Within the buffered phase, the convergence speed varies systematically with the buffer margin δ_buffer = 1 − D − λ_max: | Buffer Margin δ_buffer | Mean Convergence Steps | Standard Deviation | |---------------------------|------------------------|--------------------| | 0.05 (near buffered boundary) | 198 | 47 | | 0.10 | 142 | 31 | | 0.20 | 103 | 22 | | 0.30 | 87 | 18 | | 0.40 | 78 | 14 | | 0.50 | 65 | 11 | The convergence time scales approximately as T ∼ 1/δ_buffer inside the buffered regime, while the variance drops rapidly as the buffer grows. This is precisely why the buffered law is operationally useful: it predicts not just whether the system settles, but how reliably it settles.

10.5 Optimal Governance Density

We define the optimal governance density D* as the value that maximizes a combined objective: Objective(D) = TaskCompletion(D) · Adaptivity(D) · Buffer(D) where: - TaskCompletion(D) is the steady-state task completion rate (decreasing in D due to governance overhead) - Adaptivity(D) is the speed of adaptation to demand shocks (decreasing in D due to role-change friction) - Buffer(D) is max(0, 1 − D − λ_max) The product peaks at D* ∈ [0.30, 0.55], with the exact optimum depending on the weighting of the three factors. For equal weighting, D* ≈ 0.40. This aligns with the intuition that moderate governance produces the best outcomes: enough structure to prevent cascades, enough freedom to enable adaptation. At the optimal density, the system exhibits: - Task completion rate: 93.4% (vs. 97.1% at D = 0.10 and 78.2% at D = 0.70) - Perturbation recovery time: 23 steps (vs. 8 steps at D = 0.10 and 450 steps at D = 0.70) - Role entropy: 2.1 (out of log(10) = 2.3, indicating diversified but not uniform specialization) - Buffer margin: 0.22 (comfortable reserve from the fragile regime)

11. Discussion

11.1 Governance as Control Input

The central message of this paper is that governance is not overhead — it is a control input. In the control-theory analogy, the influence matrix A_t represents the plant, the governance density D_t represents the damping input, the loop gain g_t = (1 − D_t)λ_max(A_t) is the exact contraction test, and the buffer margin δ_buffer = 1 − D_t − λ_max(A_t) is the operational reserve. Just as a control engineer distinguishes bare stability from healthy gain margin, an enterprise architect should distinguish exact convergence from buffered specialization. This perspective resolves a recurring debate in agentic company design: should governance be minimized (to maximize agent autonomy and speed) or maximized (to minimize risk)? The answer is neither. Governance should be calibrated to keep loop gain below 1 and, ideally, preserve a positive operating buffer. Too little governance allows cascading instability. Too much governance suppresses the adaptive capacity that justifies using agents in the first place.

11.2 Implications for Enterprise Architecture

The stability framework has several practical implications for enterprise architects designing agentic companies: Network Topology. The spectral radius λ_max is a property of the influence network. Densely connected networks with strong complementarities have high λ_max and therefore erode the operating buffer quickly. Architects can reduce λ_max by modularizing the organization into loosely coupled zones, standardizing interfaces between zones, and using the MARIA coordinate hierarchy to localize propagation. Governance Tuning. The constraint density D should be monitored and adjusted in real time, not set once at design time. Environmental changes alter the influence matrix, changing both loop gain and operating buffer. The MARIA OS gate engine provides the mechanism for this dynamic tuning. Scaling Laws. As the agent population N grows, the spectral radius of a random influence matrix scales as O(√N) for sparse networks and O(N) for dense networks. Larger agentic companies therefore need either more governance or substantially sparser influence topologies. The MARIA coordinate hierarchy provides a natural scaling mechanism by localizing most influence within zones and carefully curating inter-zone channels.

11.3 Relationship to Existing Frameworks

The framework connects to several established traditions: Game Theory. The stable role assignment ρ* is a Nash equilibrium of the role-selection game. The exact condition (1 − D)λ_max < 1 characterizes local convergence, while the buffered envelope λ_max < 1 − D gives a stronger, governance-oriented sufficient condition. Control Theory. The exact loop-gain test is the natural discrete-time contraction criterion for linearized feedback systems. The buffered envelope plays the role of a design margin rather than a bare feasibility threshold. Statistical Physics. The buffered boundary behaves like an order-disorder frontier, while the exact contraction boundary captures the onset of true amplification. The distinction mirrors the difference between nominal equilibrium and robust phase stability. Organizational Theory. The framework formalizes Ashby's Law of Requisite Variety: governance must supply enough constraint structure to absorb the variety generated by inter-agent influence, without over-constraining the organization into stagnation.

11.4 Limitations

The framework has several limitations that suggest directions for future work: 1. Linear approximation. The exact stability law is derived from a linearization of the best-response dynamics near equilibrium. Near the contraction boundary, nonlinear effects become significant. 2. Stationary assumption. The influence matrix A_t is assumed to be slowly varying relative to the convergence time. In rapidly changing environments, both loop gain and buffer must be tracked continuously. 3. Homogeneous governance. The model assumes uniform governance density D across all agents. In practice, different agents face different governance intensities. Extending the framework to heterogeneous densities requires matrix-valued damping coefficients rather than a scalar D. 4. Role-space discreteness. The continuous analysis (smooth utilities, Jacobians) is an approximation to the discrete role-selection problem. For small role spaces (M < 5), discrete effects may dominate. 5. No learning dynamics. The framework assumes fixed utility functions. Incorporating online learning, exploration, and adaptive topology formation remains a major open problem.

11.5 Future Directions

Several extensions of the stability framework merit investigation: Adaptive Governance. Rather than setting D manually or through threshold-based rules, use online control to optimize both loop gain and buffer in real time. Heterogeneous Stability. Extend the framework to account for heterogeneous agents with different influence strengths, governance burdens, and utility functions. The generalized condition would involve the spectral radius of a damping-weighted influence matrix diag(1 − D_i) · A. Temporal Governance. Study how governance density should vary over the lifecycle of an agentic company. Early-stage exploration and mature operations may require different target buffers. Multi-Objective Stability. In practice, multiple stakeholders care about different kinds of stability (financial, operational, reputational, ethical). A multi-objective framework would require simultaneous buffer management across several influence matrices.

12. Conclusion

This paper has established a formal stability framework for agentic companies — enterprises in which autonomous AI agents self-organize into functional roles through decentralized utility maximization. The central result is a two-level criterion: - Exact contraction: (1 − D)λ_max(A) < 1 - Buffered specialization: λ_max(A) < 1 − D The first inequality determines whether the linearized organization actually contracts. The second identifies the portion of that stable region with usable governance reserve. Together they partition the design space into Stagnation, Buffered Specialization, Fragile Specialization, and Cascade. We have shown that this framework extends to multi-layer systems through the effective constraint density formula D_eff = 1 − ∏(1 − D_l). The MARIA OS implementation provides concrete tools for monitoring and controlling both loop gain and operating buffer: the gate engine controls D, the evidence layer damps high-frequency oscillations, the analytics engine tracks λ_max, g_t, and δ_buffer, and the dashboard surfaces these metrics to human operators. Experimental validation on the Planet-100 simulation with 111 agents and 10 role types confirms the buffered operating boundary with 96.8% classification accuracy. The optimal governance density range D ∈ [0.30, 0.55] produces buffered specialization within 80–200 convergence steps, with enough reserve to absorb perturbations without slipping into fragility. The deeper insight is that governance and autonomy are not opposing forces. Governance supplies the damping that makes autonomy sustainable, but only up to the point where adaptation headroom disappears. For enterprise architects designing AI-native organizations, the design prescription is now precise: build the influence graph, estimate λ_max, keep loop gain below 1, and target a positive operating buffer. Stability is not the absence of change. It is the presence of convergence with reserve.

References

1. Ashby, W. R. (1956). An Introduction to Cybernetics. Chapman & Hall. 2. Barabási, A.-L. & Albert, R. (1999). Emergence of scaling in random networks. Science, 286(5439), 509–512. 3. Brooks, F. P. (1975). The Mythical Man-Month. Addison-Wesley. 4. Busoniu, L., Babuska, R., & De Schutter, B. (2008). A comprehensive survey of multiagent reinforcement learning. IEEE Transactions on Systems, Man, and Cybernetics, 38(2), 156–172. 5. Chandler, A. D. (1962). Strategy and Structure. MIT Press. 6. Daskalakis, C., Goldberg, P. W., & Papadimitriou, C. H. (2009). The complexity of computing a Nash equilibrium. SIAM Journal on Computing, 39(1), 195–259. 7. Fudenberg, D. & Tirole, J. (1991). Game Theory. MIT Press. 8. Horn, R. A. & Johnson, C. R. (2012). Matrix Analysis. Cambridge University Press. 9. Lowe, R., Wu, Y., Tamar, A., Harb, J., Abbeel, P., & Mordatch, I. (2017). Multi-agent actor-critic for mixed cooperative-competitive environments. NeurIPS. 10. Mintzberg, H. (1979). The Structuring of Organizations. Prentice-Hall. 11. Monderer, D. & Shapley, L. S. (1996). Potential games. Games and Economic Behavior, 14(1), 124–143. 12. Nash, J. F. (1950). Equilibrium points in n-person games. Proceedings of the National Academy of Sciences, 36(1), 48–49. 13. Newman, M. E. J. (2010). Networks: An Introduction. Oxford University Press. 14. Nyquist, H. (1932). Regeneration theory. Bell System Technical Journal, 11(1), 126–147. 15. Olfati-Saber, R., Fax, J. A., & Murray, R. M. (2007). Consensus and cooperation in networked multi-agent systems. Proceedings of the IEEE, 95(1), 215–233. 16. Ozdaglar, A., & Menache, I. (2011). Network Games: Theory, Models, and Dynamics. Morgan & Claypool. 17. Simon, H. A. (1955). A behavioral model of rational choice. Quarterly Journal of Economics, 69(1), 99–118. 18. Strogatz, S. H. (2015). Nonlinear Dynamics and Chaos. Westview Press. 19. Sutton, R. S. & Barto, A. G. (2018). Reinforcement Learning: An Introduction. MIT Press. 20. Taylor, F. W. (1911). The Principles of Scientific Management. Harper & Brothers. 21. Urwick, L. F. (1956). The manager's span of control. Harvard Business Review, 34(3), 39–47. 22. Vickrey, D. & Koller, D. (2002). Multi-agent algorithms for solving graphical games. AAAI. 23. Weiss, G. (Ed.). (2013). Multiagent Systems. MIT Press. 24. Wooldridge, M. (2009). An Introduction to MultiAgent Systems. John Wiley & Sons. 25. Young, H. P. (2004). Strategic Learning and Its Limits. Oxford University Press.