Mnemosyne Devlog
Devlog 001, Trying to Give the Soul a Psyche
The Code Block Was Not Just a Summary Anymore
After the Soul.md idea hit, I started looking at my crude status block differently.
Before that, the code block was just a workaround.
It was something the AI stacked at the end of a roleplay so the next response would not completely lose track of the scene. It tracked things like status, memories, location, emotional state, and physical condition.
Useful, but ugly.
But around this point, I started realizing that the code block could be more than a summary.
It could be an update packet.
That was the shift.
The AI did not need to carry the whole character inside the chat. Instead, the AI could report what changed, and another system could use that report to update the Soul.
That felt important.
The code block was no longer just “memory at the bottom of the message.” It was becoming the bridge between narration and persistent character state.
The narrator writes what happens.
The code block reports what changed.
The Soul absorbs the change.
That was the first version of the architecture in my head.
But then I ran into the harder question:
What exactly should the Soul contain?
I did not want it to be just a list of facts. That would be the same mistake every other memory system makes. A list of facts can tell you what happened, but it does not tell you how the character changed.
So I started thinking about the character less like a bot and more like a psyche.
Not perfectly. Not academically. I was not pretending to be a neuroscientist.
But I wanted the foundation to at least respect how people seem to work.
People do not remember everything equally.
They remember what hurt.
They remember what comforted them.
They remember what violated their expectations.
They remember what touched a fear, a desire, a need, or an old wound.
They forget boring repetition.
But repetition can also become ingrained if it forms a pattern.
That contradiction was interesting to me.
A repeated meal is forgettable.
A repeated kindness can become trust.
A repeated threat can become fear.
A repeated silence can become abandonment.
So memory could not just decay randomly.
It had to decay based on meaning.
That was when I started asking DeepSeek to help research human psychology, memory, emotional states, and how people retain or lose experiences. I was trying to turn that research into a foundation for the Soul.
The early ideas were messy, but the direction was clear.
The Soul needed emotional spectrums.
Trust.
Affection.
Fear.
Shame.
Openness.
Resolve.
Desire.
But those variables alone were not enough. If I wanted the character to feel human, the Soul also needed a psychological foundation underneath them: attachment style, developmental stage, needs, trauma phases, love components, and memory salience.
A character should not recover from trauma just because the user says one comforting sentence. A character who does not feel safe should not behave like someone ready for intimacy, ambition, or self-actualization. A lonely character might overvalue kindness. A frightened character might remember threats more easily. A ashamed character might misread neutral silence as rejection.
That was the kind of memory I wanted.
Not clean database memory.
Human memory.
Messy, selective, unfair, and sometimes wrong.
The more I thought about it, the more the Soul stopped feeling like a character card.
A character card says:
This is who the character is.
A Soul says:
This is what the character has become.
That distinction became the foundation.
A static prompt could describe someone as guarded.
But a Soul could explain why they became guarded, what weakens that guard, what reinforces it, and which memories still shape their reactions.
That meant the code block had to become structured enough to feed the Soul.
Not just:
She is scared.
But:
What caused the fear?
Was it new or familiar?
Did it connect to an old wound?
Did it increase distrust?
Did it reinforce a pattern?
Was it intense enough to become a core memory?
Should it fade after the scene, or stay?
That was the beginning of the memory scoring idea.
I did not have the final engine yet.
I did not have the full app.
I did not even have the clean architecture.
But I had the shape of the problem:
The AI should not be trusted to remember everything by itself.
It should describe the scene and report what changed.
Then the Soul should decide what that change means.
That was the point where Mnemosyne started moving away from prompt engineering and toward a real system.
The prompt was still there.
The code block was still there.
But now I was designing the thing that would read it.
A system that could take the crude code block, interpret the emotional and psychological changes, and update the Soul.
That was the first real Mnemosyne engine idea:
Not an AI that remembers everything.
A Soul that changes like a person.
Next: Devlog 002, when I realized the Soul could not carry every kind of memory, and the system needed to split what a character remembers from what the world needs to remember.