The Words Come Later

May 3, 2026

For the past year, I’ve been writing private devlogs to a small mailing list while building Bottle Episodes. From here on, I’m writing them publicly.

This is the year that came before.

Origin

I’ve spent about a decade designing multi-person experiences. Some of them eventually looked like software. Most of them didn’t.

Immersive theatre is a system. So is an EMT call. So is a flight deck during boarding. So is a murder mystery party where five people independently decide to kill the same character with Christmas decorations.

Run enough social experiences and eventually certain patterns stop feeling coincidental. They all reduce to the same underlying questions: Who knows what? Who possesses what? Where is everyone? What actions are currently possible? How does the world update consistently across everyone’s understanding of it?

The content changes. The underlying structure is surprisingly stable.

Looking back, most of the work I was actually doing had less to do with storytelling itself and more to do with creating the conditions that make group experiences work: enough structure for people to feel safe, enough freedom for people to feel agency, and enough coherence underneath the surface that the experience itself could feel like a memorable story.

Bottle Episodes came out of wanting to build those kinds of systems computationally.

Before Software

In 2019, my best friend Claudia and I adapted one of our murder mystery parties into immersive theatre at The Annoyance in Chicago.

The audience thought they were watching improv. Behind the scenes, it was a synchronized social system.

There were six concurrent groups, six independent motives, and five different versions of the same murder. Behind the curtain was a choreography of who knew what, who possessed which objects, who was allowed to say certain things, and when information was permitted to move through the room.

Every group believed they had uniquely murdered the victim. The reveal was that everyone hated him enough to independently decide to do it.

At the time, I didn’t think of any of this as systems architecture. But in retrospect, I was already modeling synchronized social state manually.

Glide

In May 2025, my MBA program required a final project. I wanted to know whether the kinds of social systems I’d spent years orchestrating physically could exist computationally.

I started building in Glide expecting to sketch ideas for someone more technical to implement later. Instead, the architecture stabilized much faster than I expected.

At first I asked ChatGPT for schema suggestions, but I kept rejecting most of what it generated because the systems felt overly specific and difficult to generalize. I wasn’t trying to build features yet. I was trying to identify the smallest set of primitives capable of expressing the kinds of multiplayer interactions I cared about.

Then I learned how to make the UI write directly into an action log table.

That changed everything.

Once actions became the canonical input to the system, most of the architecture started unfolding naturally from there. The action log became the source of truth. Everything else could be derived.

Movement propagated automatically. State updated consistently. Available actions emerged dynamically from world state instead of being hardcoded into the interface.

Three weeks later, I had a functioning multiplayer game loop.

At the time, I didn’t know terms like event sourcing, deterministic replay, declarative systems, or PUSH architecture. I only knew the system suddenly behaved more coherently.

The words came later.

What The Engine Actually Does

Traditional game engines are optimized around rendering worlds. Bottle Episodes is optimized around synchronizing social state.

The engine continuously computes what each player knows, what actions are legally possible from their perspective, and how the world changes for everyone after each decision.

State is derived from deterministic event history. Mechanics live in templates instead of hardcoded systems. The runtime recomputes legality continuously from shared world state as events propagate through the system.

From the beginning, I was intentionally designing around composable primitives because I wanted the architecture to support multiplayer experiences I hadn’t thought of yet.

I didn’t build a separate inventory system. Items exist inside locations. Some locations happen to be rooms. Some happen to be users. Some happen to be abstract item slots attached to users.

Doors are items composed of two door-side items. Room adjacency is derived from where those door sides exist spatially. Ownership is derived relationally. Visibility determines whether actions can even perceive those relationships.

The fewer special cases the system contained, the easier it became to evolve. That mattered because the primary challenge stopped being synchronization itself. It became iteration speed.

Playtests

In September I joined a local accelerator program primarily because it gave me access to something extremely useful: a consistent playtest cohort.

By that point the architecture had stabilized enough that the surrounding experiences could evolve rapidly around it. Increasingly, the mods themselves became probes testing the boundaries of the engine underneath them.

I watched closely for what made people lean forward, what made them replay, and what social dynamics emerged naturally.

Some of the discoveries surprised me.

Players treated murder as slapstick comedy. But resource scarcity became emotionally brutal. A group committing violence together felt mischievous. A group silently deciding who to let starve felt paralyzing.

The social framing changed everything.

I also learned players would not tolerate large amounts of text no matter how personalized it was. I cut enormous amounts of narration because people consistently wanted to get back into the social dynamics themselves. I remember the moment when my accelerator cohort switched from politeness to genuine engagement. One of the leads muttered “let’s go again” under his breath with the same frustration I recognized from when he lost a hand of poker.

The architecture itself changed surprisingly little throughout most of the playtests. The surrounding experiences changed constantly.

At one point, a playtest revealed that turn cadence was slowing the energy of the room. So I added real-time mode.

The change took about thirty minutes.

The same schema already supported both because the mechanics lived in templates and derived state rather than hardcoded presentation logic. The underlying world model didn’t care whether actions resolved in turns or real time.

That reinforced something I had suspected early on: the architecture was behaving more like generalized infrastructure than a single game system.

AI Changed The Bottleneck

Over the past year, multiple people have contacted me trying to build AI-native versions of this category. Most of them seem to run into the same problem quickly.

LLMs generate. They do not resolve.

Multiplayer state is a deterministic problem.

The world has to know what is true before anyone’s screen updates.

Player A locks the door. Player B walks toward it. The engine has to know the door is locked before B’s screen renders — not after, not maybe, not with 95% confidence.

AI made narrative cheap. Coordinated multiplayer state became the actual bottleneck.

The more generative systems expand, the more synchronization, legality, perspective computation, and shared world truth start to matter.

That’s the layer I’m building.

Where Things Stand Now

The engine now contains deterministic replay, declarative multiplayer mechanics, server-authoritative state, composable primitives, perspective-aware action systems, and a fully event-derived world model.

3,472 commits. 1,643 tests. Sole contributor.

The architecture I built in Glide in three weeks still exists underneath all of it, with only one core primitive swapped out.

Most of the work since then has been formalization: making the abstractions cleaner, making the replay model safer, making the primitives more composable, and making the system easier to evolve without introducing special cases.

AI accelerated implementation substantially. But the core architectural ideas were already present before most of the programming vocabulary arrived.

There’s a public demo and a small organic following. Still constant playtesting and iterating toward product market fit, letting evidence with real users inform my design decisions.

I think multiplayer social systems are much larger than the current tooling ecosystem assumes. And I think the infrastructure underneath them barely exists yet.

Bottle Episodes is my attempt to build it.