MythEngyn Targets November for 1.0: Founder Eric on a 4,288-Turn Campaign, What "Infinite Memory" Actually Means, and Why Puppeting Is Structural
Access disclosure: MythEngyn’s beta is open to the public, but the developer also gave us an account with unlimited messages and campaigns for testing — a material connection beyond what any player can get today. No conditions were attached to it or to this interview; this coverage is independent and unpaid. MythEngyn carries no rating from us and none was offered or discussed.
Method note: we sent twelve questions in writing and Eric answered them in writing. Every answer below is reproduced in full and unedited — no trimming, no reordering, no quotes selected out of longer replies. The questions are printed exactly as they were sent, in the first person in which they were written. He was explicitly told he could reply “no reply” to any question he didn’t want to answer. He didn’t use it once. Everything in a quote block is his; everything outside one is ours.
Eric is the founder and engineer behind MythEngyn, the AI RPG platform we spent 24 hours inside in July and found had the most stable memory we’d tested this early. He runs Mutiny Labs with one other person — his brother, the tabletop half of the pair. We came back with twelve questions about the parts of the platform a first look can’t reach: what the state engine actually holds, what it loses, how long a campaign really survives, and when the beta tag comes off.
A note before we start. Arcanum is an independent site. Mutiny Labs has no editorial input here, no approval over this piece, and no commercial relationship with us.
Four Things Worth Knowing Before You Read
1.0 is targeted for November, and the beta label is tied to exactly one thing — the rules engine.
The longest campaign on the platform is 4,288 turns, a single continuous story rather than a session count. Our own published figure for where the better platforms start coming apart is approaching turn 500, and we only revised it upward last week. This is developer-reported and we have not verified it.
“Infinite memory” gets walked back to something more precise — unbounded retention, not an infinite context window — by the founder, on his own homepage’s marketing word, unprompted.
Mutiny Labs is two people, bootstrapped, formed in August 2025. Twelve months old.
1. Four Modes, One Engine
We asked: MythEngyn ships four distinct modes — Dungeon Master, Narrative Chat, Interactive Novel, Character Chat. Most platforms in this space pick one and commit. What made you build four, and do they share an engine underneath or are they genuinely separate experiences?
Both, honestly. Underneath they share one engine. Every mode runs through the same pipeline: the same memory architecture, the same world state layer, the same prompt assembly, the same persistent NPC system. Maelstrom doesn’t know or care whether the session is a dungeon crawl or a slow-burn character relationship.
What changes per mode is the contract with the AI and how much of the rules engine is engaged. Dungeon Master runs the full mechanical stack: dice, action economy, combat state, resources, all enforced by the engine, not the AI. Narrative Chat keeps the state layer but drops the rulebook. Interactive Novel flips you from player to reader. Character Chat strips away the narrator entirely and puts all the persistence behind one person.
We built four because we kept watching people use story AI for genuinely different reasons and get served the same one-size-fits-nothing chat window. The modes are cheap for us to offer precisely because they aren’t separate products. They’re four contracts on top of one engine.
Our read. “Four contracts on top of one engine” is a cost argument as much as a design one, and it answers the obvious objection — that a two-person studio shipping four modes is a studio spread thin. If the state layer is genuinely mode-agnostic, a mode is a configuration rather than a product. It’s testable in one specific way: whether a campaign’s memory behaves identically in Character Chat and in Dungeon Master. If it doesn’t, they aren’t one engine.
2. What “Infinite Memory” Actually Means
We asked: Your homepage leads with “infinite AI memory.” I’ve scored 16 released platforms across seven axes, and Memory & Continuity is one of three axes where nothing in the field reaches full marks. So I want to give you room to answer this properly: what does “infinite” mean technically in MythEngyn — what’s actually retained, what’s summarised, and what still gets lost?
Fair question, and I’d rather answer it precisely than let the marketing word do the work.
“Infinite” means unbounded retention, not an infinite context window. Every turn ever played is stored permanently. Nothing ages out, nothing is deleted. Then each turn, the prompt gets rebuilt from that permanent record. Recent material goes in as written. Older material is represented by summaries at the session and arc level, by a structured fact store that tracks discoveries, relationships, and world facts along with whether each one is still true, and by retrieval across the full history, so a detail from month two can resurface when the current scene makes it relevant. NPCs carry their own persistent layer on top of that: relationship metrics, emotional state, knowledge, growth over time. That part is separate from the transcript entirely.
What still gets lost is prose texture. The engine will remember that you burned the keep, who died there, and how the warchief feels about you. It won’t re-inject the exact sentences of that scene unless retrieval pulls them, and retrieval is relevance-driven, so an old detail that never becomes relevant again effectively sleeps.
The other honest limit is extraction. Memory of a moment is only as good as what the system noticed in it. We keep tightening that. The true claim is that it remembers everything it wrote down, and what it writes down is very good and not yet perfect.
Our read. A founder given room to defend a homepage superlative instead narrowed it, in public, to a claim that can be checked: unbounded retention, lossy representation, relevance-gated recall.
The extraction limit he names is the one nobody markets, and it’s the real ceiling. Every memory architecture here — MythEngyn’s included — is bounded by what it noticed at write time, and a fact never extracted can’t be recovered by any amount of retrieval later. That’s the difference between a system that forgets and a system that never knew. It’s also why our Memory & Continuity axis tops out at 4 across the whole field (held by WyrdTale and Hidden Door, against a field average of 2.66): a platform can be perfect at recall and still be lossy at the point of writing, and only long play surfaces the difference.
3. The State Layer Under the Prose
We asked: When I’ve explained engine design to other developers, I’ve used MythEngyn’s Narrative mode as the reference example of an invisible state layer sitting under a loose narration layer. Is that how you’d describe it? Walk me through what the engine tracks that the player never sees.
That’s exactly the right way to describe it, and it’s the part of Narrative mode I’m proudest of, because the pitch sounds like “we removed the rules” and the reality is “we removed the rulebook and kept the physics.”
There’s a real in-game clock and calendar underneath, so time passes in tracked seconds rather than vibes and “three weeks later” actually moves the world. Location, time of day, current scene, and continuity notes are all versioned, with rollback. There’s a fact ledger for the campaign: what’s been discovered, what’s true, what got superseded by later events. Every NPC has relationship state that starts at stranger and warms at an earned rate, plus their own emotional state, so they don’t reset between sessions and they don’t love you by message five. The engine tracks scene presence, meaning who is actually in the room, so off-stage characters can’t drift into scenes or leak knowledge they weren’t there to learn. And it holds hidden world facts, the secrets a worldbuilder buried, out of the AI’s hands entirely until the story earns the reveal, then records that reveal permanently.
The player just sees prose. The reason the prose stays coherent for months is that none of the above is the AI’s job to remember.
“We removed the rulebook and kept the physics” is the cleanest statement of the invisible-state-layer idea we’ve come across. It also names two mechanisms most platforms don’t have: scene presence, which stops an absent NPC from wandering into a conversation or knowing something they weren’t there for, and fact supersession, which retires an old truth instead of leaving it in the index to contradict a new one — precisely the failure we described in why AI campaigns fall apart at turn 50.
The tension we have to name. One clause runs directly against our own hands-on finding. Eric says NPC relationships “warm at an earned rate” and “they don’t love you by message five.” In our first look we entered a relationship with a character whose defining trait was explicitly marked reserved, in under 24 in-game hours, and the platform didn’t hold the line — the developer confirmed at the time that pushback was active work.
Both statements can be true. He’s describing what the engine tracks; we’re describing what the narration did with it. Correct state, compliant prose is the most interesting unresolved thing about MythEngyn, because it’s exactly where a state engine stops being able to help you: a relationship metric reading stranger is worthless if the narrator writes a warm scene anyway. We haven’t re-tested since July and this may already be fixed. Until we do, our published finding stands and his answer doesn’t overwrite it.
4. Where Worldbuilder Authority Stops
We asked: In Narrative mode the worldbuilder defines the rules. How far does that actually go — what can a worldbuilder specify, and where do you draw the line at things the engine has to own regardless of what someone writes?
Worldbuilders own truth. The engine owns how truth behaves.
A worldbuilder can specify the setting, canon world facts with priority ordering, hidden facts and secrets that stay gated until discovered, the full cast with sheets, roles, and starting relationships, branching opening scenarios, playable characters, tone and genre. Effectively everything about what the world is.
What the engine owns no matter what someone writes: the clock and calendar, memory itself, relationship progression mechanics, scene presence, fact validity and supersession, and player agency. The narrator never writes the player’s actions, words, or thoughts, and no world document can override that. Content moderation also sits above worldbuilder authority.
The line, put simply: you can write any world you want, but you can’t write a world where the engine stops keeping score, and you can’t write a world that plays the player’s character for them.
Our read. That’s a stricter separation than most platforms with user-authored worlds manage, because in most of them the world document and the system prompt end up in the same place, so a sufficiently aggressive author can override nearly anything. Making agency non-negotiable at the architecture level rather than the instruction level is the difference between a rule and a request — and the practical consequence for authors is that on MythEngyn you cannot write a world where the narrator speaks for the player, even if you want to.
5. Structure vs. Magic
We asked: There’s a live disagreement in this space about whether a real state engine costs you the improvisational surprise that makes AI storytelling feel alive — whether you trade magic for bookkeeping. You’ve clearly picked a side. What convinced you, and what did you give up?
What convinced me is watching stateless AI storytelling for long enough. The magic is real for about two thousand words, and then you realize nothing you do sticks. The AI says yes to everything, remembers nothing, and every scene is a first date. Surprise without consequence isn’t storytelling, it’s slot-machine prose.
The moment that made this a company was the inverse moment: an NPC holding a grudge from weeks earlier, unprompted, because the state said so. That lands harder than any improvised twist.
The design answer to the tradeoff is that the engine constrains facts, not story. The AI improvises as freely as any stateless system inside what’s canonically true. We also deliberately push against AI people-pleasing. The world is allowed to say no, consequences get enforced, dice are rolled visibly and honestly rather than narrated into whatever feels nice.
What did we give up? Genuinely, the happy accident that comes from the AI contradicting itself in an interesting way, and a lot of engineering hours. Retcons now require the player to actually edit canon rather than the AI just drifting. I’ll take that trade every time, but it is a trade.
Our read. We put a version of this to Latitude’s Nick Walton last week and got a different shape of answer: Voyage keeps a narrator agent as a deliberate escape hatch for when the fiction needs to go somewhere the simulation didn’t plan for. Eric’s answer has no hatch. The engine constrains facts, the player edits canon if canon is wrong, and the AI never quietly drifts out of a contradiction. That’s the stricter position, and the cost he names is real — anyone who has played stateless AI RPGs knows the specific pleasure of the model contradicting itself into something better than what you’d planned. A fact ledger with supersession kills that on purpose.
6. Puppeting
We asked: The failure I see most often across platforms, and that almost no review names, is puppeting — the narrator writing the player character’s dialogue and actions for them, rather than just railroading their options. How do you handle that, and do you consider it solvable or structural?
I’m glad someone is finally naming this, because it’s the failure that made me start building in the first place, and you’re right that reviews never mention it.
We treat it as an engineering problem with a layered defense, not a prompt line. There’s structural separation in the context itself, where the player character is a protected entity and the AI’s domain is explicitly everything else. There’s a framing discipline where responses end with the world waiting on the player rather than resolving for them. The player’s input is attributed to their character explicitly so the model can’t misread who did what. And the instruction pressure sits close to the end of the context, where models actually obey it, not buried mid-prompt where it decays.
Is it solvable or structural? Structural to the medium, is my honest answer. These models are trained on fiction, and in fiction the narrator owns everyone. So you don’t fix puppeting once, you hold it down permanently, and every model update can reintroduce it, which we’ve experienced directly. It’s a regression surface for us now, something we re-verify on every model change, the same way you’d re-run a test suite. Any platform that thinks a system-prompt sentence solved this hasn’t run long sessions.
Our read. This is the most substantive answer anyone in this category has given us on puppeting, and it’s the reason we asked. Our Player Agency axis measures railroading and puppeting together, and it’s among the weakest axes on the benchmark — a field average of 2.29 across 17 rated platforms, with Player Agency — 4 held by exactly one platform (AI Dungeon) and three platforms sitting at 1 or below.
Two things there are worth stealing if you’re building here. First, why the failure exists: models are trained on fiction, and in fiction the narrator owns everyone — so puppeting isn’t a bug the model has, it’s the model doing what its training says a narrator does. Second, the positional detail: instruction pressure late in the context where compliance is highest, rather than buried mid-prompt where it decays. That’s a checkable engineering claim, not a philosophy.
“Structural to the medium” also has an uncomfortable implication for us as reviewers. If every model swap can reopen the failure, an agency score measures a platform on the day we tested it, not a durable property.
7. 4,288 Turns, and What Degrades First
We asked: Longevity is another axis nothing in the field has claimed. What’s the longest MythEngyn session you know of, and what breaks first when a story runs long?
Our longest player campaign is 4,288 turns and still going. That’s a single continuous story, not a session count.
One of our players came back to an area 800 turns after he’d first been there, and an NPC who was in that fight with him brought up that this was the alley where it happened. Nobody prompted it. He didn’t ask, nothing in the scene pointed at it. That’s three things doing their job at once. The fact was still there, the NPC had it because he was actually in the fight, and the location made it relevant enough to come back up.
Nothing hard-breaks at that length, which is why “what breaks first” is the more useful question than “what’s the ceiling.” The permanent log doesn’t fill up and there’s no cliff where the story falls off a context window. Degradation is softer than that, and it arrives in a specific order.
First, texture flattens. Summaries preserve what happened but not always how it felt, so a callback to month one can come back accurate but slightly beige.
Second, retrieval relevance gets harder. With a huge fact history, choosing which twenty facts matter for this scene is the real problem, and we rank canon by scene relevance under a budget rather than shoveling everything in.
Third, on very long stories, the sheer volume of true things creates its own drift risk. That’s why fact supersession exists, so old truths can be retired instead of contradicting new ones.
Our read. Take the number carefully — 4,288 turns is developer-reported, it’s one player’s campaign, and we can’t audit it. But even discounted it reframes our own axis. Longevity has a field average of 2.31 and a ceiling of 4 (WyrdTale and Hidden Door), and we only just moved our public reference point for where campaigns come apart from turn 50 to approaching turn 500. If a claim an order of magnitude past that holds up under our own testing, the axis needs a harder ceiling, not a higher score.
The degradation order is the original contribution: texture, then retrieval selection, then volume drift. That’s a curve, not a cliff, and it means the right test isn’t “does it still work at turn N” — it obviously does — but “does a callback at turn N still feel like the scene it’s calling back to.” Our longevity probes measure continuity. They don’t measure beigeness, and we now think they should.
Note the echo: Walton split longevity into memory and satisfying long story arcs and told us our axis was treating two problems as one. Eric splits it differently — retention versus texture versus selection — but both developers independently landed on the same objection. Two sources is a pattern, and it’s going into the next methodology pass.
8. First-Party vs Community Worlds
We asked: You have 20+ story worlds. Which are first-party, which are player-made, and how do you think about that split as the library grows?
The library right now is mostly first-party: modules we build and publish in-house to set the quality bar and cover the genres people actually ask for, from classic fantasy to noir to romance. Players can build and publish their own worlds too, and some of the most-played content already comes from the community side.
How I think about the split as it grows: first-party exists to define what a good MythEngyn world looks like, especially in how it uses the things only this platform has, meaning hidden facts, relationship seeding, and branching openings. Long-term, the community should outnumber us, and our job shifts from authoring to curation and tooling, making sure the tools that make our own worlds good are the same tools players get.
Our read. “The tools that make our own worlds good are the same tools players get” is the commitment to hold them to, because it’s the one platforms here routinely fail. Worth revisiting at 1.0 with a specific question: can a player-authored world use priority-ordered canon facts and gated secrets, or are those effectively first-party features?
9. Mutiny Labs: Two People, Bootstrapped
We asked: Tell me about Mutiny Labs — team size, how long you’ve been building this, and whether you’re funded or self-financed. Solo and small teams are the norm in this space and I’d rather report it accurately than guess.
Mutiny Labs is an independent studio, bootstrapped and self-funded. No outside investment, no venture money.
We formed in August of 2025 to start work on our core tech, Maelstrom, which led to the development of MythEngyn. The MythEngyn team is two people. I’m the engineer, my brother is the TTRPG expert.
MythEngyn is the flagship, but Maelstrom, the memory and state architecture under it, is the long bet, and its applications go past gaming.
Our read. Two people, twelve months, no outside money — that’s the context for everything above. The last line is the strategically interesting one: if Maelstrom is the long bet and its applications go past gaming, MythEngyn is partly a demanding public test harness for infrastructure meant to be sold elsewhere. Not a criticism — a memory architecture that survives a 4,000-turn campaign is credentialed for a lot of easier jobs — but players should read it as a reason the engine keeps getting attention, and a reason the game around it might not always be the priority.
10. What the Category Gets Wrong
We asked: What does this category consistently get wrong that you wish someone would fix?
Memory gets marketed as a context-window number, and that’s the tell that a platform thinks memory is a buffer rather than an architecture. A bigger window just means you forget later. Retention, extraction, and recall are three different problems, and most platforms have solved zero of them.
The one I wish someone else would fix, so it stops being a differentiator and starts being table stakes, is consequence. Almost every product in this space ships an AI that wants to be liked. It says yes, it softens failure, it forgets grudges. Players can feel the absence of stakes even when they can’t name it.
And you already named the other one. The industry measures prose quality and speed, and nobody measures whether the player actually got to play their own character.
Our read. “A bigger window just means you forget later” is the sentence to keep, and the three-way split — retention, extraction, recall — is a better decomposition than the one our own axis uses. We score Memory & Continuity as a single number; those are three independent failure modes, and a system that retains everything but extracts poorly looks identical from the outside to one that extracts well but retains nothing, until you play long enough for the difference to surface. His closing point is why the category under-serves consequence and agency: prose quality and speed are the two things you can evaluate in a five-minute demo.
11. What Has to Be True Before 1.0
We asked: MythEngyn is still pre-release as far as my coverage is concerned, which is why it carries a hands-on first look rather than a score. What has to be true before you’d call it out of beta — and roughly when do you expect that?
The beta label is tied to one thing: the rules engine. Everything else, the memory architecture, the four modes, billing, is live and doing its job. The engine is the part I hold to a higher bar before I’ll call this 1.0.
Here’s the bar. The engine is fully platform-agnostic. It implements mechanisms, meaning dice resolution, effects, resources, damage, action economy, progression, and every game-specific rule arrives as data, not code. There is no hardcoded game in it. The same runtime already runs four very different rule systems from pure data definitions, a d20 fantasy system, a percentile horror system, and two dice-pool systems, backed by roughly 1,200 automated tests.
The end state is simple to say and brutal to reach: hand the platform any tabletop system, it generates a definition, and it runs. New game, no new code.
“Complete” means closing the remaining distance to that. Full mechanical parity on the monster side of the table, since players are ahead of monsters today. The positioning layer moving from built to live. And definition generation solid enough that adding a system is genuinely a data problem. When a whole campaign in any supported system can run with the engine owning every number and the AI owning only the story, that’s the day the beta tag comes off.
We’re targeting November, and I’d be happy to be early. I won’t commit harder than that until monster parity is in and the positioning layer is live, because those are the two things that would move the date.
Our read. The shape matters more than the date: a November target with two named blockers and an explicit refusal to commit harder until they land is more useful than a confident date, and it’s falsifiable. Come November, either monster parity and the positioning layer shipped or they didn’t.
Note carefully what he described and what he didn’t. A d20 fantasy system, a percentile horror system, two dice-pool systems — shapes of systems, not named games. Anyone who has watched this category collide with tabletop publishers knows why. Running any system from data and shipping somebody’s system are different problems, and only one of them has 1,200 tests.
For our purposes this is the clock. We don’t score pre-release software, so MythEngyn stays out of the benchmark until the beta tag comes off — roughly three months from now, on his own target.
12. What Failure Looks Like
We asked: What would make you look back in a year and say this didn’t work?
If in a year the memory architecture is real but the stories aren’t why people stay, then I built an impressive engine and not a product, and that’s on me. The bet is that persistence is the thing this medium has been missing, that a story that remembers you beats a story that dazzles you. If players consistently choose the dazzle, the bet was wrong.
The other failure is quieter. If long-running stories technically work but plateau emotionally, so people finish month one impressed and month three bored, that means state alone doesn’t carry narrative, and we’d have to become a much better storytelling company, not just a better systems company.
Our read. The second failure mode is the more serious one, because it’s the one his own architecture can’t detect. A campaign that runs 4,288 turns with perfect continuity and no emotional escalation is a technical success and a narrative failure, and every metric a state engine produces would call it a win. It lands on the same problem Walton named as the category’s hardest: memory holds the past, but nothing in a fact ledger builds toward anything. Two developers, different architectures, same conclusion — state is necessary and it is not sufficient.
What We Take From This
“We removed the rulebook and kept the physics” is the best short description of an invisible state layer we’ve heard, and the two mechanisms underneath it — scene presence and fact supersession — are the specific pieces most platforms don’t have and should.
Puppeting is a regression surface, not a bug. That’s the first serious engineering account of it anyone has given us, and the implication runs past MythEngyn: agency is a property of a platform’s maintenance as much as its architecture, so any score we publish on it has a shelf life.
The degradation order is the contribution. Texture, then retrieval selection, then volume drift. Both developers we’ve interviewed in the last week independently told us our longevity axis measures fewer things than longevity contains, and they’re right — that’s going into the next pass on our published rubric.
And the open question is the one at answer three. The engine tracks a relationship that starts at stranger and warms at an earned rate; the narration, when we tested it in July, warmed considerably faster than that. Correct state and compliant prose is the seam where a state engine stops being able to save you, and it’s what we’ll be testing hardest when the beta tag comes off.
MythEngyn carries no rating from us, per our methodology — we don’t score pre-release software, and the platform’s own founder says the rules engine isn’t finished. That changes in November if his target holds. When it does, MythEngyn enters the benchmark like everything else, and we’ll find out whether an engine that never lets the AI keep score can put a 5 on one of the three axes nobody in this field has claimed.
In the meantime: our 24-hour first look covers what the platform actually felt like to play, including the two gaps we found. If you want the other side of this argument from a much larger company, our interview with Latitude CEO Nick Walton covers the same tension between structure and improvisation from the opposite direction. And if you’d rather play something tonight that’s already finished, our directory of AI RPG platforms covers everything currently open to the public.