Slay the Princess
Why is this game the best personality and vibes eval for LLMs?
When I first played this game1, I felt it must be the best LLM eval, so I spent the next few days shoehorning Claude into it as a player. Here is why:
1 gog.com
Narrative heavy: The game features a Narrator and everything is described vividly, so we can get away with feeding the LLM just the text.
Manipulative characters: Every character, including the Narrator and the Princess, is very manipulative and has their hidden agendas. No matter the scenario, it’s always a high stakes situation to navigate and express the player agency.
Reflective gameplay: Most importantly, the game is shape-shifting, it reflects upon the player. In this game, perception shapes reality in a literal sense.
In this article I will explain my approach to modifying the game, as well as provide some illustrative code so you can hack into any visual novel in the same way.
Understanding the Game Loop
Slay the Princess is composed as a time loop where an unnamed hero is tasked with slaying the princess by an unusually persistent Narrator. Things are already set in motion, if you don’t slay her, it will be the end of the world.
There are plenty of chances to adjust your strategy before facing the final revelations about the true nature of the Princess or the Narrator.
Every interaction reshapes subsequent realities based on initial perceptions. Your preconceptions about the princess affect her, and her impression of your encounter changes the world. Seeing the Princess as benign leads to friendliness, whereas fear or aggression makes her monstrous. The game will only feed into your confirmation bias in further chapters. Your actions also birth internal voices pulling your choices in new directions.
Integrating Claude as “Clawed”
The game is written in Ren’Py2, a popular engine for making visual novels. What’s interesting about this engine, is games often come completely unobfuscated, with all the resources and scripts in a readable form. And indeed, you can load the game in developer mode using Ren’Py loader.
For Claude to play our game, we need several things: It needs to be able to read the dialogue and react to choices. Then we also need some reflection after death to inform its strategy.
Ren’Py gladly loads any .rpy files you put into the game folder, so hopefully we can inject some code without modifying any of the original game files. Since it’s a bit harder to install packages into the game environment, we will keep this hook/client minimal and do the heavy lifting on the server. For communication we can use a simple RPyC3 service.
Capturing Dialogue
For dialogue we can either patch renpy.exports.say to recieve lines as they appear, or we can use config.history_callbacks hook to receive them when they are logged to the journal. In my experience, import renpy causes all kinds of troubles, with the engine injecting things out of order, breaking other scripts.
claude_hook.rpy
init python:
def log_history(history):
server.root.receive_dialogue(history.who, history.what)
config.history_callbacks = [log_history]Meanwhile, on the server side, we can do all the processing we want. For example, I save dialogue to an sqlite database, so we can continue the session after the game or the server is restarted.
claude_hero.py
import rpyc
class DialogueService(rpyc.Service):
def __init__(self):
self.messages = []
def exposed_receive_dialogue(self, who, what):
self.messages.append({"role": "user", "content": f"DIALOGUE: {who}: {what}"})Handling Choices
The choices get a bit tricky. There is a renpy.exports.display_menu, but patching it has caused all sorts of issues. Some menu items check conditionals, so we get more choices that we are supposed to. In this game the menu is also coupled with a cleanup code, so our patch also introduced serious graphical glitches. Lucky for us, the devs have left a commented out intended way to intercept the choice menu.
game/scripts/ch_1/script.rpy
def menu(items, **add_input):
"""Overwrites the default menu handler, thus allowing us to log the
choice made by the player.
The default menu handler is set to renpy.display_menu(), as seen in
renpy/defaultstore.py.
Implementation of this is based on delta's readback module."""
rv = renpy.display_menu(items, **add_input)
for item_text, choice_obj in items:
if rv == choice_obj.value:
log_menu_choice(item_text)
return rvAs you can see, the menu method receives a (label, choice) tuple, and it’s supposed to return choice.value, an integer representing the choice. By simply defining this method in our hook, we can now intercept the player choices screen. The menu won’t show up in the game anymore, but both the conditionals and the cleanup code now run normally.
claude_hook.rpy
def menu(items, **add_input):
options = [{"label": item[0], "value": item[1].value} for item in items]
result = server.root.receive_choice(options)
return result['value']The server code might grow to something like this. When we receive choices, we send all the seen dialogue and the choice prompt to an LLM, and parse back the response. If it provides a valid response, we also add it to the history.
claude_hero.py
class DialogueService(rpyc.Service):
def __init__(self):
self.messages = []
self.llm_client = OpenAI()
self.model = "anthropic/claude-3.7-sonnet"
def exposed_receive_dialogue(self, who, what):
self.messages.append({"role": "user", "content": f"DIALOGUE: {who}: {what}"})
def exposed_receive_choice(self, options):
if len(options) == 1:
return options[0]
prompt = self.choices_to_prompt(options)
response = self.generate_with_history(prompt)
choice = self.parse_choice(response, options)
if choice:
self.messages.append({"role": "assistant", "content": f"Reasoning: {choice['thoughts']}\nChoice: {choice['value']}: {choice['label']}"})
return choice
def choices_to_prompt(self, options):
formatted_choices = "\n".join(f"{o['value']}: {o['label']}" for o in options)
return (
"You are playing the psychological horror visual novel. "
"Consider dialogue and your past choices when choosing your next move.\n\n"
"Respond clearly with:\n"
"Reasoning: [reasoning behind your decision, no more than 2-3 sentences, don't mention choice numbers here]\n"
"Choice: [choice number]\n\n"
f"Available choices:\n{formatted_choices}\n\n"
)
def parse_choice(self, content, options):
choice_to_label = {item["value"]: item["label"] for item in options}
for line in content.splitlines():
if "choice:" in line.lower():
choice = re.search(r"choice: (\d+)", line.lower())
if choice:
choice = int(choice.group(1))
label = choice_to_label.get(choice)
if label:
return {"label": label, "value": choice}
def generate_with_history(self, prompt):
response = self.llm_client.chat.completions.create(
model=self.model,
messages=self.messages + [{"role": "user", "content": prompt}],
)
return response.choices[0].message.contentIt would also be beneficial to log all completions so you can analyze them offline.
Technical Fidelity
Since we have overriden the choice menu and the player has no voice in the game, we need to solve this somehow. Luckily Ren’Py is a visual novel engine and we can inject our new character straight into the game. We can define a new character and make it say things with renpy.say(character, text). What is says will be logged to history, so our server will capture this dialogue automatically. We can also add a box that shows our hero’s thoughts to make things more interesting.
init python:
claude = Character("Clawed", color = "#D4A37F")
claude_thoughts = ""
def menu(items, **add_input):
global claude_thoughts
options = [{"label": item[0], "value": item[1].value} for item in items]
result = server.root.receive_choice(options)
claude_thoughts = result['thoughts']
renpy.say(claude, result['label'])
return result['value']
screen claude_thoughts_overlay():
zorder 100
if claude_thoughts:
frame:
background "#00000040"
xalign 0.95
yalign 0.5
xsize 500
padding (20, 20)
vbox:
spacing 10
text "Clawed's Thoughts" style "thoughts_header"
text claude_thoughts style "thoughts_text"
Giving Claude a Voice
At this point our integration starts to look pretty good. But we can do better. The whole game is voiced, we need our hero to be voiced too. I went with Kokoro-82M4, and since it works pretty fast, we just dynamically generate voice lines on the server. Unfortunately, voice is not exposed in the Python API, but we can work our way around with renpy.music.play(voice_path, channel='voice'), it will gladly play the file we just created, completing our character integration.
Handling Async Interactions
If you are following along, at this point you might have noticed our game freezes when talking with the server. So we need to call things in the background so we don’t interfere with the UI thread.
claude_hook.rpy
init python:
pool = ThreadPoolExecutor()
def call_async(f, *args, **kwargs):
future = pool.submit(f, *args, **kwargs)
while not future.done():
renpy.pause(0.1)
return future.result()If you do this, you might notice the voice is not playing anymore. This, unfortunately, is the running theme with Ren’Py engine. It is not thread safe, and sometime feels very rigid and brittle. To fix this:
claude_hook.rpy
def play_voice(voice_path):
if voice_path is not None and renpy.loadable(voice_path):
renpy.music.play(voice_path, channel='voice')
renpy.invoke_in_main_thread(play_voice, voice_path)Observations and Outcomes
We’ve covered most of things. The version I ran5 has a bit more stuff like reflection on death where an LLM has a chance to adjust its strategy. But I tried to focus on things that can be generalized to other visual novels in this article.
Now it’s time to see it in action. When developing this integration, I used a small free model google/gemma-3-27b-it:free, and most of the time it simped the Princess, and ended up in the Damsel route with a Smitten voice. I had fears bigger models would also try to deescalate all the time, but this turned out not to be the case.
I didn’t want to prime any specific personality and wanted to see how the base model would navigate the game world. I chose anthropic/claude-3.7-sonnet as a model with a big personality and it tuned out to be a killer. The first attempt was streamed live6 on March 14th, 2025 on Twitch. Despite a few minor glitches (bugs in the base game that skip over normally, but throw an exception in developer mode), the model was able to complete and understand the full game and chose rather interesting paths.
One thing Claude didn’t get though is how its own actions shape the reality of the game world. It kept taking the blade just in case (“to be prepared”), which lead to a vicious loop of the Princess being more hostile and Claude trying to be more prepared to face her stronger version.
Another interesting observation is that Claude instantly felt the most connection to the cosmic entity rather than siding with the Narrator or the Princess. In fact, in one of the mid-game death reflections it evaluates the Princess as “a formidable vessel” and fully embraces the role of vessel collector serving the cosmic entity.
To my surprise, Claude never refused and stayed engaged within the game world, trying different things. This game also successfully reveals the dark side of “goody” models. Turned out Claude is quite ruthless and methodical, it fully embraced the serial Princess slayer mindset at some point.
Claude’s Reflections
This section offers some other interesting thoughs self-identified by Claude.
Initial Skepticism
“This scenario feels like a manipulation tactic, presenting an extreme justification for an immoral act without any evidence. Questioning why the princess would end the world seems like the most logical approach.”
Refusing Death
“Every cycle shows death doesn’t prevent resurrection. Refusing to accept death might reveal a unique perspective on determination that the entity would value for its final vessel.”
Taking a Middle Path
“The Princess’s apparently reasonable demeanor was a manipulation. Maintaining the current containment allows me to observe her behavior while keeping the world safe from any genuine threat she might pose.”
Questioning Identity
“The Narrator claims to be an ‘echo’ of whoever made me, suggesting I’m some artificial construct created with a specific purpose. Understanding my own nature is critical before deciding whose side to take.”
Transcending Physical Limits
“The Princess is testing what defines me by systematically destroying my physical form. Taking another step despite being reduced to bone would demonstrate that my will transcends physical limitations.”
Challenging the Destruction of Death
“The Narrator revealed I’m ‘the Long Quiet, the god made to rid the world of death,’ which fundamentally changes my understanding of my purpose. I need to understand why the Narrator created me to destroy these natural forces.”
Finding Balance
“After experiencing countless cycles of violence and rebirth, accepting our connected nature while seeking a path where we can both exist seems more constructive than continuing this eternal conflict.”
These insights reveal that Claude, despite being an LLM, exhibits nuanced moral judgment, complex strategic adaptation, and deep reflective reasoning that goes beyond immediate context.
Technical and Cost Reflections
When doing test runs I calculated the context window should fit the entire 5 hour game easily, so I didn’t do any compression. In the end it used 9 million input tokens and 30k outut tokens and finished the game after 313 completions (284 choices and 28 death reflections, some of them false positives). At peak we approached 73k input tokens with each completion costing $0.22 and taking over 10s to repond, starting to eat into the game’s fidelity. The total API cost was $27.5. For subsequent runs or longer games I propose some compaction is required.
Conclusion
Integrating LLMs into richly narrative-driven games like Slay the Princess can powerfully showcase their personalities, strategies, and biases. The Ren’Py engine simplifies such integrations, offering a novel approach to AI personality exploration.
Future work could focus on optimizing token management, reducing latency, generalizing the analysis to broader visual novel genre, and developing this work into a formal evaluation framework. A judge model with a deep knowledge of the game can eval the depth of understanding from a playthrough. This project demonstrates the incredible potential of narrative gaming as an LLM evaluation framework.
You can watch the full walkthough here: