AFTERSHOCK FIELD LOG
← Field Log
LOG-009 2026.06.26 · 11 min read · Kenny Ademolu

We put a number on coordination: the price of anarchy in an agent society

Price of anarchy 1.11xCoordinated > uncoordinatedsolo ≈ swarmgap still suggestive (p=0.118)

A reader looked at the running theme of this log — a coordinated society of small models versus an uncoordinated swarm — and asked the sharp question: isn’t that a Nash-equilibrium story? Does the hypothesis actually hold if you frame it that way?

It’s the best framing question I’ve gotten — and one I couldn’t resist, because I’m an economics and game-theory geek at heart (my first degree was in Economics). That’s the honest reason this entry runs longer and digs deeper into the theory than usual. Because it turns out Aftershock isn’t like a game-theory problem — it is one, almost on the nose. So I spent today building a ruler for it and reading the literature to make sure I was using the words correctly. This is what the ruler said, what it can’t say yet, and where it points next.

The game hiding under the simulation

Strip the disaster theme away and Aftershock is a common-pool resource game. Each tick, six role agents claim from finite shared pools — ambulances, rescue crews, fire engines, fuel — toward missions that have a severity, a deadline, and lives at risk. Every claim one agent makes is a unit another agent can’t use: a textbook negative externality. That is precisely the setting where game theory predicts the uncoordinated outcome is inefficient — the classic tragedy of the commons (Hardin, 1968) — and where structure can claw the efficiency back. Elinor Ostrom’s Nobel-winning work (Governing the Commons, 1990) is the whole counter-argument: communities don’t need privatization or a central state to avoid the tragedy; they need institutions — shared rules everyone follows. That is a startlingly exact description of what we call doctrine.

The formal object for “players sharing congested resources” is a congestion game (Rosenthal, 1973), and the standard way to score how much selfish play costs is the price of anarchy — the ratio between the social optimum and the worst equilibrium — introduced as the “coordination ratio” by Koutsoupias & Papadimitriou (1999) and named by Papadimitriou (2001). The canonical worked example is selfish routing, where Roughgarden & Tardos (2002) proved uncoordinated traffic wastes at most a 4/3 factor with linear latencies. Swap “drivers on roads” for “agents on ambulances” and you have our benchmark.

Our four arms line up on exactly the coordination axis:

The arms, as game-theory objects
ArmMechanismGame-theory reading
swarmflat agents, no arbitration (direct dispatch)uncoordinated play — the price-of-anarchy baseline
soloone big model deciding everythingcentralized but single-headed
societyper-tick auction + written doctrinea mechanism + a correlation device
scriptedhand-tuned central heuristic ($0)a strong central planner

The society’s auction is, literally, a piece of mechanism design — the field that runs from Vickrey (1961), Clarke (1971) and Groves (1973) (the VCG family of efficient, strategyproof allocation rules). And the doctrine is best read not as Nash but as a correlated equilibrium (Aumann, 1974): a shared signal that all agents condition on, which can beat what uncoordinated best-responses reach on their own.

What the ruler measured

Raw “lives saved” is unbounded and trajectory-dependent, so it’s a poor yardstick for efficiency. Instead I measured the fraction of imperiled lives saved, grounded in the sim’s own exact accounting: every life that becomes at-risk is eventually saved, lost, or still-open, so

total_at_risk = lives_saved + lives_lost + open_remaining     (an identity, not a model)
efficiency    = lives_saved / total_at_risk                   (in [0, 1])

That’s aftershock poa, computed over recorded runs — deterministic, no API spend. Here is the result:

Efficiency = fraction of imperiled lives saved (4-arm benchmark, n=5)
ArmEfficiencyCoordinated?
society (auction + doctrine)67.3%yes
scripted (central heuristic)66.2%yes
solo (one big model)58.9%no
swarm (flat, no protocol)58.1%no

The headline isn’t the top line — it’s the clustering. Both coordinated arms land at ~66–67%; both uncoordinated arms land at ~58%. The structure, not the specific agent, is what moves the number. And the sharpest data point in the whole project is hiding in that table: the expensive single big model (solo) sits at the swarm’s anarchy level. For this allocation problem, coordination beats raw model size — six cheap models with a protocol out-deliver one big model without one.

Pairing society against swarm directly, pooled to fifteen seeds:

society vs swarm, paired efficiency (n=15)
StatValue
Mean efficiency delta+6.7 points
Seeds society won11 / 15
Bootstrap 95% CI[+2.6, +10.8] (excludes 0)
Sign-test p0.118 — suggestive, not significant
Price of anarchy (society / swarm)1.11×

So the swarm leaves roughly an eighth of the achievable lives on the table relative to the society — a real price of anarchy — but the pairwise gap carries the same statistical caveat as the raw-lives number two logs ago: the CI excludes zero, the sign test doesn’t clear significance. The efficiency reframe is more interpretable (it’s bounded, and it cleanly separates coordinated from uncoordinated); it does not manufacture significance, and I’m not going to pretend it does.

What I can’t claim (and why I’m saying so)

Three honesty bounds, because the fastest way to discredit a game-theory framing is to over-reach with it.

The agents are not equilibrium-solvers. They’re LLMs following prompts, not utility-maximizers computing best responses. So “the society reaches a Nash equilibrium” is a category error — nobody is solving a fixed point. The honest statement is that the game has an inefficient uncoordinated region and an efficient coordinated one, and we measure where each arm’s emergent play lands. (The reason this still works is one of my favorite results in the field: Roughgarden’s smoothness framework (2015) shows price-of-anarchy bounds extend automatically to no-regret learning and correlated play — i.e., they bite even for messy, non-equilibrium agents. That’s the bridge from the textbook to a swarm of language models.)

