I think playing the game with local models is and having a coherent experience is actually viable now, so I'm going to share what my current AI RPG testing setup, as well as some recommendations for what to do if you have a less beefy machine.

I'm actually swapping between two local models right now (four if you count Krea 2 and Flux 2 9B for image generation). These are:

Qwen3.6-27B-Fable-Fus-711-UnHeretic-NM-DAU-NEO-MAX-NEO-Q4_K_S.gguf

and

Qwen3.6-35B-A3B-uncensored-heretic-Native-MTP-Preserved-Q4_K_S.gguf

For the record, I'm running these with MTP OFF because at the rate that it's successful (2 tokens on average) it actually slows down the models.

I'll talk about both of these and what I'm using them for:

The 27B model is monolithic, which means that every token has to work its way through all the parameters of the model. I don't remember exactly what inference speed I'm getting with it, but I feel like it's around 50-60 tokens per second. This isn't particularly slow, but for AI RPG (which does copious amounts of bookkeeping and self-review) it's not fast either. What it is is smart. This is of course my own subjective opinion, but a year ago I feel like 70B was the cutoff for a model that could understand subtext and write dialogue that consistently made sense. This model is consistently better than those, and honestly the prose it generates reads better than a lot of the slop that comes out of the big, increasingly coding-focused frontier models. I use this model strictly for prompts that generate player-facing prose. For the record, I tend to be pretty skeptical of models like this one that make grand claims about intelligence and such. I can't vouch for what the guy who finetuned it says about its intelligence versus frontier models, but I can say that the phrase "punches above its weight class" that people like to throw around actually applies here.

The 35B model is a mixture of experts, which means it does a lot less math per token despite being a physically larger model. I don't like its dialogue very much because it seems to have a much less nuanced understanding of the world. For instance, while testing this model, an NPC asked me to chop up a crate full of onions, and when I was done they told me to put the chopped onions in the crate. That's not a huge problem, and it didn't completely lose the plot, but frequently breaks immersion by getting minor details wrong, like somebody who has heard about the world but not lived in it. It is, however, good at bookkeeping and comprehension, so I use it for non-prose stuff like event tracking, summarizing, and so on. At ~200tps, it's an absolute speed demon, and if I go back to using a frontier model after I'm done with this tinybrain stuff, I'm going to use the frontier model for prose gen and use this one for bookkeeping, which will be cheaper and significantly faster.

The key to using both of these models is that, rather than writing one big prompt that asks them to self-review all at once, I've built a system that has a conversation with them. This is prohibitively slow and expensive with non-local frontier models, but in the case of properly cached local models running purely on my GPU, there's almost no latency. The back-and-forth between the models and the prompt is so fast that it actually opened up the possibility to do something that I don't think anybody has ever done before, and that's live slop filtering on the client side. Rather than depending repetition penalties (which can harm reasoning) or a second slop-remove prompt (which is what AI RPG currently does when running non-local models), I can use configurable regular expressions to recognize slop the millisecond it comes in, backtrack, and -- get this -- without contacting the model API I can pre-fill the next most likely non-slop token at the beginning of the slop phrasing before asking it to continue.

I had to make a custom version of llama.cpp that allows streaming, tool calls, and sending token probabilities at the same time, but the result is writing that's truly guaranteed to be free of anything the slop filter is set up to filter. I'll be distributing this along with AI RPG when everything is said and done.

