Can Hermes and Claude Share Memory?
Seed your self-improving agent from a shared vault
You run Hermes as your always-on personal agent — it learns you over time, handles tasks in the background, improves with use. And you use Claude for the thinking work: drafting, reasoning, deciding. Two agents, both building a picture of you, neither aware the other exists. What you work out in Claude never reaches Hermes. What Hermes has learned about you never shows up in Claude.
They can't share memory on their own. But there's a way to give both the same picture of you.
Can Hermes see what you told Claude?
No — not on its own. Hermes stores its memory as local files (SOUL.md, USER.md, MEMORY.md) on the machine it runs on. Claude stores its memory in Anthropic's cloud, scoped to your account. Neither has any path to the other. Hermes can't read Claude's Chat Memory, and Claude can't open Hermes's files. Everything you establish in one stays there.
This isn't an oversight — it's the shape of the whole market. Every platform's memory is the thing that makes its product sticky, so none of them are built to hand your context to a competitor. ChatGPT has the most developed memory, Claude offers the most transparent, Gemini builds a preference knowledge graph — but every one of them is siloed, and memory built in one never transfers to another. Hermes adds one more wrinkle: its memory is local files, so even the manual export tricks that work between cloud platforms don't apply the same way.
The result is the same either way. Two agents that each know a slice of you, and a gap between them you keep filling by hand.
What actually works — one shared layer both connect to
A shared context layer fixes it: one vault that holds your context, that both Hermes and Claude connect to instead of relying on their own separate memories. Rather than syncing two memories against each other, you give both agents the same source to read from and write to.
It works through MCP — the Model Context Protocol, the open standard for connecting AI tools to outside data. Both Hermes and Claude are MCP-capable, so both connect to the same vault the same way:
- Read. At the start of a session, each agent loads your context from the vault — who you are, what you're working on, the decisions in flight. Both start informed instead of cold.
- Write. When you work something out in either tool, it saves back to the vault. The next time the other agent loads, that context is already there.
The write step is what closes the loop. Work out a decision in Claude, save it back, and Hermes inherits it on its next run. Have Hermes log something from a background task, and Claude sees it next session. Save-back isn't automatic by default — you turn it on with a custom instruction telling the agent to store new context as it goes, which makes the loop run without you thinking about it.
One important note on Hermes specifically: because it's file-based, its own local files (USER.md, MEMORY.md) still do their job for Hermes-only continuity. The shared layer sits alongside them — it's what lets Hermes's understanding reach Claude and vice versa, rather than staying trapped on the machine Hermes runs on.
The difference from a one-off export is that this stays current. Import features don't fix lock-in — they're one-time snapshots that go stale immediately. Owning your context means keeping it in a portable layer you control, connected to tools through an open protocol. A shared layer isn't a copy you make once; it's the live source both agents read every session.
How to set it up
Give both agents access to the same vault, then let each connect over MCP. The tool that holds the vault and serves it to both is Unabyss.
Here's the shape of it:
- Build your context vault in Unabyss. Connect your real sources — LinkedIn, Notion, GitHub, email — and Unabyss extracts a structured profile in under 90 seconds. This is the single source both agents will share.
- Connect Claude to the vault over MCP. Claude loads your context at session start and can save new context back.
- Connect Hermes to the same vault over MCP. Hermes reads the same context on its runs and writes back the same way. Its local files keep doing their job; the vault is what it shares with Claude.
- Turn on save-back with a custom instruction. Tell each agent to store new context as it works — e.g. "save decisions and new project details back to Unabyss." Now the loop runs automatically in both directions.
Once both are pointed at the same vault, Hermes and Claude stop being two disconnected memories. They're two agents working from one shared picture of you — and you control what's in it and what each can see.
For the full step-by-step across more than two tools, see How to Share Memory Across All Your AI Tools.
The point
Hermes and Claude were never going to share memory on their own — one keeps its memory in local files, the other in the cloud, and neither is built to reach across to a rival. The way to make them work from the same picture of you isn't to sync two memories. It's to give both one shared context layer they read from and write to, so what either learns is available to the other.
See how multiagentic memory works →
