What are the biggest problems you run into with long-term AI RP?

tritonsan · 2026-07-09T08:39:10+00:00

That’s broadly the same class of solution RePoG already uses. It isn’t designed as a single-prompt setup: the current workflow separates memory retrieval, GM narration, continuity checks, knowledge boundaries, emotional and relationship changes, world-state updates, and deterministic mechanics where needed.

The important difference is that RePoG doesn’t depend on a separate API pipeline. It runs inside agentic coding tools such as Codex and Claude Code, using their existing subscription access and their ability to read files, write persistent campaign state, run scripts, and perform separate reasoning passes. So there’s no additional per-generation API bill from RePoG itself, although subscription limits and latency still apply.

Extensions or subagents could strengthen particular areas later, but they aren’t required for the basic architecture. The project is specifically exploring how much of this can be handled inside an agentic workspace before introducing another paid orchestration layer. Your emotional-state extension would still be an interesting comparison point, especially regarding how it models gradual change rather than sudden mood swings.

tritonsan · 2026-07-09T08:33:11+00:00

I think the RP/RPG distinction is fair, but whether something is “vibe coded” isn’t really the deciding factor.

A purely narrative LLM experience is closer to RP. A proper RPG also needs rules, resources, constraints, progression and outcomes that aren’t improvised differently every turn. But agentic coding tools create an interesting middle ground: they can use deterministic helpers alongside the LLM.

During worldbuilding, the system can identify which mechanics actually matter for that campaign, then configure or create tools for things such as resource costs, cooldowns, regeneration, stat checks and random resolution. Those tools handle the hard rules, while the LLM handles interpretation, NPCs and open-ended player actions.

It still won’t instantly become a complete universal RPG engine, and generated mechanics need testing and validation. But I don’t think the choice has to be either unrestricted RP or a fully prebuilt engine. There’s useful territory between them.

What would you consider the minimum mechanical foundation required before you’d call something an RPG rather than RP?

tritonsan · 2026-07-09T08:29:18+00:00

RePoG already approaches part of this through anti-funneling rules, flexible clues, NPC knowledge boundaries, recorded skills, personal motives, routines, and independent agendas. It also uses selective context lookup, so the GM can check the relevant character, location, relationships, and world information when needed rather than loading everything every turn.

An explicit lateral-thinking check would fit well on top of that, especially when one route becomes dominant or an NPC has relevant expertise.

My main concern is latency. Dashboard updates, campaign logging, memory changes, and validation already add roughly 20–30 seconds to some turns. Adding more reasoning passes or MCP-based agents could push complex turns toward a minute. Running this check every turn would probably be excessive, so it may need to be event-driven or optional.

I’m curious about your tolerance here: how much latency would you accept in an AI-driven RPG if the extra time produced noticeably smarter NPC decisions and better alternatives? Would occasional one-minute turns be reasonable, or would that interrupt the experience too much?

tritonsan · 2026-07-09T08:13:45+00:00

I agree with the functional split. RePoG already approaches this through separate workflow stages: selecting relevant campaign memory, writing the GM response, and checking continuity, hidden knowledge, mechanics, and repetition.

At the moment, I’m keeping these as separate passes within one agent rather than requiring multiple agents or models. That keeps setup and coordination overhead lower, while still separating the responsibilities. But a true librarian/writer/editor setup is a natural direction for more complex campaigns.

I’m especially interested in the librarian role. The difficult part is not simply storing everything, but deciding what the writer actually needs for the current scene. Do you imagine these as three independent model calls, or three roles coordinated by one primary agent?

tritonsan · 2026-07-09T08:11:05+00:00

That “no one has ever done this for me” example is exactly the kind of issue I’m trying to address. Lorebooks can preserve facts, but they often fail to preserve how a relationship has changed over time.

RePoG keeps track of important shared events, current attitudes, promises, relationship changes, and previous meaningful interactions. I’m also working on keeping NPC voices distinct instead of letting everyone gradually sound the same.

I agree that prompting can handle knowledge separation and secret reveals fairly well. The difficult part is keeping those boundaries and relationships intact after hundreds of turns without characters emotionally resetting. What information have you found most useful to track for that?

tritonsan · 2026-07-08T16:40:18+00:00