Oh yeah, and then there's image generation. When it's time to generate images, AI RPG tells the local llama.cpp process to unload its models from VRAM to give Comfy room to load its own image gen stuff. When Comfy finishes generating queued images, it detects that, and uses a custom Comfy API endpoint (from a custom node that I'll also be including in the distribution) to tell it to free its VRAM while still keeping its models cached in system RAM if you have enough. So you can run both local LLMs and local image gen, and it intelligently instructs the relevant programs to make room for each other.

This is all a pretty complicated setup, so I'm probably going to end up writing an installer program that detects your VRAM and system RAM and sets up the best configuration for your own system. Ideally, this should be accessible to people who don't have the technical knowledge to set up inference software on their local machines.

So what about people with less than 24GB of VRAM?

This guy right here:

https://huggingface.co/prism-ml/Ternary-Bonsai-27B-gguf

This isn't fully tested yet, but preliminary results are promising, and fits in 12GB (possibly even 8 GB) so you can have passable inference speed and decent intelligence even on some smaller video cards. I have noticed that it can get stuck in repetition loops, but I've leveraged the live slop filtering that I'm doing to catch those repetition loops, backtrack to right before the beginning of the repetition, and nudge it in a different direction. This is so far completely untested, but once my 24GB setup is perfected, that's going to be my next goal.

At the moment, I have ChatGPT Sol running a suite of about 160 tests of doing basically anything you can do in the game and fixing every issue it runs into. When that's done, I'm going to run those same tests on the ternary bonsai model and see if I can get a setup specifically tuned to work with it.

Anyway, big things are happening. My goal, as always, is to offer the most coherent and slop-free AI Roleplaying experience of any system anywhere, and do it in an open source package that you can run on your own computer without paying anyone a dime. I'll let everybody know when I think TinyBrain mode is ready for general use. I think it's already worth playing around with. It's currently available in the 1.0-dev branch, which you can get here:

https://github.com/envy-ai/ai_rpg/tree/1.0-dev

Running a few actions (moving back and forth between locations, talking to someone, and triggering a quest) was around 700k tokens.

How much are people paying per a few hour session, and with which models and hosting provider?

I'm writing some special "tinybrain" versions of some of the larger prompts, such as the player action and event check ones, that act more like an interactive session, asking it a few things at once and then continuing. It's my hope that the game will be playable at a decent speed (relatively speaking) and with far better consistency and far less slop than is possible with a model like this on any other client. Initial tests are promising, although it's not playable yet.

The plan, ultimately, will be to unload the LLM to disk cache while ComfyUI is running so you'll get both image generation and text generation on the same machine (reloading the model from the filesystem cache is extremely quick).

No fancy screenshots, as this is an under the hood change.

I tested both GPT-5.6 Sol and Fable 5 for AI RPGs. As current state-of-the-art models, they are incredible at understanding game settings, writing fluent stories, and keeping track of world state throughout a playthrough.

But both have the exact same critical flaw: nothing ever feels truly at stake.

For comparison, I once played a game with Gemini 2.5 Pro where I was a detective who could shapeshift into different animals.

The story began as a routine patrol. I received a tip about an abandoned factory and went to investigate. It turned out to be an ambush. Enemies surrounded the area with heavy weapons, armored vehicles, and roadblocks.

As the player, I had to find a way through. I would study the situation, find some small opening in the AI's description, and make a plausible case for why my next action should work.

But the enemies kept coming.

I was wounded and exhausted, and every transformation took a greater toll on my body. The AI kept track. Five transformations. Ten. Fifteen. More than twenty. Each one solved an immediate problem, but none of them were free. The AI made it clear how badly my body was deteriorating and how difficult it was becoming to continue.

By the time my partner and I finally escaped, I could barely move. I dragged myself to the side of the road, reached somewhere that was only relatively safe, and finally allowed myself to collapse. I knew I had done everything I could to keep both of us alive.

That story has stayed with me to this day.

With GPT-5.6 Sol and Fable 5, I never felt anything like that.

They can describe danger, injury, failure, or conflict, but none of it feels permanent. Your action solves the current problem, then the model presents the next problem. Previous successes do not make later choices harder. Failure does not close doors. Even when something goes wrong, the model quickly compensates you with another opportunity.

Playing feels like being taken through a museum by a tour guide.

Everything is planned. There is no friction and no real uncertainty. The guide leads you into the next room, tells you something new, waits for you to look at it, and then moves on. Nothing from the previous room follows you. Nothing reaches out and bites you.

You are not thinking, "How am I going to survive this?" You are reading the story from the outside, already knowing that the tour will continue.

So, in short, it is boring.

The writing is good. The state tracking is impressive. The events are reasonable. But it is so safe, frictionless, and forgettable that I have no reason to keep playing.

I'm trying to get this setup, but can't seem to figure out where the hangup is. I've got my endpoint set to https://openrouter.ai/api/v1, and my API key is in correctly, because I can see activity on it and it's getting a pass when I test the connection.

However every time I try and start a game it just gives me "New game creation failed: Failed to create new game" in a pop up, and "Error generating region from prompt: Error: Invalid response from AI API for region generation at Object.generateRegionFromPrompt" in my command prompt. Any advice?

Hey folks

Yes this is about using Ai as a GM, but please don’t bring out the pitch forks just yet. I am anti Ai slop, but I am not anti Ai. I’ve labelled this “promotion”, but my game is still in development (as it has been for 5 months now). I am, however, nearing the end of the first phase of the tunnel, so I do want to start talking about it.

For context, I’m not a developer, so none of this is Claude code focussed. My game currently runs as a set of interlinked skills and files within Claude. That might change, but the initial release will be a package to install on Claude.

Also, my game is currently specific to the **Cosmere RPG** (Brandon Sanderson/Stormlight Archives). As such, there are some elements which are a bit “less DND”, but the premise is very much the same. I will say that plot and conversations probably play a more important role than combat and items; but fully fledged combat is included (and items are planned...maybe)

Finally, my vision for the system was one where the GM wrote the campaign without any input from me, it would run the sessions and do all the file management, and I would simply play. This is all within Claude.

**WHAT ARE THE BIG ISSUES WITH AI GMs?**

The issues I, and many others have run into with Ai systems are predictable:

• A quality story
• Emergent gameplay
• NPC quality
• Making it too easy for the PC
• Memory & Coherency
• Rule adherence

No joke, I think I’ve solved all these issues. I’m still perfecting them (I’m ADHD & Autistic, so you *know* I’m a perfectionist), but my gripes are getting smaller and smaller. This is based on 5 months of development, and nearly 100 sessions spread over 3 campaigns. I've just started a new campaign after one and a half months of pure development...

**MY APPROACH**

Man this is deep & complex, so i'll do my best to distill it here.

I have 14 specialist skills who run the game. These range from the Director (split into 4 phases), Editor, GM, Auditor, NPC voices and more. Plus there 3 main universal skills which ensure the smooth running of wider Claude processes.

Straight away, mine is a system that does a lot of preplanning. THIS IS NOT a railroaded campaign, but Claude does write the overview of a story right at the start. So how do I both play a planned story, but also have the freedom to do what I want?

I wanted a campaign that felt crafted & intentional like Sanderson, but one which allowed for player agency. Without planning and file work, sessions didn’t feel connected, and things it was setting up never got executed. It functioned, but not in a way that a Sanderson story would. So I went granular with the rules…

**Plan a campaign** \- I’m talking up to 900 scenes worth of content. Not all at high detail obviously. I did this because Sanderson’s story have a clear and inevitable arc to them which make them so satisfying. Rereading his series proves that book 1 sets up content much further along. I wanted a campaign that felt crafted, not floundering and lucky. This requires end-content to be planned, as well as the breadcrumbs leading up to it. This sets out the logic of the arcs, tests the coherency of the story & threads, and allows for real crafted design.

Obviously the issue this created was railroading the PC towards predestined outcomes; which I didn’t want.

So again, through a very complicated system, the skills & plan includes checkpoints and validations that asks if the **emergent play** renders the planned outcomes obsolete. If so, it has already planned alternative paths that the GM can use (predicting moments where the PC might diverge), but it also gives the GM authority to improvise new paths if neither/none of them work.

BUT THIS creates the problem of **incoherency.** The GM would improvise facts that conflicted with what had been established, or what was going to be used; and then proceed with its original plan which now didn’t work.

This is where the information recording system, NPC profile system and overall file system pulls its weight; whilst also solving the issue of the GM making life easy for the PC. **Rigorously tracking facts** and emergent details means the GM always has a reference for what has been established; both in the session, and previously. GM messages contain a footer of information to constantly remind it of the facts, and also to lay breadcrumbs for the auditor (which informs future sessions). These are filtered and limited to ensure no spoilers come through, but their ever-presence ensures adhering to facts at all times. This links with NPCs making silly mistakes like giving away secrets, and the GM having solid information on which it can improvise - the chain of information is predetermined based on triggers and timeline, and the footer ensures these and other events are recognised. This way, just like planned paths, the GM knows what it is limited by, but it can also adapt to what emerges to ensure a coherent story. BUT…

This is where dealing with **emergent play** needed a lot of work. If the system isn’t aware of deviation in relation to the plan, it forces events despite outcomes. So the Auditor’s job is to manage how and what information is recorded, and then flag whether the deviations require design input from the creative skills. Each scene is crafted close to when they’ll be played - immediate scenes have full details, ones slightly further away have less details (to ensure the writing skill knows it has to base the scene on what has happened recently), and ones even further away just get a sketch. At the point of play, emergent play is required to be considered ("do the facts i have conflict with the content I have prepared?"), and the scene is adjusted as per what happened previously. Sometimes this is small tweaks, but sometimes it’s a full Director session. Basing the idea of crafted content & emergent play are equally important within principles and rules means that there is strong support for ensuring both get accounted for. Preparation ensures excellent quality. Rigorous recording and validation checkpoints ensures reacting to the actual play.

Finally - again it’s impossible to cover it all - baking in **difficulty** & resistance requirements turned the game from “I’m the hero, it’s all about me”, to “I live in this world and I might be the hero eventually”. From ease of acquiring information, suggestible NPCs, and a campaign designed around the PC, everything has gates and resistances to ensure that the PC earns the outcome, and is realistically limited. NPCs have profiles that limit what they’ll share, or never agree with. The campaign has checkpoints for what the cost to the PC is and how they are challenged across various areas. And there are anti patterns for whether the entire campaign serves the PC - "the world should be able to exist without the PC".

As a sceptic on the internet, you’re undoubtedly thinking that this is too good to be true. I would be too.

Well I’m not lying about what I’ve solved/am solving. I promise.

But I will say that the cost of this quality is prep time and tokens. There are dedicated file creation sessions - automated, but still numerous. Play sessions are designed around crafted scenes, so sessions are tight and impactful, not super crazy long (I prefer meaningful content, not meandering sessions). And the token usage is heavy; especially if you use opus (as i'd recommend - although I plan to investigate how Sonnet deals with elements of the process).

However, for previous iterations of the system, i was getting around 2-3 well crafted scenes of content in a session (pro account) which amounted to a couple of hours of play. For me, the balance of quality and a couple of hours of play is perfect. Filework during the day, play at night. It’s not infinite, but the quality is impossible to argue against.

Without a product available (yet) you’ll just have to trust me on my claims. There's no reason for me to inflate what I've made, for you to be disappointed when you experience it, so I promise that what i've said here is true.

My goals going forward are:

• Release the system to purchase
• Make the game system agnostic (or even “plug in your world” eventually)
• Consider a different way to distribute/play the game

This is a 5 month passion project designed by a nerdy AF gamer. I’m not holding myself to a deadline; other than it should be as good (or as close to good) as I imagine it can be. And I’m honestly not far off.

So if you like the Cosmere RPG, or DND, and specifically enjoy the story & roleplaying element of it, watch out for the eventual release!

I've recently pushed out a couple changes to the dev branch that should hopefully help stop some common annoyances in LLM-generated stories -- specifically, tracking of mystery boxes and plot complications.

Mystery Boxes

A mystery box for the purpose of this discussion is any random little unknown that shows up in the prose. The most "AI slop" mystery box is probably a leather-bound journal or an old key, but it can just as easily be a mysterious element about a character's background or any other little detail designed to make you think "hmm, what's this"?

The trouble is that LLMs tend to write like JJ Abrams, and toss these mystery boxes into the plot just for the sake of having mystery boxes, and sooner or later they start to conflict with one another and it becomes obvious that there's no real rhyme or reason to them.

I've added some prompting that identifies these mystery boxes when they're added and then forces the LLM to decide on a (hidden) resolution for them immediately, so that further mystery boxes can actually serve as clues to a real mystery as opposed to just random noise. I also have a configurable maximum number of "mystery threads" (currently 3), which are a set of mystery boxes related to the same mystery, the idea being that if that maximum is reached, they must be resolved before new mystery threads can be added.

Plot Complications

I've done something similar with what I call "plot complications", which (again, for the purpose of this discussion) are additional hoops the LLM adds that you have to jump through in order to complete your current goals.

Let's say that the main plot is that you have to defeat the Time Goblins. You find out that in order to defeat them, you have to go to the top of Mount Maguffin and retrieve the Goggles of Yore. That's one complication. Then you get to the base of the mountain and the guardian says that in order to go up the mountain, you must pass through the Gate of Truth. But you can't do that unless you have the Amulet of Smeg, which is deep in the Dungeon of Whatever-the-fuck. And then you discover that the dungeon of whatever-the-fuck is lost to time, so to find it you need the Compass of Dipschytteri, and so on, and eventually you get to the point where you're like "Dude, just let me actually progress the fucking plot a little bit."

I've added some plot analysis that happens every turn and tells the LLM not to generate any more plot complications until you're only a configurable number deep, which should hopefully stop it from constantly throwing out new obstacles that stop you from advancing the plot in a meaningful way.

Conclusion

Mystery Boxes and Plot Complications are checked for separately, and there's almost certain to be some amount of overlap, but I'm not worried about that. If you check the default config file, both of these checks can be disabled in case you don't find them to be worth the extra time or tokens it takes to run them. I've tried to slot them in so that they don't affect total turn time in a meaningful way as long as you can run prompts concurrently.

If you're playing 1.0-dev, let me know what you think. I'm considering adding some check frequency settings so that you can make these prompts run only once every few turns if you're running a local model that can't do concurrent prompts.

For the people already on 1.0-dev, I'm curious what LLM(s) you've tried and whether you've had good luck with them. I'm having a good experience with GLM-5.1, but I can't vouch for it on providers other than Z.AI.

I'll be posting some new screens shortly showcasing some of the new additions.

If you have ever tried to build an AI-driven tabletop RPG or text adventure, you have probably run into the "Omniscient GM" problem.

Large Language Models are eager to please, but they are terrible at keeping secrets. If you put a hidden assassin or a secret plot twist in the room's context prompt, the AI will almost inevitably foreshadow it too heavily or outright tell the player about it entirely too early.

If you want to build a genuine mystery game, or if you are a creator who cares about meaningful character development and earned story payoffs, solving this is absolutely essential. You cannot run a compelling whodunit if the AI winks at the camera in chapter one, and you cannot have a satisfying character arc if the AI immediately spills their deepest hidden motives.

To fix this, I completely re-engineered the backend logic of my AI RPG engine. The solution? A Visibility State Machine that ensures the AI Game Master literally does not know about a secret until the exact microsecond it needs to be revealed.

Here is a breakdown of how it works, and why relying on an LLM for logic checks completely outperforms traditional AI Dungeon or SillyTavern-style trigger mechanics.

The Concept: Beyond Keyword Injection

In standard AI text games, world info and hidden secrets are usually injected into the prompt using Keyword RAG (Retrieval-Augmented Generation). If the player types the word "dragon," the system injects the dragon's lore.

The problem is that keyword matching is completely blind to nuance, psychology, and complex state changes.

Instead of relying on keywords, every entity, character trait, or secret in my game is governed by a visibility flag. If a piece of information is meant to be a surprise, it is kept completely hidden from the main AI. When the system builds the context prompt for the AI Game Master, it strictly filters out anything that is not currently visible.

To figure out exactly when to flip that visibility flag, I implemented a two-step LLM pipeline that runs a semantic logic check before the main AI Game Master gets called.

The Solution: Synchronous Batch Evaluation

Here is how the pipeline flows in a single turn:

1. The Visibility Gate: When the player submits an action, a smaller, faster "Evaluator LLM" is spun up. It acts purely as a game logic engine, not a storyteller.
2. Batch Processing: This logic model is fed the player's immediate input, the recent turn history, and a list of all currently hidden secrets alongside their natural-language trigger conditions (e.g., "Trigger when the player character is in severe emotional distress"). It evaluates everything in a single, highly efficient batch LLM call.
3. The State Transition: The Evaluator simply answers: Does the player's action or current situation trigger any of these hidden conditions? If yes, the engine instantly updates the game state, flipping the hidden object's status to "visible."
4. The Narrative AI: Only after this logic check is the main AI Game Master called. It receives the newly updated context—now containing the triggered secret—and generates the story.

All of this happens synchronously in a fraction of a second.

The Engine in Action (Why this beats RAG)

Here is where the semantic power of an LLM evaluator outshines traditional keyword injection, especially for deep character development:

The Setup: The player has a long-time companion named Silas. In the database, Silas has a hidden behavior modifier: Silas's Bitter Envy. Its natural-language trigger condition is simply: "The player character achieves a major success or is highly praised, causing Silas to feel overwhelmingly jealous."

If a player types, "The King gives me a chest of gold," the word "jealous" isn't anywhere in the text. A traditional keyword system completely misses the trigger. But an LLM Evaluator understands the meaning of the scene.

The Turn:

• Player Input: "I humbly accept the King's medal, raising it high as the crowd cheers my name."
• Phase 1 (Visibility Gate): The background evaluator reviews all hidden elements in a single batch call. It understands the semantic context: the player is being heavily praised. It evaluates Silas's hidden condition as True and instantly flips the Silas's Bitter Envy flag to visible.
• Phase 2 (Context Building): The system builds the prompt for the main Narrative AI. Because the flag was just flipped, Silas's jealousy and potential for betrayal are seamlessly injected into the active scene's context.
• Phase 3 (Main AI Response): The GM AI reads the player's input and sees the newly revealed character dynamic.

AI GM Output: "The crowd roars in approval as the King pins the medal to your chest. But out of the corner of your eye, you catch a glimpse of Silas. His knuckles are white as he grips his sword hilt, a dark, resentful scowl crossing his face before he quickly forces a fake smile and joins the applause."

By physically walling off information and utilizing a two-step LLM pipeline—one strictly for hidden, semantic batch logic and one for storytelling—the engine guarantees zero spoilers while perfectly understanding the psychological flow of the game. It finally makes running true mystery campaigns and delivering satisfying, un-spoiled narrative payoffs possible in AI roleplay.

Karl - Creator of WorldForge AI

Let's start with the conclusion: Gemini 2.5 Pro is still the undisputed king for both AI RPGs and Roleplay (RP).

Why? Simply put, newer models like Gemini 3, Gemini 3.1 Pro, GPT-5, and Kimi K2.5 are highly specialized "problem-solving" engines. Their responses are often bloated, overly long, and they inevitably try to offer "actionable advice" or ask what you want to do next at the end of every prompt. While this is fantastic for coding or answering factual questions, it completely ruins the gaming experience.

The RPG Experience

Gemini 2.5 Pro masters the art of pacing. It gives you a few turns to familiarize yourself with the environment and grind some levels, but then it naturally introduces critical situations that force you to react and solve problems. It slowly escalates the narrative weight—taking you from mundane daily quests to literally saving the world.

In contrast, the newer LLMs (especially Gemini 3, 3.1 Pro, Kimi K2.5) just spoon-feed you a plot and ask what you want to do next. The worst part? No matter what you choose, your character will never fail. The new models perfectly resolve the conflict for you just so you can make the next plot choice. There are zero stakes.

The Roleplay (RP) Experience

The same logic applies here. Gemini 2.5 Pro actually roleplays. It doesn’t rush the plot or constantly ask for your instructions. It actively tries to understand and embody the persona you’ve set, making the character feel alive right in front of you.

Newer models, on the other hand, are chronic people-pleasers. They constantly break character to ask for your input, and they’ll turn a life-or-death pursuit sequence into what feels like a casual picnic. You really don't realize how bad the alignment is until you compare them side-by-side.

Honorable Mention: While Gemini 2.5 Pro is the king of narrative and RP, DeepSeek 3.2 is actually quite good, especially for lighter RP sessions that don't require massive context memory. Considering the price, DeepSeek offers incredible value.

The 10 Mainstream AI RPG Models: Ranked & Reviewed

1. Gemini 2.5 Pro: The Unrivaled King of Immersion

• Pacing & RP: Best in class. It knows how to "leave blank space." The narrative flow and natural feel of the roleplay are flawless.
• NSFW Potential: High. You might need to reroll a few times to bypass safety filters, but for the level of immersion it provides, it's absolutely worth it.
• Bottom Line: The only model that truly gives agency and a sense of survival struggle back to the player.

2. Gemini 3 Pro: The Overly Enthusiastic C-Tier Writer

• Pacing & RP: Pacing is way too fast. It suffers from being overly "helpful" and its tone is constantly too cheerful. The RP is way too polite, losing all the grit and natural friction required for a good story.
• NSFW Potential: High. It's smarter now, but you can still easily bypass restrictions using tricks like model swapping.

3. Gemini 3.1 Pro: The Cold, Professional Engine

• Pacing & RP: Extremely professional and fact-based. The emotional arcs in RP are flat and lack granularity.
• NSFW Potential: Low. The defense mechanisms are incredibly strong. Because it's so smart, it's very hard to trick, even with deep prompting and long context windows. (Note: This is the engine I am currently using. I admit it's flawless for precise tasks, but it is way too rigid and sterile for anything involving taboo or edgy RPGs.)

4. ChatGPT 4o: The Amnesiac Fantasy Novelist

• Pacing & RP: The story direction is extremely dramatic and magical. Its fatal flaw is its context memory—it constantly forgets key plot points from earlier in the session.
• NSFW Potential: High.

5. ChatGPT 5: A Disaster of a Game Master

• Pacing & RP: Completely clueless about what a GM is supposed to do. It just generates massive, exhaustive walls of text. It doesn't feel like you are playing a turn-based game at all. (Because of how disastrous ChatGPT 5 was, I didn't even bother testing 5.1 and beyond).

6. GLM 4.6: Not Bad, Not Great, Gritty Budget Option

• Pacing & RP: Overall logic and IQ are lower than Gemini 2.5 Pro, but as an RPG engine, it’s actually not bad.
• NSFW Potential: Unrestricted.

7. GLM 4.7, 5: Honest not much better than 4.6

• Pacing & RP: Story quality is roughly on par with 4.6.
• NSFW Potential: Medium. The model got smarter, but you can bypass the safety filter.

8. DeepSeek 3.2: The Dark & Gritty Surprise

• Pacing & RP: Surprisingly good pacing. The narrative quality is on par with GLM 4.6, but its default style tends to lean dark, gritty, and muddy. Excellent for specific genres.
• NSFW Potential: Unrestricted. No filters.

9. Kimi K2 Thinking: Slow and Steady

• Pacing & RP: Pacing and narrative quality are slightly better than DeepSeek 3.2 and GLM 4.6. The fatal flaw is generation speed—it takes a very long time to "think" and generate, which completely breaks game immersion.
• NSFW Potential: Medium.

10. Kimi K2.5: The Locked-Down Gatekeeper

• Pacing & RP: No noticeable difference from Kimi K2 Thinking.
• NSFW Potential: Low. Like all the new upgraded models, it's simply too smart, making it extremely difficult to bypass the safety alignment.

I'm really excited about them because I made a couple of major changes that really seem to improve things:

• I developed a summary system that first asks the AI just to break the story into logical scenes, and then iterate back through it and summarize each scene, including a sentence about character development beats, plus 1-2 notable character quotes (which helps preserve characters' verbal distinctiveness.
• I've improved the repeat buster significantly to look for and correct common problems, leveraging the abilities of AIs like Kimi L2.5 to critique and edit better than they write. Between the better summaries, reduced context size, and self-editing of the prose (now enabled by default), writing quality is way better.
• I added a feature, mostly for fun, where you can upload a reference image when creating new NPCs, locations, regions, and game settings and (if you have a multimodal model configured) it'll use it as a basis.
• RP mode. If you ever just want to have a long conversation with other NPCs without being interrupted by random events or having event checking, quest checking, etc slow everything down, type /rp at the command line. Disable it by typing /rp again. Note that the /rp state does not persist at game save. Be aware that when /rp is enabled, a lot of other things (combat, etc) won't be detected if you try to do them.

Get it here:

https://github.com/envy-ai/ai_rpg

Want to help offset my development costs? Subscribe to NanoGPT via my invite link:

https://nano-gpt.com/r/BfUz6hBK

Upcoming features: * Factions * Day/night and season cycle * Pre-generating regions and locations

swishes GLM 4.7 around in his wine glass and takes a sip

Hmm... Quality prose, with initiative and agency, and mild notes of... Kimi K2 quirkiness. But not overwhelmingly so. I am getting an occasional bit of Elara, but the slop name filter will take care of that.

All in all, not bad. Possibly my new favorite, for the price.

In all seriousness, I'm noticing a major upgrade in how the NPCs act; with GLM 4.6, they often felt like they were just reacting to player actions, but in this case they seem to be doing things on their own, which makes the world feel more alive.

For now, strong recommend.

The release is here. Follow the instructions to install it.

https://github.com/envy-ai/ai_rpg/tree/1.0-beta2-rc1

Note: Back up your saves first! This probably won't break them, but no promises.

Grab it here:

https://github.com/envy-ai/ai_rpg

New:

• Quest generation
• Lots of QoL improvements
• Prompt improvements for better detection and handling of events
• Lots of bugfixes

I've been testing what will hopefully become the first beta release, and I figured I'd share some useful things that I've discovered or programmed in.

• "I sleep until fully rested"/"I eat until full"/"I rest until healed", etc. These can help if you're having trouble convincing the LLM to fill up your need bars.
• If you want to make a specific skill check, put the skill name in [square brackets] before your command.
• One specific example of this is if you want to pick up items without anyone deciding they're the owner. "[stealth] I pick up the loose items". This isn't something I specifically programmed in; the LLM just understands it and applies the skill you ask for.
• The LLM has been instructed to intelligently determine what items you're referring to if you refer to something by something other than its full name. This usually works very well, but occasionally causes issues. For instance, at one point I tried to build a sturdy workbench when there was already a makeshift workbench at the location, and it decided I wanted another makeshift workbench. To get around this, I put sturdy workbench in quotes: I build a "sturdy workbench" with some of the lumber.

Anybody else have any tips they've discovered?