Why a Tag-Based GM Protocol

One of the earliest decisions in Fate’s Edge was to keep the GM logic legible — no hidden heuristics, no opaque prompt soup deciding what happens at the table. The result is a tag-based protocol: every GM action, from a scene transition to a skill check outcome, is expressed as a small, typed, test-covered directive.

Here’s the part I didn’t expect when I started, and which I now think is the most interesting thing about the architecture.

The whole game is 24 verbs

The directive set that drives the AI GM currently has 24 distinct tag verbs (25 spellings — ADD is an alias of APPLY). Not 24 per subsystem. Twenty-four total, for the entire game.

That’s things like [CALL FOR ROLL], [SET DV], [SET POSITION], [TIMER] and [TICK TIMER], [ADD SB] and [SPEND SB], [ENCOUNTER START] and [ENCOUNTER RESOLVE], plus the bookkeeping verbs for NPCs, facts, revelations, tokens and mood. Sort them and they fall into four piles, which will look familiar if you’ve read anything else I’ve written about this system:

Three of those four piles are the resolution system and they cost eleven verbs between them. The other thirteen are bookkeeping — who’s in the scene, what’s been revealed, where the tokens are — and bookkeeping is the part that grows with content rather than with rules.

Now notice what isn’t in there. There is no [CRAFT] verb. There is no [SIEGE] verb, no [TRAVEL] verb, no [RITUAL] verb, no [MASS COMBAT] verb. Crafting, travel, warfare, downtime, magic and social conflict are all fully supported, and none of them contributed a single directive to the protocol.

They didn’t need to, because none of them are separate subsystems. Crafting is a roll that fills a clock. Travel is a roll that fills a clock. A siege is a roll that fills a clock — when I wrote a mass-combat module recently I went in expecting to bolt a wargame underneath it, and found instead that an army is a Follower with a Capability rating and two clocks, and that a general’s order is an ordinary roll whose successes fill an objective by two segments, one, or none. The engine never learned anything new. It was pointed at something bigger.

This is the actual payoff of self-similar rules

I’ve written before that the rules are built from four objects used at every scale, and that if a new subsystem wants its own resolution mechanic I treat that as a bug report about the core. That’s a design argument, and design arguments are cheap.

Here’s the engineering argument, which isn’t.

A protocol has to enumerate what it can express. If crafting had its own resolution mechanic, the tag set would need crafting verbs, and the AI would need to know when to emit them, and the parser would need to handle them, and the test suite would need to cover them, and the docs would need to explain them — and then the same again for warfare, and again for travel, and again for rituals. That’s the shape most game software ends up in: a protocol whose size is proportional to the number of things the game can do.

Because the rules are self-similar, this one’s size is proportional to the number of things the game is, which is four. Adding a whole warfare module to Fate’s Edge cost the protocol zero new verbs and the test suite zero new cases. That is not a small thing. It’s the difference between a system that gets harder to extend as it grows and one that doesn’t.

The corollary is worth stating plainly for anyone building on this: if you write an extension that needs a new tag verb, you have probably not found a gap in the protocol. You have probably found a place where you invented a mechanic you didn’t need. That heuristic has been right every single time I’ve tested it against my own work, usually to my mild annoyance.

Tags all the way down

There’s a pleasing rhyme here that I’d like to claim I planned.

The magic system in the SRD is itself tag-based — spells are built by combining element tags with effect tags, [FIRE] with [BARRIER], [AIR] with [DEFEND], and the difficulty falls out of how many tags you’ve stacked. Adversary abilities are tagged too: [AMBUSH], [REINFORCEMENT], [TIMER], [BARGAIN]. The fiction composes small typed primitives into larger effects.

And then, a layer down, the engine that runs it composes small typed primitives into larger effects, using the same idea for the same reason: a closed vocabulary you can enumerate is a vocabulary you can test, teach, and hand to a stranger. A GM learning [WARD] and a contributor learning [TICK TIMER] are doing the same kind of learning.

Why deterministic matters more than “AI”

The protocol is deterministic and the tests are the point: 22 test files cover the bot’s modules, and the directive processor is a few hundred lines of ordinary, boring, readable code.

That means the AI GM is optional, not load-bearing. Everything the model does, it does by emitting directives that a human GM could have emitted, from state a human GM could have read. Swap in a different model, a scripted adventure module, or a person with the rulebook open, and the same protocol still holds. Nothing about the game’s behaviour lives inside the model’s weights — the model chooses which legal directive to emit, and that’s all it does.

This is also the honest answer to the reasonable worry about an LLM at the table. It isn’t “trust the model.” It’s “the model can only say 24 things, all of them typed, all of them checked, and all of them things you could have said yourself.” When it does something wrong, you get a wrong [SET DV] you can see and argue with, not an inscrutable vibe. That’s a much better failure mode than the alternative, and it was only affordable because the ruleset underneath is small enough to enumerate.

What’s next

The directive set is deliberately open to extension where extension is genuinely warranted — new narrative tools, new hooks into world state, better ergonomics for things the protocol can already express clumsily. What I’d ask of a contributor is the same thing I ask of myself: before adding a verb, check whether the thing you want is a roll, a clock, an outcome, or a piece of world state wearing a costume. It usually is.

The Tag DSL guide on the dev portal is the best jumping-off point, and the bot repository has the processor and its tests if you’d rather read code than prose. I’d genuinely rather receive a pull request that deletes a verb than one that adds three.