The agents were not forgetting me. They were remembering different versions of me.
One memory said Mnemosyne was dormant.
The index sitting above it said the provider had been reactivated.
The live configuration said it was active.
Three answers. One machine.
Nothing had been forgotten. That was the problem.
The system had preserved every version of the truth, then left the next agent to decide which one deserved a weapon.
I had 26 project-memory stores, a session archive, a knowledge graph, a person model, Claude instructions, Codex instructions, and ten Hermes instruction surfaces.
I still had to repeat myself.
That is not a memory problem.
That is a chain-of-command problem.
Memory without a chain of command is gossip.
The fix was not another database. It was one canonical user layer, native adapters for each runtime, and fresh-session evals that forced every agent to prove it had loaded the right rules.
More memory. Less trust.
At first, the setup looked sophisticated.
Claude knew how I worked. Codex knew the repo. Hermes had specialized profiles. Mnemosyne could hold durable memory. Honcho carried a representation of me. claude-mem held the session trail.
Each system was useful.
Together, they could behave like six people taking notes in the same meeting without agreeing on who writes the minutes.
Claude knew I wanted the answer first. Codex opened with throat-clearing. One Hermes profile followed a standing preference while another acted like the preference had never existed.
So I would correct the agent.
Again.
And because the correction mattered, it got saved wherever I happened to be standing.
A Claude file. A project note. A profile instruction. A persona conclusion. A session observation.
Now the preference existed in five places.
Which sounds safer until one of them changes.
Then you do not have redundancy.
You have five future arguments.
This is how more memory made the agents less reliable. The system stopped forgetting my corrections and started preserving their entire family tree.
Old truth. New truth. Generated summary of old truth. Index entry pointing at new truth. Runtime proving something else entirely.
More memory. Less trust.
We stopped asking where to save things
The breakthrough came when we changed the question.
Not: Where can this be stored?
But: What kind of thing is this, and who has the right to own it?
A stable user preference is not a project fact.
A project fact is not a safety boundary.
A procedure is not a memory just because somebody typed it into Markdown.
A session summary is not present truth.
And a closed incident is not useless. Sometimes that incident is the only reason the current rule makes sense.
Once those stopped masquerading as the same thing, the architecture got simpler.
Current code, configuration, databases, and runtime behavior decide what is true now.
Stable user preferences live in one canonical source.
Project facts stay inside their projects.
Procedures become tested skills.
Volatile runtime state becomes a command that checks reality instead of a paragraph pretending reality will hold still.
Session history stays episodic.
Incidents stay attached to the lessons they bought.
One kind of memory. One rightful owner.
One truth. Native voices.
We found ten rules that actually belonged at the user level.
Address me as Dr. Mani. Answer first. Do not walk me in circles. Preserve exact inputs. Check the whole relevant scope. Do not lose work. Do not create conflicting duplicates. Verify primary sources. Keep the prose direct. Do not turn one answer into a committee meeting.
Those rules went into one structured source.
One.
Then a deterministic generator translated them into the native instruction surface each runtime already supported.
Claude Code received a generated startup projection through its verified hook.
Codex received one managed block inside its supported global instruction surface.
Hermes received one managed block in the default runtime and each existing profile.
We did not dump the rules into Mnemosyne persona rows and hope every runtime magically found them. We did not flatten the Hermes profiles into one beige assistant. We did not let the shared user layer outrank project instructions, runtime identity, or safety boundaries.
Engineering stayed Engineering.
Architect stayed Architect.
Codex stayed bound to the repo in front of it.
The agents did not become one agent.
They became different agents who knew the same person.
One truth. Native voices.
Then we made them prove it
The generated files had hashes, schema versions, managed markers, byte limits, and end sentinels.
Manual edit? Fail.
Stale hash? Fail.
Missing rule? Fail.
Truncated output? Fail.
Half-finished activation? Roll it back.
That proved the machinery.
It did not prove the experience.
A perfect instruction file is still useless if the agent never loads it.
So we launched 24 fresh sessions across 12 runtime targets.
Each target had to load the exact rules that applied to it. Each had to preserve its own identity. Each had to obey a higher-authority local instruction. Each had to keep an opaque project token inside the project where it belonged.
The clean session could not know the token.
The project session had to.
That was the difference between testing a file and testing a relationship.
Tests prove the pipe. Evals prove the drink.
What changed when I opened the next session
Before the repair, every new session carried a small tax.
Does this one know me?
Am I about to explain the same thing again?
If I correct it here, will that correction stay here or infect every profile?
Is this answer coming from current evidence or an old paragraph with good posture?
After the repair, the relationship became boring in the best possible way.
Claude, Codex, and Hermes know the same applicable preferences. They still have different jobs. Project facts stay inside projects. Current evidence beats remembered prose. Ambiguous rules stay quarantined. Every activated surface has a tested rollback path.
I do not need them to remember everything.
I need them to know which memory gets to speak.
That is the real benefit.
Not recall.
Continuity.
Not one giant AI personality smeared across every tool.
One person, remembered correctly by different tools.
Memory without a chain of command is gossip.
Give memory a chain of command and the whole system gets quieter.
Then you can finally get back to work.
Leave a Reply