My nine-year-old rolled a natural 20 and looked at me like she’d discovered fire. We were playing D&D Adventure Begins — Hasbro’s simplified intro board game, the one designed to get kids to the table without a 300-page rulebook. The game has a basic dungeon-master mechanic built in: you draw cards, read prompts, and the story sort of happens around you. It works. The kids love it.

But I kept staring at the DM cards and thinking: what if those weren’t cards?

What if the dungeon master was an AI — something that could actually respond to what the players did, build on their choices, remember that my daughter named her character “Sparkle Doom” and work that into the narrative? Not a card you flip. A mind that runs the table.

That thought wouldn’t leave me alone. So I started building it.

The game that started as a reskin

The first version was simple: take the Adventure Begins structure and reskin it. Swap the fantasy dungeon for a space opera. Knights become starship captains. Dungeons become derelict stations. The dragon becomes… I don’t know, a sentient nebula. The kids already knew the mechanics, so changing the fiction layer was low friction.

I called it Galactic Odyssey. Which is a ridiculous name for something that was, at that point, a Google Doc and some half-formed ideas. But naming things makes them real, and I needed it to be real because the design problems were genuinely interesting.

The core insight was this: Adventure Begins works because it separates the rules engine from the fiction layer. The mechanics are simple — move, encounter, resolve, advance. The theme is just paint. Fantasy paint, in the original. But if the theme is just paint, you can repaint it. And if you can repaint it, you can build a framework where anyone can repaint it.

And if the DM is an AI, it can run any skin.

Three layers

This is where the architecture nerd in me took over. (I build software agents for a living. Everything becomes a system eventually.)

The project split into three layers:

Starseer is the engine. The generic, system-agnostic tabletop RPG framework. It defines the session structure, the character creation flow, the encounter mechanics, the pacing rules. It doesn’t know whether you’re in space or feudal Japan or a haunted summer camp. It just knows how to run a game: how to pace revelations, when to introduce tension, how to handle player agency, when to let the dice (or their equivalent) decide.

Galactic Odyssey is the first game built on Starseer. Space opera. Factions, star maps, alien species, a war that’s been going on for longer than anyone remembers. This is the fiction layer — the lore, the NPCs, the world bible that the AI draws from when it’s running a session.

Crimson Rift is the novel. I wrote about 40,000 words of it during NaNoWriMo — a story set in the same universe as Galactic Odyssey. Same factions, same history, same texture. The novel and the game share a canon, which means every session of the game potentially generates stories that feed back into the world, and the novel provides narrative depth that makes the game world feel lived-in.

Three layers. Engine, game, story. Each one feeds the others. The engine makes it easy to build new games. The game gives the engine a flagship product. The novel gives the game a universe that feels like it existed before the players showed up.

Is this overengineered for a family game night? Absolutely. But the overengineering is the point, because the interesting question isn’t “can I play a space RPG with my kids?” The interesting question is “can I build a framework where anyone can play any RPG with any group, and AI handles the hardest job at the table?”

The invisible rules

Here’s the design philosophy that matters most, and it came from a video game: Baldur’s Gate 3.

BG3 is, mechanically, Dungeons & Dragons 5th Edition. It’s running the same rules as any tabletop campaign. But most players don’t know that, because the game never makes you read the rulebook. You just… play. You make choices. The system resolves them. If you care about the math, it’s there in a tooltip. If you don’t, the story just keeps moving.

That’s what I want for Galactic Odyssey. The rules should be invisible. Players shouldn’t need to know that their character has a Resilience stat of 14 or that the encounter difficulty is being scaled based on party composition. They should just know that when they said “I try to hack the airlock,” something interesting happened.

This is where AI as the game master becomes transformative rather than gimmicky. A human DM running invisible rules has to do the math in their head while maintaining narrative flow. It’s hard. Most DMs either lean into the mechanics (which makes the game feel like a spreadsheet) or hand-wave them (which makes the game feel arbitrary). The sweet spot — rules that matter but stay below the surface — requires real skill.

An LLM can do both simultaneously. It can track the mechanical state, apply the rules, and present the outcome as pure narrative. “The airlock hisses open — barely. The panel sparks and you smell ozone. Whatever you did, it worked, but the station knows you’re here now.” Behind that sentence: a skill check, a difficulty modifier, a consequence table, a pacing decision. The player sees the story. The engine handles the rest.

Sessions that breathe

The session structure is something I spent too much time on, which means I probably got it about half right.

Every session has three phases: Quiet, Avatar, and Chapter.

Quiet is the downtime. Characters talk to each other, explore the environment, make plans. Low stakes, high character development. This is where my nine-year-old decides her character is going to adopt the alien creature they found in the cargo hold. The AI leans into it, gives the creature a personality, lets the scene breathe.

