Mnemosyne Devlog
Devlog 002, Splitting Memory in Two
The Soul Remembers Like a Person. The World Log Remembers Like a GM.
After I started thinking of the code block as something that could update the Soul, the next problem became obvious.
Not all memory is the same kind of memory.
At first, I was still thinking too simply. The AI needed to remember what happened, so I needed a better memory system. That sounded reasonable, but it was still too broad. “Memory” was doing too much work as one word.
A character remembering something is not the same as the story remembering something.
That was the next shift.
The Soul should not carry everything.
The Soul should carry what changed the character.
That meant emotional memory. Subjective memory. Biased memory. The kind of memory that affects trust, fear, shame, affection, openness, desire, and resolve. The kind of memory that might grow stronger because it hurt, or fade because it never meant anything.
But the world needed a different kind of continuity.
Where are we?
What objects are in the room?
What just happened in the plot?
What is the active danger?
What information has been established?
What does the narrator need to know, even if the character does not?
That did not belong entirely inside the Soul.
If I put everything into the Soul, the character would become weirdly omniscient. They would “remember” facts they should not personally know. They would carry scene logistics as if those logistics were emotional memories. A location change, an object on a table, or a background plot thread would sit beside trauma, trust, and fear like they were the same kind of thing.
They are not.
That was when the memory system split in my head.
The Soul remembers like a person.
The World Log remembers like a GM.
That distinction mattered a lot.
The Soul is subjective.
The World Log is operational.
The Soul can be wrong, biased, incomplete, or emotionally distorted.
The World Log should be stable enough to keep the scene coherent.
A character might remember the sound of rain because it made them feel safe. The World Log remembers that the scene is taking place at a station, it is raining, the last train is delayed, and a suspicious courier package exists in the scene.
A character might forget the exact words someone said, but remember that the tone felt threatening. The World Log remembers the actual exchange happened, where it happened, and what plot thread it touched.
A character might not know there is someone watching from across the platform. The World Log can know that, if the narrative mode allows it.
That was the reason one memory bucket was not enough.
The project needed at least two layers.
The first layer was the Soul.
That layer tracked the character’s inner continuity: emotional variables, relationship changes, trauma state, personal memories, core memories, schemas, and slow personality drift. This was the “what the character has become” layer.
The second layer was the World Log.
That layer tracked story continuity: setting, active scene, recent objective events, important objects, plot threads, time passage, and what the narrator needed to keep consistent.
Once I saw that split, a lot of earlier problems became easier to name.
Before the split, I kept asking:
How do I make the AI remember everything?
After the split, the question became sharper:
What kind of memory is this?
Is it something the character personally experienced?
Is it something that emotionally changed them?
Is it a world fact the narrator needs?
Is it information the character should not know yet?
Is it just recent chat context?
Is it a long-term plot detail?
Those categories changed the architecture.
A betrayal belongs in the Soul.
A room layout belongs in the World Log.
A repeated kindness might become a relationship schema in the Soul.
A missing keycard belongs in the World Log.
A traumatic memory might become distorted inside the Soul.
A plot event should remain stable in the World Log.
That was the first time Mnemosyne started feeling less like “memory for AI RP” and more like an actual simulation layer.
It was not enough to summarize the chat.
A summary says what happened.
A Soul says what it did to the character.
A World Log says what remains true about the scene.
Those are different jobs.
This also solved part of the narrator problem.
I did not want the AI to simply be the character. That made the model too likely to speak as the character, steal the user’s actions, and collapse the difference between what the narrator knows and what the character knows.
The narrator needed to work more like a GM.
The narrator could see the scene.
The character could only know what they experienced.
The Soul could remember subjectively.
The World Log could preserve continuity objectively.
That meant Mnemosyne needed a narrator architecture, not just a character chatbot.
The character was not supposed to carry the whole universe inside their head.
The narrator and the system had to carry the universe around them.
That was also where the idea of different narrative modes started making more sense.
Realistic mode could restrict the narration to external behavior: body language, voice, movement, visible reactions.
Reader mode could allow access to the character’s inner thoughts, but only what the character themself knows or feels.
God mode could allow the narrator to reveal wider world information, foreshadowing, or details outside the character’s awareness.
Those modes depended on the same split.
Without separating Soul memory from World Log memory, God mode would poison the character. The character might start acting on information they should not have. Reader mode could become too omniscient. Realistic mode could accidentally expose internal state.
So the memory split also became a knowledge-boundary split.
What does the narrator know?
What does the character know?
What does the player see?
What does the engine store?
Those questions became part of the system.
The character’s memory and the world’s memory could not be the same thing.
That was the first conceptual breakthrough after the Soul idea.
The Soul would carry the character’s lived inner history.
The World Log would carry the scene’s objective continuity.
The narrator would read from both.
And the player would only see the story.
That became the next foundation of Mnemosyne.
Not just:
Make the AI remember.
But:
Make the right layer remember the right thing.
Next: Devlog 003, when this split had to become software, hidden state had to disappear from the player’s view, and the app started testing whether the Soul could actually update behind the scenes.