BTUT.

Why complex multi-agent systems matter — and why the default fails.

Complex multi-agent systems are the operating substrate of modern civilization. Traffic networks with millions of vehicles. Power grids with millions of generation / load nodes. Autonomous fleets — drones, trucks, ships — coordinating without a central planner. Financial markets where millions of agents converge or diverge on prices. Sensor networks, robotic fleets, distributed compute, civic-scale behavioral coordination. All of it is the same mathematical problem: how do many agents reach a cooperative equilibrium fast enough to be useful, and robustly enough not to collapse under stress.

DARPA Mathematical Challenge 13 names this problem directly. The dominant academic answer is a PDE on the density of agents, solved with O(N³) numerics, which crashes before 10,000 agents. That is not a coordination substrate for a civilization; it is a coordination substrate for a laboratory. BTUT starts from a different mathematical object entirely — a phase transition of a scale-free network under Fermi-rule strategy updates — and the reduction is categorical, not incremental. The question changes from how do we solve the PDE faster to why do we need a PDE at all. The same critical exponent, the same N-invariant convergence count, and a domain-varying critical γ are observed across three validation regimes (abstract, traffic, drone).

That is the “new approach” claim. The cross-domain-comprehensive claim is where the primitive actually lives. One mathematical object ships today across: an Eclipse SUMO integration (full TraCI client, A/B comparison harness, 800-vehicle stress peak), an ROS integration (rosbridge, agent-state streaming, parameter update channel, Turtlebot3 swarms), a 50 – 200 drone swarm validation suite, a Python SDK (pip install btut-sdk), a REST API on Fly.io, a serverless Lambda variant, a WASM build for in-browser simulation, a full proofs corpus, and a research workbench for parameter sweeps. This is the most cross-domain application of a DARPA-Challenge-13-style primitive currently live. If a broader one exists, produce it — the repository is open, the APIs are public, the comparison is trivial.

The reduction.

The classical approach to multi-agent coordination solves a PDE on the space of agent densities. It works — on paper. In practice the cost scales like O(N³) and the simulation crashes at ten thousand agents. The field’s default assumption is that coordination is expensive.

BTUT refuses the PDE. Agents play a Stag Hunt coordination game and a Prisoner’s Dilemma simultaneously on a scale-free network with preferential-attachment hubs, updating strategies via the Fermi function. A single parameter τ ∈ [0, 1] weighs hub-degree influence; a single parameter γ controls the cooperation bonus. The result is a phase transition with a clean critical exponent and N-invariant convergence dynamics.

Network + game.

# Scale-free topology (Barabási–Albert, preferential attachment)
P(k)  =  C · k^(−γ)      with    γ ∈ (2, 3)
k_hub ∼ N^(1 / (γ − 1))

# Hub-weighted influence on neighbor j of i
w_ij  =  (k_j)^τ  /  Σ_{l ∈ N(i)} (k_l)^τ

# Strategy update (Fermi)
P( s_i ← s_j )  =  1 / ( 1 + exp( −(U_j − U_i) / κ ) )

Theorem 1 — Cooperation convergence.

In a scale-free network with γ ∈ (2, 3), τ > τ_c, and c_A > d_B, the system converges to full cooperation (all agents choose strategy A) with probability 1 as N → ∞.

Sketch: hubs with degree k_hub ∼ N^(1/(γ−1)) flip to A, each influencing O(k_hub) neighbors. Above the critical τ_c, hub influence creates a positive feedback loop. Because c_A > d_B, cooperation is payoff-superior and cascades faster than defection spreads.

Theorem 2 — Critical threshold τ_c ≈ 0.3.

There exists a critical value τ_c ≈ 0.3 below which cooperation cannot dominate and above which cooperation emerges via hub-mediated cascades. The threshold emerges from the balance between hub amplification (cooperation spreads via high-degree nodes) and defection temptation (higher individual payoff from strategy B).

Corollary — Continuous phase transition (mean-field).

f_A(τ)  ∼  (τ − τ_c)^β        for τ → τ_c⁺   ,   β ≈ 0.5