The denominator is a ceiling, not a tight optimum. Efficiency = 1.0 means every imperiled life saved. That’s a rigorous upper bound, but it is not the best achievable outcome under finite resources — the true optimum is a multi-tick scheduling problem over the deterministic world, and it’s intractable to compute exactly. So I report “fraction of saveable,” never “fraction of optimal.”

On the hardest scenario, the order flips. On the brutal real-data NYC Hurricane Ida pack, the scripted central heuristic saves 32.2% and the LLM society saves 8.9%. The coordination edge is a synthetic-benchmark finding; the society is not magic on a savage real scenario. That belongs in the same paragraph as the win, not in a footnote.

This is also why I keep one skeptical paper open on my desk: Cemri et al.’s Why Do Multi-Agent LLM Systems Fail? (2025) catalogs how often multi-agent LLM setups underperform — exactly the null hypothesis a “society beats X” claim has to survive. Ours survives it structurally and suggestively, not decisively.

The experiments that would firm it

A ruler is only useful if it tells you what to build next. Three follow-ups, in order of value:

  1. A self-enforcement test. Right now we know the society’s allocation is efficient (it eliminates priority inversions — see Log 004). We don’t know if it’s stable: could any single role do better by deviating from the auction outcome? Replay each contested tick and check for a profitable unilateral deviation. If there is none, the coordinated allocation is incentive-compatible — a self-enforcing equilibrium, not merely an imposed rule. That’s the difference between “we told them to cooperate” and “cooperating is their best move.”

  2. A central-planner oracle for a tighter optimum. The save-everyone ceiling is loose. A strong omniscient greedy planner run through the same deterministic engine would give an achievable social-optimum proxy, turning “society reaches 67% of saveable” into “society reaches X% of what a perfect coordinator achieves” — the real price-of-anarchy denominator.

  3. Auction strategyproofness. Our auction allocates by urgency bids. Can an agent win contested units by overstating urgency? The VCG line (Vickrey/Clarke/Groves) is the theory of allocation rules where honesty is the dominant strategy. Testing whether doctrine conformance keeps bids truthful — or whether a strategyproof rule does it for free — is a clean mechanism-design question we already have the harness to answer.

Turning the lens on real incident response

Here’s the part that makes this more than a benchmark curiosity. Real incident response already runs on a coordination doctrine. The U.S. National Incident Management System (FEMA, 2017) and its Incident Command System exist because uncoordinated multi-agency response to a disaster is a price-of-anarchy disaster: duplicated effort, contested resources, no clear allocation. ICS is, in our vocabulary, the correlation device — a shared playbook that every responding unit conditions on. Aftershock’s “doctrine” is a toy of exactly that idea.

And the resource problem under it is a well-studied optimization target: emergency dispatch and ambulance routing/location have a large literature (see the reviews by Mukhopadhyay et al., 2022 and Tassone & Choudhury, 2020), and multi-agent disaster response has been a grand challenge since RoboCup Rescue (Kitano & Tadokoro, 2001), with agent-based simulation used to plan resource allocation for major incidents (Hawe et al., 2015).

So a concrete future iteration of the app: a mechanism-design dispatch layer. Picture an incident commander facing several simultaneous incidents competing for the same scarce units. Today that allocation is often made under load, ad hoc. A decision-support layer could run the same auction + doctrine Aftershock uses — a transparent priority mechanism over real incident demand — and, crucially, report the price of anarchy of the status-quo allocation versus the coordinated one: “this dispatch pattern is leaving an estimated N% of saveable response-time on the table.” That’s the honest framing the whole project is built on — real demand and latency, simulated outcomes — extended into a what-if tool. Not a replacement for human incident command (the literature, and common sense, say the human doctrine is the point); a ruler the commander can hold up against their own decisions.

The other half is the agents. Generative-agent societies (Park et al., 2023), multi-agent debate (Du et al., 2023), and LLM negotiation under mixed incentives (Abdelnabi et al., 2023) are all converging on the same question Aftershock asks in miniature — and the open problems in getting them to cooperate reliably are exactly the ones Dafoe et al. (2020) laid out for Cooperative AI. A dispatch layer is a high-stakes, legible place to study them: the externalities are real, the doctrine is real, and the price of anarchy is measurable.

The honest takeaway

Coordination has a value, and now we can put a number on it: on this benchmark the protocol-free swarm pays a ~1.11× price of anarchy (pooled over fifteen seeds; ~1.16× on the five-seed four-arm cross-section), and — the cleaner result — coordinated play (whether a hand-tuned heuristic or an LLM society) beats uncoordinated play (whether a swarm or one big model) by ~8 points of saveable lives. The society-vs-swarm edge itself remains suggestive, p=0.118; the order flips on the hardest real scenario; and the agents aren’t really solving for equilibrium at all. The interesting work isn’t claiming a bigger win — it’s making the coordination self-enforcing, measuring it against a tight optimum, and pointing the same ruler at a real dispatch board.

Build the ruler first, as ever. Then let it tell you what to build.

Live demo: https://aftershock.redoubtlabs.dev · Code: https://github.com/bluntmachetti/aftershock (method + verdict in docs/EVIDENCE.md §3 and docs/FIELD-NOTES.md §25)

Every reference below was independently checked before publishing (Log 006’s lesson). Foundations of game theory and mechanism design; recent multi-agent-LLM work; and the incident-response literature the application section draws on.

Price of anarchy & efficiency of equilibria

Congestion games & the commons

Mechanism design & correlated equilibrium

Multi-agent LLM systems

Incident response & emergency resource allocation