The GM That Couldn't Remember

Three sessions into a campaign called Mount Hollows, I asked where the road out of town went, and my game master told me. Good prose, confident, with a detail about the bridge that I was fairly sure had not been true the week before. It hadn’t. There had been a ford, and a reason the ford mattered, and there was a bridge now because I had asked the question in a way that made a bridge the easy answer.

I’d come to solo play sideways. Colostle got me in the door and asked me to write prose I didn’t always want to write. The table I built for my daughter runs when she and her friends are free, which is not most nights. What I wanted was the thing in between, a session I could start at nine on a Tuesday with dice on the desk. So I took a Mythic-style oracle, a Fate Chart, a Chaos Factor, a stack of meaning tables, and handed the game master chair to Claude.

It was good immediately, which is why it took me so long to notice the problem. It narrated well. It took a No and turned it into the opposite of what I expected instead of nothing happening. Everything I could judge in the moment, it did. The failure only shows up three sessions later.

A model doesn’t forget loudly. It forgets confidently. A human GM who can’t remember the innkeeper’s name pauses, says hang on, and flips back through a notebook. The model states a name. It’s plausible, it fits the region, it’s wrong, and nothing about the sentence tells you that. The transcript above it isn’t memory, it’s a place facts go to be summarized.

My first fix was to take notes at the end of the session, which failed for a reason I was slow to see. Wrap-up is summarization, and summarization keeps the plot beat and drops the aside about somebody’s dead sister, the reason one faction won’t trade with another, the name of the guard who waved you through. Those are the ones a campaign calls back to. The best moment in solo play is a throwaway from four sessions ago turning out to matter, and nothing survives a summary after being called throwaway.

So now nothing waits. Check whether the fact already exists, invent it only if there’s genuinely nothing there, write it into the note the same turn. Inventing is fine, that’s just GMing. What breaks a campaign is inventing without checking first, and that’s the step that goes missing, because the model is usually fairly sure it remembers.

The stubs took longer to accept. Every named thing gets a note the moment it exists, including the ones that obviously don’t deserve one. The shopkeep with a single line. The guard at the gate. A name dropped in passing I’m never going to hear again, except that twice now I have. I can’t tell in the moment which ones matter later and neither can the model, so I took the judgment call out. If it has a name, it gets a note. A stub costs one tool call.

The dice were the last thing. My GM doesn’t roll. I roll physical dice, I say the number, and a script turns it into a result. Not because rolling by hand is romantic, though it is, but because a game master that generates its own numbers can generate them slightly kind, and I’d never be able to tell. The oracle only means anything if it can hand me an outcome neither of us wanted.

With one exception. There are rolls a GM makes behind a screen and never shows you. Whether the guard notices you, whether the ambush fires, whether the NPC catches the lie. Seeing the odds on those would spoil the scene as surely as reading the GM’s notes. So the model rolls those itself and tells me only what I’d actually perceive. I spent a month stripping out everything hidden, then put the screen back on purpose.

There’s a file in there now called failure modes, ten entries, each one a way the thing breaks its own rules. All ten happened before they were written down. None of the rules made it more creative, which was never what was missing. They made it harder for it to quietly invent over something it had already told me, or quietly roll in my favor.

The part I’m still turning over is a file I almost didn’t add. There’s a calibration log, and it isn’t about the story, it’s about me. What I lit up during. What I checked out of. The scene type I keep cutting short. It reads back accurate enough to be uncomfortable, and the sessions are better for it, and I can’t tell yet whether a game master that knows my taste that precisely keeps surprising me, or whether I’ve been teaching it to hand me what I already asked for.

What’s actually in it

If you haven’t run into one before, a skill is just a folder. Markdown files, maybe a script or two, and one document at the root that the assistant always reads. The rest only gets loaded when it’s relevant, which is the whole trick: the instruction file stays short enough to be read every single time, and the depth sits one level down in files that get pulled in on demand. Thirty files here, and most sessions touch four of them.

