Wargaming (Adversarial Contingency Planning)
A wargame is a plan written for the world not going as planned. A normal plan — even from a very capable model — assumes linearity: it breaks the task into phases, sequences them logically, and reads as a high-probability blue-sky path. A wargame instead has the model fight the mission on paper move by move, and at every move enumerate the failure it could hit, the signal that reveals the failure, and the counter-move that resolves it. The source's spine is three elements — action → reaction → counteraction: the model makes a move, "reality humbles it" by throwing an error, and it must take a counter-action to recover. The source calls this loop, pre-simulated on paper, "the modern-day agentic loop" written out ahead of time (see Agent Loop).
The move that makes it more than a checklist is the explicit instruction "you are not executing this mission, you are purely war-gaming it" — a capable model distinguishes a plan from a wargame and, told which it is producing, front-loads the contingency reasoning it would otherwise discover only at run time. The concrete artifact each move carries: expected observation (what you see if it worked) / most-likely failure + the cause it signals + the counter-move / a fork trigger ("if you observe X, take route B") / RECON NEEDED markers for assumptions due-diligence could not settle (each with the exact check that would settle it) / and terminal abort conditions — the error classes at which the executor should stop rather than push on (e.g. no access to a required system). The operator sets the simulation depth — how many orders of consequence (second-, third-, fourth-order) to game out before stopping — because unbounded simulation never terminates.
Why do this with a premium model you are about to lose access to: the wargame is a portable artifact. Once the hard contingency reasoning is captured in markdown, a cheaper or open-weight executor (the source names Opus 4.8, GPT-5.5, GLM, Sonnet 5) can run the brief "end to end without asking a single question" and far more confidently, because the realities it will meet have already been simulated. This is the "method you feed the model" made durable — see Execution Commoditization and the architect/executor split of Model-Tier Routing. It is distinct from live plan-then-dispatch routing: the expensive model's reasoning is distilled into a transferable blueprint, not consulted in the loop.
Claims
- A wargame differs from a plan by pre-simulating failure: every move states its expected observation, its most-likely failure and the signal that reveals it, the counter-move, and fork triggers — a normal plan assumes linearity and only shows the success path. principle — durable: a linear plan and a contingency-annotated plan are different artifacts regardless of model; the value of the second is the pre-computed reaction/counteraction the first omits.
- Telling a capable model explicitly "you are war-gaming, not executing" changes what it produces — it will front-load contingency reasoning rather than an execution path. observation — the source's mechanism claim ("a language model will know the difference between a plan and a war-game"); attributed, plausible, but a behavioral assertion about current models, not a proven law.
- Bound the simulation: the operator sets how many orders of consequence to game out (second-, third-, fourth-order), because "as with any simulation, you need to define an end." best practice — context: contingency planning that could otherwise recurse indefinitely; how deep to go is a human judgment about the stakes of the specific mission, not a fixed number.
- End every wargame with abort conditions — the error classes at which the executor should stop rather than push on (e.g. no access to a required system is a full blocker). best practice — context: handing a brief to an unattended executor; abort conditions are the safety valve that prevents a blocked run from thrashing. Pairs with Evidence-Gated Completion (a move's "expected observation" is the evidence gate for that step).
- The value of a wargame is that it is portable: the premium model's contingency reasoning, once written to markdown, lets a cheaper executor run the brief confidently without live access to the premium model. principle — durable: this is Execution Commoditization's "the method becomes the distribution channel" applied to planning — the transferable artifact is the moat, not the model.
- Mark unresolved assumptions in-band (RECON NEEDED / a
placeholder variable) and flag them to the operator rather than guessing
silently. best
practice — context: war-gaming with undefined inputs; surfacing
the gap (in a ledger or
{{VARIABLE}}) beats a confident fabricated value. Echoes Negative Prompting and evidence-gated honesty about what is unverified.
Related
- Agent Loop — the source frames action→reaction→counteraction as "the modern-day agentic loop"; a wargame is that loop pre-simulated on paper before an executor runs it live.
- Execution Commoditization — the strategic why: when execution is cheap, the method you feed the model is where differentiation lives; a wargame is that method captured as a durable artifact.
- Model-Tier Routing — adjacent architect/executor split. Wargaming is the offline, artifact-first variant: distill the expensive model's reasoning once, then any executor runs it — vs consulting tiers live.
- Orchestrator Unknowns (Finding Your Unknowns) — the diagnostic that motivates war-gaming: the bottleneck is the unknowns the orchestrator holds; forks and RECON-NEEDED markers are how a wargame drags them into the light.
- Spec-Driven Development — a wargame is a spec with the failure branches written in; both move the hard thinking ahead of execution.
- Evidence-Gated Completion — each move's "expected observation" and the closing verification runs are per-step evidence gates baked into the plan.
- Negative Prompting — abort conditions and "run nothing that changes state" are the wargame's boundary-setting clauses.
- Distillate: Do THIS Before You Lose Access to Fable 5 — war-game the missions, keep the blueprints