The Game Master Is a Language Model: Building a Tabletop Game on LLMs
My wife — a seasoned product designer — and I built a tabletop-inspired RPG that uses an LLM as the Game Master. What started as a proof-of-concept quickly became a revealing experiment in what language models can do to interactive software. This is the first of a series of posts about what we learned.
You can play the game right now at llmrpg.jinyooai.com.
What the Game Is
At its core, this is a turn-based RPG that runs in your browser. Player characters include a warrior and a mage. Soon enough, enemy goblins appear and you must battle them. So far, so familiar.
Here's where it gets interesting: when it's your turn, there's no action menu. No list of four moves to pick from. Instead, you get a text box, and you type whatever you want your character to do. In plain English.
I throw my shield at the goblin's legs to trip it.
An LLM reads your input, considers the current game state and what happened on previous turns — and resolves your action. Then it narrates the result, like a game master storytelling at your table.
The Power of Freedom
Instead of a boring action like "attack with my sword", consider the following:
Be alert and ready myself to counterattack any enemies going for my mage.
I did not program this interaction. There is no code that specifically handles this "counterattack" action.
And yet, when an enemy tries to lunge at the mage a few turns later, the warrior deals damage before it can even reach the mage. The Game Master — an LLM — remembered the warrior's declared intent, and resolved the next game state as the warrior counterattacking.
Even the most ambitious RPGs are bounded by how they are programmed. Baldur's Gate 3, a game celebrated for player freedom, ships with hundreds of spells, interactions, and branching decisions. It's extraordinary. But it's still finite. Every possible action was anticipated, designed, animated, and tested by a team of game developers. But generative AI can provide more freedom to the players.
[A warrior prepring a counterattack]
[Interacting with the environment]
What LLMs Bring to the Table
There are three specific properties of LLMs that make this game work.
You Don't Need an Action Menu
Most obviously, LLMs understand natural language.
In a traditional game, you would need a dropdown of actions that are predefined.
On the other hand, an LLM enables the "action menu" to be, well, English.
More importantly, it understands intent — not just what you said, but what you meant, across turns. A declared intention from two rounds ago shapes how the GM resolves something now. No traditional action system handles that.
It Reasons About the World It Creates
Here's one of my favorite interactions from playtesting:
A player, before making any action, asks: "Is there anything notable in the environment?"
This isn't an action — it's a question. So the GM responds without advancing the turn: "You notice some barrels stacked against the far wall."
Then the player can: "Cast fireball towards the barrels."
The GM resolves it: the barrels explode, dealing massive area damage to the enemies nearby.
Nobody scripted a barrel-fireball interaction. The LLM generated the environmental detail on the fly, then — when the player referenced it a turn later — it remembered the barrels existed, inferred that barrels are probably wooden and flammable, reasoned about the fireball's effect, and narrated the explosion.
The AI GM can Surprise You
A player types: "Swing my sword."
Nine times out of ten, this resolves as you'd expect. Your character swings, the enemy takes damage, the story continues.
But sometimes — rarely, unpredictably — the GM narrates something like: "You swing with confidence, but your foot catches a gnarled tree root mid-stride. The momentum carries your arm around and you pommel yourself squarely in the jaw. Your allies wince."
Self-damage. From a basic attack. Because the GM decided this was a moment for a little chaos.
This is what makes the game feel alive. An LLM doesn't just mechanically resolve inputs — it narrates. It reads the situation, decides when a turn should be routine and when it should be surprising, and adds texture the way a human DM would. You never quite know what's going to happen, even with simple actions. That unpredictability is what keeps players at the table.
Why Now
A year ago, this game would have been a frustrating demo. LLMs weren't fast or cheap enough to run coherent multi-turn sessions at game speed, and the inconsistency would have broken immersion constantly. That's changed. And the speed question turns out to be a big deal for game feel — a 10-second pause between your action and the GM's response isn't just annoying, it changes how players engage entirely. That's what the next post in this series is about.
But the bigger picture goes beyond games. The pattern — open-ended human input, reasoning over accumulated context, coherent generated response — is a design primitive for a new category of interactive software. Every current example of this pattern is still early and rough. Games happen to be the most legible way to demonstrate what it can do.
Try the game. Type something ridiculous and see what happens.