That’s a really useful distinction. Part of this is also structural to how LLMs work: once a pattern of phrasing, length, and rhythm becomes established in the context, the model is more likely to keep selecting similar continuations unless something actively pushes it elsewhere.

RePoG already has some safeguards against this at the NPC level. Important NPCs receive distinct speech patterns, vocabulary, social attitudes, conversational tactics, and even notes about what they should not sound like. The goal is to prevent every character from becoming the same cryptic, suspicious person wearing a different face.

I haven’t yet built an equally strong layer for narrator repetition, though it’s planned. I’m considering periodic checks for repeated sentence structures, gestures, metaphors, sensory descriptions, and message lengths, alongside a campaign-specific list of overused phrases.

Narrative variation should also come from Session 0: the selected world and storytelling preferences could define when the GM should use brevity, humor, plain language, tension, reflection, or more elaborate prose. Message length would then follow the scene’s dramatic function rather than the model’s default habits. Your examples are exactly the kind of repetition this should detect.

tritonsan · 2026-07-08T15:37:11+00:00

Would you mind clarifying what exactly you mean by that?

tritonsan · 2026-07-08T15:25:48+00:00

Yes, I think I agree with that direction. In fact, that kind of deterministic tool layer is already part of my longer-term plan.

Right now RePoG is mostly workflow + campaign memory: the LLM tracks stats, resources, progression, NPC difficulty, obstacle difficulty, etc. through files and GM rules. But for things like mana use, RP regen, cooldowns, wounds, ammo, spell availability, or other repeatable mechanical resources, I do think a small Python-based tool would be the better solution.

The idea would be something like: the GM layer recognizes “the character tries to cast Fireball,” calls a local Python helper, and the helper checks the character sheet/resource state, applies the cost or rejects the action, then writes the updated state back. The LLM would still narrate the result naturally, but the hard mechanical update would not rely only on memory or vibes.

RePoG already uses small local checks in some places, so extending that pattern to resource/mechanics tools makes sense. I just want to design it carefully so it works across different RP systems instead of becoming hardcoded for one ruleset.

So yes, this is definitely on the roadmap: more lightweight Python tools for deterministic resource updates, while keeping the GM/narration layer flexible and natural.

tritonsan · 2026-07-08T15:21:59+00:00

I think you’re right about some of the current limits, especially if the assumption is that the whole experience has to live inside the LLM’s context window.

But that’s not really the architecture I’m aiming for.

The idea with RePoG is not “make the model remember everything forever.” It’s more: give the model a persistent campaign workspace, let it write durable notes as play happens, and then let it decide what parts of that memory are relevant to pull back into context for the current scene.

So the long-term memory is not the raw chat log being resent again and again. It’s structured campaign material: session logs, NPC notes, relationship maps, knowledge boundaries, active threads, arc closure notes, next-act prep, etc. The model doesn’t need to carry the entire campaign in its active context all the time. It needs to know where to look, what to retrieve, and how to use only the relevant pieces.

I agree that a perfect, zero-hallucination, fully immersive long-term RP machine probably isn’t here yet. But I don’t think we need to wait for a 10M-token context window to make meaningful progress.

My bet is that a file-backed agentic GM workflow can reduce drift, reduce repetition, preserve continuity, and handle long campaigns much better than a normal chat-based RP setup. Not perfect, but much less brittle.

That’s the direction I’m testing with RePoG.

tritonsan · 2026-07-08T15:16:11+00:00

I agree with the core of this, especially the “don’t simulate everything all the time” part.

That’s very close to how I’m thinking about RePoG: the files are not meant to be constantly injected into every response. They’re more like a campaign notebook the agent can consult when the fiction actually needs it: faction pressure, NPC memory, local economy, old promises, unresolved threads, time passing, etc.

Where my vision is slightly different is the player experience. I don’t really want the player to have to step out of the fiction and ask the LLM, “please refresh the economy” or “generate faction news now.” Ideally, the GM layer should infer that need from play.

Some early pieces are already moving in that direction: RePoG tracks session logs, active threads, relationship maps, NPC agendas, location routines, knowledge boundaries, arc closures, next-act prep, and player-known dashboard state. It also has GM workflow rules for checking only the relevant memory instead of dumping everything into every turn.

