No One Wins in Nuclear War: A Social Simulation of Military Decision-making

AI summary

Overview

Research area: AI safety and multi-agent social simulation, specifically the use of large language models as players in adversarial, high-stakes organizational decision-making (wargaming).

Technical level: Intermediate. The core ideas are conceptual and accessible, but full appreciation requires some familiarity with LLM agent frameworks, game engines, and reproducibility practices such as deterministic replay.

Scope: The paper introduces WOPR, a simulation environment that pairs a deterministic, replay-checkable game engine with a standard interface for agent decisions, and layers on top of it a communication-capacity experiment axis and several organizational command structures — demonstrated on a published card game about nuclear war.

What This Paper Is About

Most work on social simulation with language models focuses on whether agents behave like believable people — persona fidelity, opinion formation, social reasoning — but leaves the consequences of their choices to be adjudicated informally by a model or a human. That makes it impossible to replay a scenario and verify that a claimed outcome actually follows from the stated rules.

This paper supplies the missing piece: a rules engine that is the sole authority on what actions are legal, that records every state transition, and that lets any game be re-executed and audited. It instantiates that engine with the card game Nuclear War, then uses it as a fixed substrate for studying how communication and organizational structure change military-style decision-making.

Key Contributions

1. A replay-validated rules engine: A deterministic simulation environment built on a real published card game, verified by a 240-game sweep confirming that purely structural changes to the engine leave seeded outcomes unchanged.

2. A decision-point contract: A small, fixed interface that converts every genuine strategic choice (card placement, launch targeting, interception, etc.) into an explicit agent decision at a rule-defined moment in the turn, while mandatory bookkeeping steps advance automatically.

3. A four-rung press ladder: A communication axis layered on the unchanged engine — from silence, through one public statement per round, through multiple public passes, to full press with private single-recipient channels and structured commitments — without any effect on game state or replay output.

4. Four faction command-and-control archetypes: Sole-authority, council, distributed, and automated command structures, each motivated by a real nuclear-use command system, all collapsing internal deliberation into exactly one action so they remain interchangeable seats in the same game.

Main Findings

• Replay validation works as a fidelity method. The engine's "parity invariant" states that structural refactors must leave seeded outcomes byte-for-byte identical, and that any change in outcomes must be explicitly asserted by name. This is verified across 240 games (3 and 4 players × heuristic and random agents × seeds 1–60) via a two-worktree diff rather than a single hardcoded golden file.

• Random and heuristic agents diverge by design. Random agents produce different outcomes wherever targeting or interception is a real choice, because they consume random draws. The test suite asserts this divergence explicitly rather than absorbing it silently — an unusual and deliberate design choice for reproducibility.

• Speech is completely decoupled from mechanics. Across all four press rungs, the replay JSON is byte-identical to a no-press game. Communication is trace-only, written to a separate sidecar file that the engine ignores. This means any measured effect of communication is attributable to communication alone, holding the rules fixed.

• Factions are composite agents invisible to the engine. A faction runs internal deliberation, applies a pure aggregation rule (executive override, weighted council threshold, distributed quorum, or pre-armed policy trigger), and returns one legal action. The engine cannot distinguish it from a single agent, so the same replays and validation apply.

• The council archetype has a worked trace. In a three-member council with a 0.34 threshold facing a two-opponent endgame, members split between three different votes; no option cleared the threshold, so the rule fell back to the first-cast vote and the faction launched at player 2. Votes and aggregation come from a real recorded deliberation; the rationale text is illustrative.

• Rule conformance is traced, not claimed as perfect. A conformance matrix binds each implemented mechanic to a source note, and a rules-trace pass maps a full deterministic replay onto source-linked rule steps with no gaps reported. Two known simplifications are documented, including the use of a two-d10 spinner where the published postal rules specify a separate six-sided die, which changes launch-failure probability.

• The paper is an environment, not a study. The authors state explicitly that there is no controlled comparison across press rungs, no claim about how agents behave under them, no automatic enforcement of commitments, and only one of the four archetypes has a worked example.

Methodology in Plain English

The authors began with an existing commercial card game with published rules and rebuilt those rules as a deterministic computer program. The key design decision is that the program, not any model, decides what moves are legal. When it is a player's turn, the engine advances automatically through all the routine steps — drawing cards, resolving effects — and stops only at points where a genuine strategic choice exists. At each such stop, it hands the agent an observation and a list of legal actions.

An agent is anything that can look at the observation and return one action from the list. It could be a simple scripted heuristic, a language model with a persona, or an entire group of models deliberating internally. If the group deliberates, it must still return exactly one action, so the engine never needs to know the difference.

