How it works — 4 of 7

Adjudication

Every action an actor proposes has to turn into a result. The rule the platform follows for that step is deliberately narrow: the model argues, the platform computes. The success or failure of an action, and the size of its effects, never come from a number the model made up — they come from fixed rules, a seeded dice roll and a fixed effect table. What the model does contribute, it contributes as arguments — plus two bounded self-assessments described below, each capped and consumed by fixed formulas rather than trusted as a measurement.

An action arrives with a stated rationale. The model is asked for up to a few arguments for it and a few against, an intended effect, and two bounded ratings: how far up the escalation ladder the action sits (a 1–10 rung) and how heavily it would fall on civilians (a 0–1 score). Those two ratings are the only numbers the model produces, and they are honest to name: the rung feeds a capped rally-round-the-flag term in public pressure, and the civilian score gates how hard certain stability and trust effects land — both through fixed, clamped formulas, never as raw deltas. Everything else is arguments. The arguments feed a base probability that is entirely computed from fixed rules: how many arguments favor the action, how many oppose it, and a set of state-dependent modifiers (whether the actors involved are already in conflict, how volatile the situation already is, and so on). The model's prose never touches this probability directly.

The base probability then meets a dice roll — literally: a seeded 2d6 roll, the sum of two six-sided dice. "Seeded" is the honest part of this: the roll is not free chance, it is derived deterministically from the run identity, tick and action. Given that same identity and action namespace, the roll can be recomputed and checked after the fact. This is narrower than promising an identical end-to-end rerun: creating a new run gives it a new identity, and model output can change the actions that enter the namespace. Numeric replay is therefore inspectable; full language-model replay remains best-effort.

The roll, against the base probability and a set of fixed thresholds, lands on an outcome class — success, partial success, or failure (with escalated variants on both ends). That outcome class looks up a fixed row in an effect table, and that row — not the model, not the roll — is where the actual deltas to indicators, relations, and any spillover on third countries come from.

Before anything is written down, those deltas pass through guardrails: per-action caps on how large a single delta can be, a rule that nothing changes without a recorded cause, and a limit on how much can move in one tick in total, scaled down proportionally if several actions push the same indicator at once. Any correction guardrails make is itself logged, not silently applied. If the numeric substrate layer is switched on, the surviving deltas are then carried forward into it. The whole chain — arguments, roll, outcome, effects, corrections — is kept as a full trace attached to the action, so any single result can be walked back to exactly why it happened.

flowchart TD
    accTitle: Adjudication trace
    accDescr: An actor action becomes arguments and bounded ratings, fixed rules and a seeded roll determine an outcome class, a fixed effect table supplies deltas, and guardrails record corrections.
    A[Actor proposes an action, with a rationale] --> B[Model argues: pros and cons, plus two bounded ratings - escalation rung and civilian impact]
    B --> C[Base probability plus state modifiers, from fixed rules]
    C --> D[Seeded 2d6 roll: recomputable for the same run identity, tick and action namespace]
    D --> E[Outcome class: success, partial, or failure]
    E --> F[Fixed effect table sets the deltas]
    F --> G[Guardrails clamp outliers and log corrections]
    G --> H[Substrate updates the numeric stocks, if enabled]