Mnemosyne Devlog
Devlog 000, Before the Repository
I Got Tired of AI RP Forgetting What Mattered
Before Mnemosyne was code, it was frustration.
I was using AI roleplay platforms and kept running into the same problem: the AI could write a dramatic scene, but it could not live through one properly. Characters changed too fast. Trust jumped too quickly. Fear disappeared because the scene needed to move forward. Emotional development compressed weeks of growth into a few messages.
At first, I did not think I needed to build an engine.
I thought I just needed a better prompt.
So I made my own crude system. It was basically a code block the AI would stack at the end of the chat, a compact tracker for the current scene. It held things like status, scene information, memories, atmosphere, physical condition, sensory details, and character position.
It was rough.
It was not software.
It was not a state engine.
It was just a prompt-based memory and status block, duct-taped onto the end of a roleplay.
But it worked better than nothing.
And that was what bothered me.
If a crude code block could improve continuity, then the problem was not just the quality of the writing. The problem was that the AI had no reliable structure for carrying the scene forward. It could imitate emotional continuity, but it did not really track it.
That made the existing platforms feel worse.
JanitorAI, Character.AI, and other AI RP services had the same basic weakness in different costumes. The memory was bad, the summaries were unreliable, and somehow the systems that were supposed to fix those problems were often the things placed behind limits, subscriptions, or platform control.
The more I used them, the more it felt like I was paying around the problem instead of solving it.
Then there were the “power user” tools.
SillyTavern was better in some ways. It gave more control. It could handle memory and context better if you were willing to configure things, feed it lore, manage summaries, and burn tokens. But even there, something felt missing.
It remembered more.
But remembering more was not the same as being more human.
A character could have a longer context and still feel hollow. A system could keep more facts and still fail to understand which ones mattered. More tokens did not automatically create a soul. Sometimes it just meant the model had a bigger pile of text to drag behind it.
That was when the problem started becoming clearer to me.
The AI did not just need more memory.
It needed judgment.
The first big realization came when I looked back at one of my own RP tests and noticed the core failure clearly. The character progression was too sudden. The AI was not building trust, fear, shame, affection, or confidence step by step. It was jumping to the next “interesting” emotional state because that made the current scene easier to write.
That bothered me.
I did not just want better summaries. I wanted a system that could check whether a character had actually earned a change.
So the idea shifted from “make the AI remember more” to something sharper:
Make the AI remember like a character, not like a transcript.
That meant tracking emotional variables separately. Trust is not love. Fear is not shame. Affection is not commitment. A character can like someone and still distrust them. They can feel safe in one room and terrified in another. They can remember a small moment forever if it hit the right nerve, while forgetting whole stretches of ordinary conversation.
That became the early shape of the Soul idea.
Not as a finished architecture at first. More like a suspicion.
A character should not just be a static prompt. A character should have a changing internal state. Something persistent enough to survive beyond the current message, but compact enough that the AI could actually use it.
The crude code block was the first version of that idea.
The Soul came later.
The next problem was memory quality.
I already did not trust platform auto-summaries. JanitorAI’s summarization felt too unreliable, so my workaround was manual: copy the whole chat, paste it into DeepSeek, and make it summarize the session myself. That worked better, but it was still external labor. It also proved the platform-level memory system was not enough.
What I wanted was not a generic summary.
I wanted the AI to know what was worth remembering.
That led to the flagging idea: important events and dialogue should be marked based on character-specific salience. A betrayal should matter more to a character who values loyalty. A small act of protection should matter more to someone whose safety needs are damaged. A casual joke might vanish, but a joke said at the exact moment a character was afraid might stick forever.
That was the real seed of Mnemosyne.
Not “save everything.”
Not “summarize everything.”
But:
Track what changed the character.
From there, I started thinking less like a roleplay user and more like someone designing a memory system. The system needed emotional progression gates. It needed salience-based memory. It needed forgetting. It needed the ability to say, in character, “I don’t remember,” without sounding broken.
At first, all of that still lived inside prompts and code blocks.
Then it started to feel too big for prompts.
Then I saw the Open Claw / boom video.
I do not remember it as some grand technical revelation. It was more like one of those stupidly simple moments where the idea that had been floating around finally snaps into a usable form.
Soul.md.
That was the part that hit me.
I did not need the character to be only a prompt. I did not need the memory to be only a summary. I could treat the character’s inner continuity like a living file. Something readable. Something editable. Something that could carry state, scars, preferences, memories, fear, trust, and the slow changes that happen after enough scenes.
Not a full engine yet.
Not some perfect architecture.
Just a file.
But that file changed the direction of the whole idea.
The crude status block at the end of the chat was no longer just a hack. It became the first ugly version of what Soul.md could become: a place where the character’s internal life could persist outside the immediate scene.
That was when Mnemosyne started becoming clearer.
A narrator writes the scene.
A Soul remembers what mattered.
And somewhere between frustration, prompt hacks, broken platform memory, and that Soul.md moment, the project stopped feeling like a better roleplay prompt.
It started feeling like something I could actually build.
Next: Devlog 001, the first commit and the first shape of the project.