the llm proposes; the rules engine disposes

this is the architectural spine. the language model writes scenes and chooses which adjudication tool to invoke. the rules engine — a deterministic library that lives in src/rules/ — decides what actually happens. dice rolls, combat math, loot drops, experience points, room access, save-file integrity: every outcome that matters is computed by code that has the same answer on every run, not by a model that improvises.

the model narrates. the story is yours. the world is real.

what the model does

  • narration prose. the words you read between actions — descriptions of scenes, the voices of npcs, the texture of a room — come from the model.
  • tool selection. when a player declares an intent ("i try to pick the lock"), the model decides which adjudication function to invoke ("roll a dexterity check against dc 15"). it picks the tool; it does not decide the result.

what the model does not do

  • state mutation. the model never writes to the save file directly.
  • outcomes. success or failure on any check is computed server-side, not narrated into existence.
  • loot. what drops, who claims it, and when, is decided by the rules engine and an atomic claim protocol.
  • experience points. xp is awarded by deterministic rules, not by a model's mood.
  • combat math. attack rolls, damage, conditions, death saves — all server-side.
  • dice. rolls come from a deterministic dice library; the animation on screen is a reveal of the server-computed value, not a separate roll.
  • room access. whether a door opens or a wall holds is a rules-engine decision against the world's state, not a narrative convenience.
  • save-file integrity. writes are serialized per campaign, validated, and sanitised before they touch the database.
  • ability validation. a player cannot invoke a class feature they don't have, even if the model would have let them try.

how the rules engine adjudicates

every gameplay action follows the same path: the player speaks their intent. the model emits a tool call with arguments. those arguments are validated. the rules engine — pure functions, no network, no model — computes the outcome from the current world state. a single state manager applies the result. the new state is broadcast to every connected session in the campaign.

the path is the same for solo play and for a party of six. it is the same for combat and for conversation. it is the same when the model is excellent and when the model is having a bad day. the rules engine is the spine; the model is the voice. the two are kept separate on purpose.

which model

the narration model in this deploy is gemini 2.5 flash (legacy in-house driver). it writes prose and chooses which adjudication tool to invoke; it does not own any outcome the rules engine adjudicates (see the lists above).

if the agent driver is swapped to a different model in the future, this page updates within one deploy. the model name on this page is the source of truth a skeptical reader can cite.

the legacy driver does not wrap agent turns in the 60-second watchdog — a stall produces no calm timeout, and the gm stall-recovery affordances (story 3.4 — backlog) do not engage.

how the world reaches you

some campaigns can reach you while you are away — a letter from a character who has not forgotten you, arriving by email or on discord. this is the one place the world steps out of character to explain itself, because a message that finds you outside the game should never feel like surveillance. here is exactly how it works.

the model is the voice, not the hand on the switch. when something happens in the world worth a letter, a deterministic world-tick decides that; the rules engine decides which character would write and when; the rate is capped to a trickle. only then does the model write the letter's words, in that character's voice. the model never chooses to contact you. it is given a beat the rules engine already decided, and asked to phrase it.

nothing is sent unless you ask for it:

  • off by default. reach is silent until the person who runs the campaign turns it on, per campaign.
  • one tap to stop. every message carries a link that turns its channel off and keeps it off — a settings reset will not bring it back.
  • quiet hours. messages that would land overnight are held until the window closes; by default the world stays silent from late evening to morning, in your local time.
  • a trickle, not a stream. at most one message per channel in any eighteen-hour window, no matter how much the world moves while you are gone.
  • dormant campaigns stay dark. a finished or sleeping campaign never reaches out.

the letters themselves stay in character — there is no disclaimer stapled to the bottom of a message, no "this was generated" footer. the explanation lives here, on this page, where a curious reader can find it. that is the trade: the world keeps its voice, and the workings are never hidden.