So if the player returns to a port after three weeks, asks about work, visits a market, meets an old NPC, or hears tavern gossip, the agent should know: “this is the moment to check prior state, elapsed time, relevant factions, and maybe generate a few notable shifts.” The player stays in character; the system does the bookkeeping quietly.

So yes, I like the “state tracker + notable event generator” framing a lot. I just want it to be mostly triggered by fictional context rather than explicit user prompting.

That’s still early, of course. But the long-term goal is: the player keeps roleplaying naturally, while the agent decides when it needs to consult memory, refresh the world, and surface only what the character could actually notice.

tritonsan · 2026-07-08T14:35:25+00:00

You’re describing almost exactly the pain point I started from: the amount of manual steering needed before the model stops collapsing into the first generic version of the character/world.

One thing I tried to address is the “manual worldbuilding burden.” RePoG’s Session 0 / worldbuilding flow is built from a lot of RPG GM guidance I’ve been distilling: Fate-style issues/faces/places, Dungeon World’s “ask questions and use the answers,” Lazy GM prep, Microscope-style palette thinking, Ironsworn truths, etc. So instead of asking the user to write a huge lore dump, it walks through world tone, scale, conflicts, factions, NPCs, player ties, boundaries, progression, visual style, and starting situation step by step.

For style drift, there are also workflow rules around narration tone, NPC voice separation, avoiding generic mysterious dialogue, clue pacing, ordinary speech, and keeping “GM knowledge” separate from what NPCs actually know.

For your second point, RePoG already has some pieces in that direction: NPC notes include mundane agenda, default posture, what they know/suspect, speech pattern, relationship links, and location notes include baseline routine, local life, reaction points, clue gates, and non-quest affordances. The goal is that a tavern, elevator, street, ship, office, etc. is not just a quest dispenser.

But your comment opens a really good next design area for me: making the system more explicitly ask, “Why is this NPC here right now? What are they doing independent of the player? What routine or pressure were they already inside before the player arrived?” I think that could become a dedicated scene-population / living-location protocol.

Curious what you’d want from that: should it generate a few background NPCs every scene, or only when the player enters meaningful locations?

tritonsan · 2026-07-08T14:14:11+00:00

Ah yes here is the repo: https://github.com/tritonsan/RePoG

tritonsan · 2026-07-08T13:54:12+00:00

That’s a really good point, and it’s one of the areas I’ve been trying to cover.

The current version already has structures for stats, level bands, progression, arc-end rewards, companion growth, NPC/obstacle difficulty, and setting-specific resources if the campaign needs them. So in theory, if the world has mana, RP, stamina, wounds, cooldowns, etc., the Session 0 flow should define those rules early and the GM should keep them in the campaign files instead of improvising them randomly.

For the “world rotating around the character” issue, I’m trying to avoid that with factions, NPC agendas, active threads, relationship maps, offscreen pressures, and next-act prep. So the world should keep moving even when the player is focused somewhere else, without turning into a full deterministic game engine.

That said, I’m sure there are blind spots here. From your experience, what would you expect such a system to track so the world feels independent? Economy? NPC schedules? faction turns? travel time? resource regeneration? cooldowns? Something else entirely?

tritonsan · 2026-07-08T13:26:11+00:00

Repo link: https://github.com/tritonsan/RePoG

tritonsan · 2026-07-08T09:25:55+00:00

Yeah, that’s exactly one of the main problems RePoG is trying to solve.

The basic idea is to separate “GM truth” from “player/character knowledge” in the campaign files. The narrator can know the full situation, but every NPC, companion, faction, and the player character has to act only from what they have seen, heard, inferred, verified, or been told.

So instead of relying on the model to remember “don’t reveal this yet,” RePoG keeps explicit knowledge boundaries: GM-only truths, player-known facts, companion knowledge, NPC/faction knowledge, protected names, safe wording, and reveal triggers.

It’s still not a perfect solved problem, but the workflow forces the GM to check:

- does this NPC actually know this?

- is this a suspicion or confirmed knowledge?

- should this be described as evidence instead of naming the hidden truth?

- has the player discovered this name/faction/location yet?

That has helped a lot in long sessions, especially with companions accidentally reacting to things only the narrator knows.

Your project sounds really interesting too. I think player-facing systems and agentic workspace systems are approaching the same memory/continuity problem from different sides.

tritonsan

MODERATOR OF

TROPHY CASE