On 27 October, at an AI Tuesday meetup in Pattaya, I spent an hour explaining how Hermes Agent’s memory works: the holographic plugin stores facts, and the dreaming skill tidies them up at night. Towards the end, during questions from the audience (the talk is in Russian), people asked: will this work in Claude Code? In Codex? In other agents?
The honest answer back then was “no”. Both plugins were written for Hermes and lean on its core: its hooks, its cron, its memory format. You couldn’t lift them out and drop them into another agent. But the question stuck. I work in Claude Code and Codex every day myself, and each has its own memory that knows nothing about its neighbour’s. Why not build universal versions?
Three days after the talk, two open repositories appeared: holographic-memory and agent-dreaming. As of 31 October they’re at versions 0.8.1 and 0.6.0, both under the MIT licence. Below: what they do, how they work together, how to install them, and how to bring what your agents already know about you into the new memory.
Why agents need shared memory
First, which programs I mean. Claude Code: both in the terminal and in the Claude desktop app. Codex: both the Codex CLI in the terminal and the Codex app, which reads its settings from the same place, so memory installed for Codex shows up there without a separate install. I checked this on my own machine: in the Codex app the relevant facts arrive before each message on their own, and its memory server works with the same database as Claude Code.
Claude Code has auto memory: Markdown notes, separate for each project. Codex has memory_summary.md, a summary it writes itself. Both systems work, but they live apart. Tell Claude Code that the server runs on Bangkok time, and Codex will never hear about it. On top of that, Claude Code’s notes have no history: if a fact changes, the old text simply disappears, and you can no longer ask what was true a month ago.
In Hermes, holographic solved exactly these problems: a fact store with history, trust and search that hands the agent what it needs before every message. All that was left was to teach it to talk to other agents.
holographic-memory: one store for every agent
The engine comes from the holographic plugin for Hermes and is now developed separately, with its own tests: around 2,300 for the engine alone. The store is an ordinary SQLite file on your computer, ~/.holographic/memory_store.db by default. No API key, no network, no model calls. A fact saved in Claude Code is known to Codex too: there’s one store for all of them. If you need to, you can split it by project. By default the agent doesn’t save everything it sees, only what you asked it to remember or agreed to let it keep.
Memory plugs in two ways. The first is a hook, a small program the agent runs by itself at every step: before each of your messages a short process finds the facts related to it and puts them into the context, marked as data rather than instructions. Usually that’s up to five facts that match the words of the message in any form, plus up to two about a person or thing you named. A fact already shown in this session isn’t repeated for the next six turns, and “ok, thanks” costs zero tokens. The second is an MCP server: through it the agent gets twenty-three commands for the store, from save, find and change to merge duplicates, forget and export.
The most valuable thing carried over from Hermes is the way it treats history. Every edit is a dated version, so the question “what was true on 1 October?” has an answer. Something changed in real life: memory_change, and the old text becomes history. It was a mistake: memory_correct, and the wrong text never enters history. It’s no longer true: memory_end. Only memory_forget wipes a fact entirely, history included, and only when you ask for it.
Search understands 18 languages, and in Russian it copes with names in any grammatical case: “rasskazhi pro Iru” (“tell me about Ira”, with the name in the accusative) finds Ira, while “Royu yamu” (“I’m digging a pit”) stays a verb and doesn’t turn into a person called Roy. Text that looks like a password, a key or an instruction to the agent won’t be saved. A new fact that might contradict an old one comes back with a warning, and memory_contradict finds such pairs across the whole store.
Two features are off by default, because both send texts to a separate model. Search by meaning finds a fact even when the question uses different words: for that, the texts of facts and your messages go to an embeddings service of your choice, a cloud one like OpenAI or one running on your own computer. Reranking with a second model filters out facts that matched on a stray word, and adds a request to your server, or to a model on the same machine, for every message. Without them, everything stays on your computer. As for speed: about 0.9 seconds per message with a store of 300 facts on a 2020 laptop, and if something breaks, the hook quietly skips the turn and never blocks your request.
The full version, with facts injected before every message, currently works in Claude Code and Codex. Antigravity, Grok Build, Gemini CLI, Cursor and other agents with local MCP get the memory tools and the same store, but they only see facts when they go looking for them, because their hooks work differently. Cloud chats like Grok in the browser can’t reach a local store at all.
agent-dreaming: a nightly memory audit
An agent that remembers also remembers things it shouldn’t: a guess as a fact, one fact twice in different words, a project that wrapped up a month ago. Dreaming compares what the agents saved with what you actually told them, and once a day asks a few short questions.
The nightly pass is an ordinary script, with no model and no network, and takes seconds. It reads your messages from the past 30 days in Claude Code, Codex, Antigravity and Gemini CLI, checks them against the facts and puts its questions into its own folder, ~/.dreaming. It writes nowhere else. It starts by itself: the first session after a time you set kicks off the pass in the background. In the morning, at the start of a session, there’s one line: “Dreaming: 3 questions waiting”. Just the number, no text from the facts.
The agent asks the questions itself, when you tell it to: /agent-dreaming:dream in Claude Code, $dreaming in Codex. One at a time, no more than seven main ones per sitting; the rest can wait. Do these look like the same fact: merge them? A fact disagrees with a note or with CLAUDE.md. Nobody has mentioned a project for a month: is it still current? The agent saved a conclusion on its own and you never confirmed it. You said the same thing three times on different days: make it stick? You answer in plain words: “yes”, “outdated”, “it changed, now it’s like this”, “forget it”, “don’t ask again”.
A separate type of question covers possible new facts: you said something lasting about yourself, and it isn’t in memory. The pass doesn’t store a single word of your messages: only a link to the session file and two cryptographic fingerprints. During the review the message is read again, the agent first decides for itself whether it’s a fact (is it lasting, is it about you, is it already in memory), and only then asks you. Such a question comes on top of the seven main ones, and there’s only one per review. On a synthetic persona, 86% of what the agent ended up asking about turned out to be real facts; on a real home setup, 7 out of 7, roughly two a week.
Only your own words count as evidence. Background tasks, subagents, cron, text the agent inserted itself and long pasted documents are thrown out, and a message containing a secret isn’t read at all.
Dreaming isn’t tied to holographic. It can check Claude Code’s auto memory notes (they have no history, so “outdated” there means deleting the note) and the file of the reference memory MCP server. It reads Codex’s memory so as not to ask about things already recorded there, but never edits it.
How they work together
The split of roles is simple: holographic stores and serves facts, dreaming checks them but has no write access. Anything that changes as a result of the nightly check changes only after your answer: the agent turns it into a holographic command.
Say you answered “outdated”. The agent records the answer with the dreamem decide command, which prints exactly one call, memory_end for that fact, for example. The agent checks that the session is connected to the same store the night pass read, and makes that call. The call carries the number of the version you were shown. If the fact was changed in another session in the meantime, holographic refuses, and the question comes back with the new text. That way a night that saw yesterday’s store can’t overwrite today’s.
There’s a feedback loop too. If the outcome journal is switched on in holographic (experience = true), the agent records cases where you corrected an answer built on a remembered fact because it was out of date. Dreaming sees that record and asks at night: is this fact still true? The loop closes: memory suggests, the journal records the misses, the night asks the question, and the decision stays with you.
How to install
You need Python 3.11 or newer and uv. Memory first:
uv tool install git+https://github.com/itpartypattaya/holographic-memory
holomem install claude-code --dry-run
holomem install claude-code
holomem install codex --dry-run
holomem install codexIf the terminal can’t find the holomem command after the first line, run uv tool update-shell and open a new terminal. --dry-run shows exactly what will change in your settings and writes nothing. The installer leaves a backup next to every file it changes, and --uninstall removes exactly what it added. In Claude Code, open a new session after installing. In Codex, open /hooks and trust the two holographic hooks, otherwise it won’t run them. For Claude Code there’s also a plugin option: /plugin install holographic-memory --marketplace itpartypattaya/holographic-memory.
Then the audit:
uv tool install git+https://github.com/itpartypattaya/agent-dreaming
dreamem run --dry-runThe trial run shows what dreaming would ask and saves nothing. Next, connect it to your agents. In Claude Code, as a plugin: /plugin install agent-dreaming --marketplace itpartypattaya/agent-dreaming. In Codex and Antigravity, with dreamem install codex and dreamem install antigravity (in Codex, trust the hooks in /hooks again).
All that’s left is to pick a time for the check. After dreamem config time 23:00 it runs the first time you open an agent after 23:00. After dreamem config time any, at the first session of each day, which is handy if your laptop is off overnight. To check everything is in place, run holomem status and dreamem status.
How to move your memory into holographic
If you’ve been working in Claude Code or Codex for a while, your agents already know a thing or two about you. There’s no need to tell them all over again:
holomem import claude-memory --dry-run
holomem import codex-memories --dry-runThe first command reads Claude Code’s auto memory notes from the standard folders, per project and for subagents, and turns each note into one fact. The second takes preferences and tips from the Codex summary and skips the section listing past tasks. With --dry-run you’ll see what goes into the store; without it, the facts are saved. They go through the same checks as any entry and get a trust score of 0.4, lower than facts you added yourself. Running it again won’t create duplicates, and the agents’ original files stay as they were. If a file couldn’t be read, the command names it rather than pretending there was nothing to move. If you once moved Claude Code’s memory to your own folder through the project settings, point the command at it with --path.
After the import it’s worth looking at what you’ve got. holomem export --out memory.md saves all current facts as one readable page, easy to skim or open in Obsidian. It’s an overview without past versions, not a backup, and a file with that name will be overwritten. If search by meaning is on, holomem embed computes vectors for the new facts straight away. The import skips exact and near-exact repeats by itself, and if the same thing was said in Claude Code’s notes and in Codex’s memory in different words, dreaming will offer to merge those pairs overnight.
Claude Code’s auto memory keeps working after the move. With both systems on, when you say “remember this”, the agent will first ask where to write it: to holographic, to Claude Code’s notes, or both. If you want everything to go into one store, you can turn Claude Code’s auto memory off in its settings (autoMemoryEnabled: false).
There’s no dedicated import from Hermes or from cloud chats. For ChatGPT, Claude.ai and the like you can do it by hand: ask them to write out what they remember about you, check the list yourself, paste it into Claude Code or Codex and ask it to save to holographic whatever will still be true in a month. Nobody promises completeness here: a cloud chat may not write out everything. The agent saves the facts one by one through memory_add, filters out secrets and instructions, and tells you where a new fact looks like one already saved.
What’s still rough
Both projects are a few days old, at 0.x versions, and that’s worth keeping in mind. The agents’ session formats are internal and change from version to version: if dreaming runs into an unfamiliar format, it honestly flags incomplete coverage and won’t ask “still current?” based on that night. Fact injection before a message only exists in Claude Code and Codex. The filter for possible new facts is tuned for Russian and English. Search by meaning with a cloud service sends texts out, so switch it on deliberately.
I have both programs on my work laptop, and one memory store serves Claude Code, the Codex CLI and the Codex app. If you try them yourself, bring your questions and findings to the IT Party chat (in Russian), and bugs to the repositories’ issues. The talk that started it all is here (in Russian).