The critical exponent β ≈ 0.5 places BTUT in the mean-field universality class. The phase transition is robust to noise and to network variations — the primitive behaves consistently across abstract, traffic, and drone domains.

SUMO stress test — 800 vehicles, zero gridlock.

The headline validation runs Eclipse SUMO for 3,000 simulated seconds across six phases — warm-up, ramp-up, peak stress, sustained, wind-down, recovery — with traffic peaking at 800 vehicles between 600 – 1200 seconds. Every metric below is read directly from the simulator’s raw JSON output; nothing is modeled.

Sustained throughput: 1,760 vehicles/hour. Maximum wait time: 8 seconds. Six stress phases, one coordination primitive, zero catastrophic failures.

Seven strategies compared.

The SUMO environment supports a direct head-to-head against baseline coordination schemes on the same network and load. Under the standard validation harness (not the stress peak), the results below compare cooperation fraction, sustained speed, wait time, throughput, and stability:

The τ sweep.

Cooperation climbs monotonically from 49% (democratic, τ=0) to 73.4% (hub-centric, τ=0.8). Peak speed gain lands at τ=0.7 (+12.3%). The τ_c ≈ 0.3 threshold is visible: below it, cooperation and speed improvements are fragile; above it, both compound.

O(N) scaling — verified.

Convergence iterations are constant as agent count grows three decades. Every run — 500, 1000, 2000, 5000, 10000 agents — terminates in exactly 12 iterations. That is the N-invariance claim, and it is what makes the reduction real.

The constant-iteration property is the defining signature of O(N) complexity in this primitive. Speed-per-agent gracefully degrades (7.88 → 5.60 m/s) as the physical simulation gets denser, but the coordination substrate itself does not slow down.

Drone swarms — 50, 100, 200 agents.

Cooperation stays at 100% across all three scales. Formation error grows sub-linearly (82 → 103 as N quadruples). Energy efficiency stays flat at ~96.9%. Collisions grow with density — an honest limit: BTUT is a coordination primitive, not a collision-avoidance planner, and the numbers make that distinction visible.

Real-world integrations.

SUMO — via TraCI.

A TraCI client layer exposes real-time vehicle data, metrics, and the BTUT coordination controller to the simulator. Two comparison modes (baseline, btut) and a combined both view let any experimenter A/B a given road network against the primitive with no modeling choices on the user’s side.

ROS — via rosbridge.

The robotics frontend connects to a local ROS master over ws://localhost:9090. It exposes agent state streams, coordination-result streams, and a parameter update channel. Example integration: a 5-robot Turtlebot3 swarm coordinated at γ = 1.8, τ = 0.4.

Python + Cloud.

pip install btut-sdk gives a single-call Simulator interface. A REST API on Fly.io answers POST /simulate with JSON results, and a Lambda variant provides serverless horizontal scaling. The SDK is the same shape for a researcher in Jupyter and for a backend under load.

Applied deployments.

Beyond the core primitive, BTUT ships in two stand-alone live applications — each a different real-world domain using the same coordination substrate:

• franklinstreetdata.com — a civic / urban-data application of BTUT on Chapel Hill’s Franklin Street. Repository: direncode/framklnstdata.
• bigdunc.com — a game-modeling application built on the BTUT coordination kernel. Repository: direncode/game-model.

With these two, the count of live domains running the same mathematical object rises to six: traffic simulation, robotics, drone swarms, cloud surfaces, civic data, and game modeling. The cross-domain claim is now backed by public URLs; every deployment is clickable from the source bar at the top of this chapter.

Why this matters.

DARPA Mathematical Challenge 13 asks how to coordinate millions of autonomous agents efficiently, in real time. The conventional assumption is that “efficiently” implies a cluster. BTUT’s answer is that efficiently implies a different mathematical object: a Fermi-updated, hub-weighted phase transition on a scale-free network. On a single simulator, 800 vehicles coordinate through a peak-stress event with zero gridlock. The phase transition is in the mean-field universality class with β ≈ 0.5. That is not an engineering optimization. That is a reduction.