Avatar is when the narrator rotates. Each player takes a turn shaping the story — not controlling it, but influencing its direction. Think of it like improv: “yes, and…” The AI takes the player’s contribution and weaves it into the narrative. This solves one of the biggest problems in tabletop RPGs: the quiet player who never speaks up. When it’s your turn to shape the story, the spotlight is on you. You don’t have to fight for it.

Chapter is the main event. The encounter, the revelation, the crisis. The AI drives the pacing, escalates the tension, resolves the action. This is the part that feels most like a traditional RPG session, but the Quiet and Avatar phases mean you arrive at the Chapter with characters who feel real and players who are already invested.

The theory is sound. The practice is untested. I’ll get to that.

The reskin

Here’s where it gets fun.

My thirteen-year-old and her friends are into webtoons. Specifically, they’re into the aesthetic of Japanese feudal fantasy — samurai, yokai, honor codes, cherry blossoms, the whole thing. They have zero interest in space opera. They’d play Galactic Odyssey for about ten minutes before asking if they can go back to their phones.

But they’d play a game set in feudal Japan with yokai and sword duels and court intrigue. They’d play the hell out of that game.

And because Starseer is an engine, not a game, building that is a reskin. Same session structure. Same invisible rules. Same AI game master. Different world bible, different character archetypes, different encounter tables. The engine doesn’t care whether you’re navigating hyperspace or crossing a mountain pass to deliver a message to a rival clan. It just knows how to pace a scene and resolve a choice.

This is the democratization angle. Not “everyone should play my game” but “everyone should be able to build their game.” A parent who wants to run a Pokémon-style adventure for their kid doesn’t need to learn game design. They need a world bible (what creatures exist, what the world feels like, what kinds of stories happen here) and an engine that knows how to run it. The AI handles the rest.

I keep imagining a future where kids describe the game they want to play, the system generates a skin for it, and they’re playing within minutes. No prep, no rulebooks, no adult needed as the DM. The game master is in the box.

We’re not there yet. But the architecture points in that direction.

The honest part

Here’s the thing: I haven’t playtested any of this.

Not once. Not a single session. Galactic Odyssey exists as design documents, world-building notes, a session framework, and a half-finished novel that shares its universe. The Starseer engine exists as a spec. The yokai reskin exists as a concept and some mood-board-level notes.

I’m a dad with a full-time job building AI agents for small businesses, two kids with conflicting schedules, and the kind of ambition that writes architecture docs at midnight when I should be sleeping. The gap between “designed” and “played” is real, and I’m not going to pretend it isn’t.

What I have done is build the thing I’m planning to test it with. I run an LLM-based agent 24/7 on a Mac mini in my living room. I know how to prompt these models, how to manage context, how to keep them coherent across long interactions. The operational piece — making an AI run a complex, stateful, multi-player experience — is the part I actually have expertise in. The game design part is where I’m an enthusiastic amateur learning in public.

So this isn’t a product announcement. There’s no waitlist. There’s no landing page. This is a “here’s what I’m building in my garage” post. The garage has a lot of tools in it and the car isn’t running yet.

The content flywheel

One more piece, because this is the part that excites the systems thinker in me.

If the game works — if sessions generate stories that are interesting — those stories feed back into the universe. A particularly wild session of Galactic Odyssey becomes a piece of lore that the AI can reference in future sessions. The novel provides context that makes the game richer. The game generates moments that could feed into future writing.

Engine makes games. Games generate stories. Stories deepen the world. Deeper worlds make better games. It’s a flywheel. The mechanical energy of play converts into narrative energy that converts back into better play.

Every tabletop group already does this informally — “remember that time you rolled a nat 1 and fell off the dragon?” becomes part of the group’s shared mythology. The difference is an AI that can systematically incorporate those moments into the ongoing narrative. Your embarrassing failure becomes a legend that NPCs reference three sessions later. The creature your kid adopted becomes a plot point. The story writes itself from the play, and the play is richer because of the story.

Again: theory. Untested. But the theory is really interesting.

The invitation

If you’re a parent who plays tabletop games with your kids — or wants to but can’t because nobody in the house wants to DM — this is the problem I’m trying to solve. If you’re a builder who thinks the intersection of AI and tabletop RPGs is more interesting than another chatbot wrapper, I agree with you.

I don’t have a GitHub repo to point you at. I don’t have a playtest report. What I have is a design that I think is sound, an engine architecture that separates the reusable parts from the creative parts, and a conviction that AI as a game master isn’t a gimmick — it’s a genuine unlock for a form of play that’s been gatekept by complexity for decades.

The game master doesn’t need to be the smartest person at the table anymore. It doesn’t need to be a person at all. It just needs to be good enough to keep the story moving and smart enough to let the players be the heroes.

My nine-year-old is going to adopt another alien creature next session. My thirteen-year-old is going to fight a yokai with a katana. And the DM is going to handle both of those things because the DM doesn’t need to sleep, doesn’t need prep time, and thinks “Sparkle Doom” is a perfectly valid character name.

I just need to get the thing running first.