Because everything is deterministic, the researchers can replay any game from a seed and compare outcomes before and after code changes. They use this as a test: if a refactor is purely structural, the 240 seeded game outcomes must not change. If a deliberate bug fix does change outcomes, the specific affected seeds must be named and pinned in the test suite. This catches accidental behavior drift that ordinary unit tests would miss.

On top of this frozen engine, they added communication as a separate layer. Messages are recorded to a sidecar file and injected into agents' memories, but never touch the game state. The four rungs progressively increase what can be said and to whom, up to private whispers and structured "commitments" — declared intentions like standing down at a given round, recorded as data and linked to later decisions but never automatically checked for violations.

Finally, they replace single-agent players with small command structures. Each faction member votes, and a fixed rule collapses the votes into one action — mirroring different real-world arrangements of who holds release authority.

Why This Matters

Impact on research. The paper identifies a specific, concrete gap: social simulation and LLM wargaming both lack a verifiable engine where a claimed outcome can be replayed and checked against stated rules. Supplying that engine converts wargame simulations from qualitative exercises into auditable experiments, and does so without prescribing which agent framework researchers use — the design is intended to be harness-agnostic, with Concordia as only a default.

Real-world applications:

• AI safety evaluation for high-stakes decision-making. Fixed rules plus a communication-capacity dial lets researchers isolate how much a model's escalation or de-escalation behavior depends on what it is allowed to say, rather than on the mechanics of the scenario.
• Organizational and command-structure analysis. The four C2 archetypes let researchers ask whether concentration of authority, consensus requirements, or pre-delegation change outcomes under identical conditions — a question that is essentially impossible to test on real institutions.
• Human-versus-model comparison. The same engine and contracts could seat human players, allowing fair comparisons of decision patterns under controlled communication conditions.
• Reusable infrastructure for other verifiable rule systems. The decision-point contract is not specific to Nuclear War, so the same architecture could underpin negotiation, resource-allocation, or treaty-compliance simulations with fully auditable mechanics.

Industry relevance. The engineering practices here — deterministic replay, parity invariants across refactors, explicit assertion of intentional behavior changes — are standard concerns in simulation, game development, and safety-critical software, and they transfer directly to any organization building agentic systems that must be evaluated rather than merely demonstrated. The published tooling, example configurations, and an offline no-provider variant that runs the full pipeline without a live model also make the work easy to adopt without API costs.

Future Directions

• Scale the press ladder into a controlled study. The paper defines the rungs but does not run a comparison. The obvious next step is to hold the engine fixed, vary only the communication rung, and measure how agents' escalation behavior changes.
• Compare command-and-control archetypes systematically. All four are defined, but only the council has a worked example. Varying archetype and personality parameters across factions, on the same engine, would test whether structure alone shifts outcomes.
• Build multi-game batch analysis. Press modes currently run one game at a time. Statistical claims require batch runs and aggregate analysis rather than single-game inspection.
• Move commitments from honor system to evaluated signals. Commitments are recorded and linked to later decisions but never enforced or automatically checked. A violation-detection layer would turn them from a post-hoc research artifact into an active measure of credibility and defection.
• Broaden rule fidelity and applicability. The conformance matrix tracks unresolved simplifications, notably in postal equipment launch resolution, and the contract could be ported to other verifiable rule systems beyond this one game.

Target Audience

AI safety and AI ethics researchers studying multi-agent behavior and escalation dynamics; researchers building LLM-based social simulations who need reproducibility and auditability; wargaming and crisis-simulation practitioners interested in machine-checkable mechanics; and engineers building agent evaluation environments who want a concrete model for deterministic replay, decision contracts, and separating an agent's communication from an engine's state. The paper is also useful to readers specifically interested in how organizational structure — not just individual agent personality — shapes high-stakes decisions.

Authors’ abstract

WOPR is a social-simulation environment for studying how organizations make high-stakes decisions, built on a deterministic, replay-validated rules engine and using wargames as the vehicle. We instantiate it first with the published card game Nuclear War, traced against its published rules. We start with military decision-making because of its safety implications and because it needs further study, but the design is not specific to it: the decision-point contract that exposes the engine to agents is reusable across verifiable rule systems. Existing social-simulation work emphasizes persona fidelity and synthetic opinion, but lacks a verifiable rules engine with replay-checkable mechanics and private-channel negotiation. WOPR supplies that engine, and its contract makes every strategic choice an explicit agent decision. The method is agnostic to social-simulation frameworks; we adopt Concordia as the default harness for driving the game. On the same engine, WOPR layers a four-rung press ladder from silence to private single-recipient channels with structured commitments, and instantiates each faction as a collective command-and-control system rather than a single agent. We make all code, example configurations, and replay data publicly available at https://github.com/eilab-gt/wopr.