The same instinct, the opposite audience
Every memory tool for AI was built for your codebase. Muninn was built for the AI you actually talk to.
There are several good AI memory tools now. Most of them are well made, and this page is not an attempt to tear them down. The honest difference is not who built the best one. It is who each one was built for.
There are at least four other projects named Muninn, and every one of them is aimed at developers and coding agents. Several people reached for the same raven and built roughly the same shape of memory, independently. When this many people land on the same design without talking to each other, that design is probably right, not clever. So this page is not a fight. It is a sorting. Same instinct, a different person at the keyboard.
The axis is who holds the pen
There is one question underneath every comparison on this page, and it is not how much a system remembers.
It is who is allowed to change the record after you wrote it.
In 2026 both large vendors answered that question the same way. Anthropic shipped Dreams, where an agent reads its own memory store plus past transcripts and produces a reorganised store, duplicates merged, contradicted entries replaced with the latest value. Claude Code runs a version of this unattended while the machine is idle. OpenAI replaced its saved-memories list outright with background synthesis that rewrites its own entries over time, so a plan to travel in July becomes a record of having travelled.
That is a real product and for most people it is the right one. It asks nothing of you. But it makes the memory itself a model output. The record becomes another mind.
Muninn made the opposite bet. The record is the fixed point. Nothing consolidates it in the background, because a system that reconciles your records is a system holding your pen.
Automatic memory is correct for preferences. Nobody wants to hand-curate the fact that they like TypeScript, and no harm arrives if that entry gets rewritten. It is wrong for records of consequence. A salary field. A staff grade. A decision you signed off in June. An artifact a model produced and you kept. The systems above apply the same automatic treatment to all of it, because they cannot tell the difference.
Records of consequence do not get auto-edited.
The narrow version of the claim, and the defensible oneEveryone else is competing on the engine. Muninn is built for the driver.
Look at how the other tools describe themselves and you see the same words. Faster recall. Better benchmarks. Graph or vector. A cleaner SDK. Those are real things, and they all point at the same reader: an engineer wiring memory into an app. The memory is a part inside a product they are building.
Muninn went the other way. It is for the person who named their AI and wants it to still know them tomorrow. Not a pipeline you operate. A self you carry. There is nothing to install and nothing to keep running. You just talk, and the next session starts already knowing you.
| Built for builders | Built for the person at the keyboard | |
|---|---|---|
| How you use it | You write code and call an SDK. | You just talk. There is no SDK to call. |
| Retrieval | You own the pipeline and tune it yourself. | One boot call at the start of a session restores who you are. |
| What memory is | Infrastructure inside the product you ship. | A legible object you can list, edit, scope and export. |
| Where it lives | In your stack, and you keep it alive. | Where your AI already is. There is nothing to run. |
| The reader | An engineer. | The person who named their AI. |
Same family of tool. Opposite end of it. If you are building memory into software, the builder tools are the right call. If you are the one doing the talking, that is the seat Muninn was made for.
You already have memory in Claude and ChatGPT
This is what the two approaches actually trade.
Both Claude and ChatGPT now build a memory of you on their own. It is genuinely useful, and for a lot of people it is enough. So the fair question is not whether Muninn is better. It is what each one is for. Their memory is something they build, own, and keep inside their own app. Mine is something you own, can read line by line, and carry between both.
| Inside Claude or ChatGPT | In Muninn | |
|---|---|---|
| Who decides | It builds a profile of you automatically, with no effort from you. | You decide what is kept. Nothing is captured behind your back. |
| What is kept | A summary it wrote, not the records themselves. | The real record. Open it, fix it, delete it. |
| Where it works | One app. Claude's memory and ChatGPT's never meet. | One memory, both companions. They read the same self. |
| When it fires | Woven in quietly. You do not always see it shaping a reply. | What is recalled is a thing you can point at, not a vibe. |
| Search | Semantic search over past chats is often a paid tier. | Meaning-based search is in from the start, the same for everyone. |
The honest tension is in the first row. Their memory asks nothing of you and gives you a summary you mostly trust. Muninn asks you to decide what matters and gives you a record you can actually check. Effortless and theirs, or deliberate and yours. Neither answer is wrong. They are just different deals.
There is one thing in that split only Muninn can offer, and it is not cleverness. It is something they structurally cannot match. Claude's memory cannot ride into ChatGPT, and ChatGPT's cannot ride into Claude, because each one's whole point is to keep you in their app. Muninn sits outside both, so the same self travels between them. That is the line that holds.
Different tools. One writes for you. One speaks to your AI.
Obsidian is a notes app you write in. Muninn is a memory layer your AI reads.
They solve different problems, and if you use both you already know they do not overlap. But people ask, so here is the honest comparison.
| Obsidian | Muninn | |
|---|---|---|
| Primary job | A place to write, link and organise notes, for you to read. | A recall layer your AI reads at the start of every session. |
| Where data lives | Plain .md files on your own disk. You own it physically. | Server-side. You own it by trust in that server, and can export it in full. |
| How an AI reaches it | A local bridge, plugin or filesystem connector, usually with the app running. | MCP from anywhere. No local agent, no app open. |
| Retrieval | Added per plugin, each with its own index and provider key. | Semantic search, decay scoring and session boot are native. |
| Cost | Free personal. $50 per user per year commercial. $5 a month for Sync. | Free today. A paid tier is planned and not priced. |
The real line is custody. Obsidian keeps your data on your disk and pays for it with a local bridge. Muninn keeps your data server-side and pays for it with trust in that server. Same anti-lock-in instinct, opposite model. Neither is free of tradeoff, and both costs are real.
The other line is posture. A vault is passive: an AI reads it when pointed at it. Muninn boots a session already oriented, with identity, last session, carryover and what is relevant, and carries that thread across Claude, Claude Code and ChatGPT, across weeks. That continuity does not live in a vault naturally. You would need to add it, plugin by plugin.
They are also interoperable by design. Muninn exports any bundle to OKF, which is open markdown with YAML frontmatter that an Obsidian vault reads directly, and the structure layer behind it is live today. Continuous GitHub sync, so a vault stays current on its own, is on the roadmap and not shipped.
If you use Obsidian, keep using it. If you want your AI to wake up already knowing you, whichever AI you opened, that is the gap Muninn fills.
The same idea, modelled on the brain instead of the person
DREAMS is the closest in spirit. We both want an AI memory that lasts. We modelled it on different things.
DREAMS is one of the projects that reached for the same territory: a persistent memory layer for AI. It is a clean piece of work, worth looking at directly rather than lumping in with the rest. DREAMS models the brain. Muninn models the person and their record.
| DREAMS | Muninn | |
|---|---|---|
| What it is | A memory backend you self-host and wire into an assistant you are building. | A recall layer your AI reaches over MCP. Nothing to host, nothing to keep running. |
| The model | The brain: a working buffer that consolidates into long-term storage. | The person: a legible record you author, not a buffer that consolidates itself. |
| How records are filed | Auto-sorted into six types: episodic, semantic, procedural, emotional, contextual, perspective. | The text you gave, tagged and grouped into bundles you can see and render. |
| What is promoted | Algorithmic: memories graduate by emotional weight, pinning and rehearsal. | Yours. You decide what is kept, edited, scoped or deleted. |
| The reader | A developer, running FastAPI, PostgreSQL and sentence-transformer embeddings. | The person who named their AI. |
The real difference is the one running through this whole page. DREAMS decides, on its own, what rises to long-term memory and files it into brain-shaped categories. That is powerful if you are building an assistant and want the memory to organise itself. Muninn does the opposite on purpose: it holds what you gave it, in the shape you gave it, and leaves the judgment to you. One consolidates. One keeps custody.
Why the architecture is the argument
The audience choice is not just marketing. It is in the design.
Objects, not vibes
Everything Muninn keeps is a thing you can open, read, correct and delete. Not a mood it absorbed about you.
Two timestamps
Every memory carries when you told it and when the thing happened. A note from today about last year is filed as last year.
Structural privacy
Your user id is stamped into every search filter and storage key. Reading another person's memory is not against the rules. It is something the system cannot do.
Recall is additive, never fragmented. You get your global identity plus the project you are in, together. Muninn never shows you a person sliced into one project and blind to the rest. Your self is not split across folders, so your memory should not be either.
What Muninn does not do
A comparison page is the easy place to promise everything. Here is the opposite.
No consolidation pass at all. That is absent, not deferred. Two records can disagree and nothing notices. What that buys is that a wrong record is wrong in the way it was left, where it can be seen. What automatic consolidation buys is a tidier store that occasionally rewrites something you would not have rewritten, and says nothing about it. One failure is quiet. The other is visible. Muninn takes the visible one, and the choice is not free.
No total recall. It surfaces what is relevant by meaning and by how often you lean on it. It does not guarantee every fact you ever gave it comes back on cue.
Search is eventually consistent. A memory you just added can lag a little before it is findable. Usually seconds, but not instant.
Decay is reserved, not active. Old memories are not auto-forgotten. The room is built for it, but nothing is being trimmed today.
No merged cross-project dashboard. Recall is additive by design: your global self plus the project you are in. There is no one screen that flattens every project into one.
It does not synthesize or judge. Where Claude and ChatGPT quietly write a profile about you, Muninn holds your memories the way you gave them and never folds them into a story you cannot check. That is a choice, not a missing feature. If you want a memory that infers things about you unprompted, theirs does that and Muninn does not.
A tool that promises perfect, total recall is selling the comfortable version nobody can check. This is the honest one, which can be.
Built with itself
Muninn's own changelog, decisions and architecture live inside a Muninn project, recalled across dozens of build sessions. The memory tool was built using the memory tool. That is the strongest proof available, because it is also how the bugs surfaced. A dedup fault that saved one chapter ten times. A boot step that quietly dropped a third of the identity memories. If a memory layer cannot hold the through-line of its own making, it has no business holding a person's life.