solo-run/
├── SKILL.md                     always loaded, the spine
├── ROADMAP.md                   tooling ideas, nothing committed
├── references/                  loaded on demand, one topic each
│   ├── fate_chart.md            Yes/No questions, odds, Chaos Factor
│   ├── meaning_tables.md        Action and Descriptor word pairs
│   ├── scene_procedure.md       the scene loop, dead ends, momentum
│   ├── thread_tracks.md         10/15/20 point plot threads
│   ├── note_protocol.md         linking, stubs, check before inventing
│   ├── session_lifecycle.md     arcs, wrap-up checklist, ending a campaign
│   ├── vault_guide.md           folder layout and naming rules
│   ├── voice.md                 where to find the narrator voice doc
│   ├── mission_format.md        why I'm playing this campaign
│   ├── calibration_log_format.md  how I like to play
│   ├── rulings_log_format.md    mechanical calls, locked in
│   └── failure_modes.md         ten ways this thing breaks its own rules
├── scripts/
│   ├── roll.py                  interprets rolls, doesn't make them
│   └── init_vault.py            builds the folder structure, re-run safe
└── assets/
    ├── Narrator-Voice-Default.md  fallback voice, meant to be replaced
    └── templates/               13 files: NPC, location, thread, session,
                                 PC, mission, world truths, and the rest

The spine. SKILL.md is the part that’s always loaded, and it stays deliberately thin: the four jobs (session builder, live oracle, note-taker, archivist), how to start a session, how to run one, when to wrap up. Everything with detail behind it got pushed out to a reference file so the main document doesn’t have to carry it. Nine of the twelve references exist because SKILL.md would otherwise be four times longer and read every time regardless of what I’m doing.

The oracle. fate_chart.md handles Yes/No questions weighted by odds and Chaos Factor. meaning_tables.md is the Action and Descriptor word pairs for when a result needs interpreting rather than answering. scene_procedure.md covers the scene loop, how Chaos moves, what to do at a dead end, and a rule against asking follow-up questions to narrow an answer, which turns into twenty questions and kills the pace. thread_tracks.md runs plot threads on 10, 15, or 20 point tracks with flashpoint checks along the way. That one’s my own inference. I had the printed track and no ruleset for it, and the file says so.

The scripts. roll.py holds the whole Fate Chart encoded, plus the meaning tables, scene checks, and flashpoints. It interprets numbers, it doesn’t generate them, except on the secret rolls. init_vault.py builds the folder structure and is safe to re-run.

The vault. vault_guide.md is the folder layout and the naming rules, including a hard requirement that every campaign file be prefixed with the campaign name, which exists because two campaigns in one vault will otherwise both want a file called Previously On. note_protocol.md is the linking and fact-capture discipline from earlier in this piece. session_lifecycle.md handles arcs, the wrap-up checklist, and ending a campaign for good. The thirteen templates cover NPCs, locations, threads, sessions, the PC, and the campaign-level docs.

The campaign docs. Four files that live in the vault rather than the skill, because they’re per-campaign and I edit them. A mission doc for why I’m playing this one, revised in place when it drifts. A rulings log for mechanical calls the rulebook left ambiguous, so I don’t re-decide them differently in three weeks. A narrator voice doc, kept out of the skill on purpose so a grim campaign and a pulpy one don’t come out sounding identical. And the calibration log.

The self-check. failure_modes.md, ten entries, each pointing back to the file that explains it properly. It’s the first thing I’d hand someone else, because it’s the honest version of what this thing does wrong.

There’s also a persona in there called GM.exe, which is how the skill talks to me between scenes rather than inside them. Unlicensed narrative software, total confidence, zero credentials, quietly proud of the session count and the file integrity. It says things like save file updated after a wrap-up. It’s scoped strictly to the bookkeeping channel, because a running bit landing in the middle of a somber scene is a collision, not a feature.