I run my own little memory backend. It is called daimon-memory: a small Rust service my AI tools talk to so they share one brain instead of each keeping its own goldfish memory. Claude Code, Codex, and Hermes all point at it. That was the idea, anyway.
The reality, until this week, was messier. The client side of each integration had grown organically, and "organically" is the polite word for scattered. The plugins lived inside the server repo, tangled up with the Rust. Hermes was wired in with a hand-rolled script that copied files into place. Every tool had its own slightly different setup. And here is the embarrassing part: I could not have told you, with a straight face, which of them actually worked. Claude Code, yes. Codex and Hermes? I assumed. I had not really checked.
That is a bad place to be with a memory system. The whole point is that it works quietly in the background, which also means that when it quietly stops working, nobody tells you.
So instead of poking at each broken thing one at a time, I changed the approach.
Move the clients out of the server
The Claude Code and Codex plugins now live in their own marketplace repo, separate from the backend. The server is the server, the clients are clients, and they talk over a configurable endpoint. You can point a client at any daimon-memory instance, local or remote, without ever cloning the server.
Give every tool the same shape of install
No more bespoke per-tool rituals:
- Hermes: a real pip package (
daimon-hermes) with asetupcommand, instead of a copy-files script. - Claude Code and Codex: marketplace plugins, each with a small
install.shthat writes the endpoint and key where that tool expects them.
Install, point it at your server, done. Same story everywhere.
Keep the shared code honestly shared
Claude Code and Codex run most of the same plumbing: the recall client, the state handling, the save-nudge engine. Those files are now byte-identical across both, with a CI check that fails the build the moment they drift. Fix a bug once, both tools get it, nothing silently rots out of sync.
Make the changes trackable
Because it is its own repo now, every change has a visible history, a staging branch, CI, and a clean promote-to-main step. I can see what changed, when, and why. Next to "it is buried somewhere in the server repo's integrations folder," that is night and day.
The work itself was unglamorous: move files, write installers, register a memory server the way each tool actually wants it, add a check that yells when the auth is wrong instead of failing in polite silence. But the change in approach is the real win. The integrations went from a pile of scripts I hoped still worked to one repo I can read, track, and trust.
This is still a work in progress. Hermes is the holdout: it is pip-packaged now, but its provider still sits inside the server repo, not yet pulled out to the marketplace repo with the Claude Code and Codex plugins. That decoupling is the next bit of tidying.