Your agent finally
remembers what mattered.
OpenMnemex judges every session for what's worth keeping and files it into a self-pruning knowledge graph — just Markdown in a git repo. No vector database. No embedding pipeline. No server.
$ uvx openmnemex@latest # runs it, installs nothing
Agents are brilliant in the moment — and forget everything after it.
The two usual fixes each carry a sharp, permanent cost. OpenMnemex takes a third path.
Stuff everything into context
You pay for the whole pile on every single turn — context bloat, runaway cost, and diluted attention as the history grows.
Gets worse over timeEmbed it all into a vector store
Now you operate an embedding pipeline, an index, and a database — and retrieval is opaque: you can't read it, diff it, or trust it.
Infra + opacityRemember like a human does
Knowledge is files. Relevance is a number computed on demand. Used things stay hot and cheap; unused things quietly decay and die — unless something still points at them.
The OpenMnemex wayGive your whole org a shared memory — in an afternoon.
One git repo becomes your company's institutional knowledge. Every engineer's agent reads and writes it, routed like your org chart — and you seed it from the repos you already have.
- 🏗️Bulk-ingest what you already havePoint Mnemex at your service repos and docs. It distills years of ADRs, API contracts, and code comments into a connected graph — one command per repo, no live session needed.
- 🗂️Structured org → team → domainThe graph routes the way your company is shaped: an org router picks the team, a team router picks the domain. New engineers' agents inherit the whole institutional memory on day one.
- 👥Shared graph, isolated draftsEveryone's agents read the same promoted graph, but each person's captures stage locally until a deliberate promote. No one steps on anyone's memory.
- 🔁Stays in sync as you evolveRe-run ingest after the code changes and it imports only the diff — idempotently. A deleted source surfaces as an orphan candidate to judge, never a silent deletion.
- 🔒Safe by constructionIngest only stages (promote stays the sole writer), never reads secrets, and never mutates your source.
index.md # org router — which teams exist team-payments/ index.md # team router — HOT / WARM / COLD settlement/ … # domain: nodes + patterns ledger/ … team-risk/ index.md fraud-signals/ … team-platform/ auth/ · observability/ …
Two gates — approve the scope & routing map once, one bulk summary at the end. Never per-atom review. A monorepo is one decision, not ten thousand.
/mnemex:mnx-ingest github.com/acme/payments-service
Reads stay cheap — even at thousands of nodes.
Context-stuffing and vector-RAG both get more expensive as your knowledge grows. Mnemex is architected the other way: a read's cost scales with the path you take, not the size of the graph.
- 🧭 Route, don't retrieveYou read one-line index heads to pick a path (org → team → cluster). Nothing is pasted into context on spec.
- 🔥 Hot = top-K, chunk 1The routing head is capacity-bounded, so the baseline read stays small no matter how big the graph gets.
- 📚 Chunked reads, stop earlyRead Hot first — it's usually enough. Warm/Cold load only on demand. You rarely load a whole index, never the whole graph.
- 🏷️ Match on summariesEach index row carries the node's summary + aliases, so you match the right node without opening a single body.
- 🔎 Expand only on commitLoad only the bodies you'll actually use, inside a per-hop token budget — beam search, not "load every neighbor".
- 🗑️ Self-pruning surfaceDecay and death keep the routing surface small over time — no landfill of dead knowledge to page through.
Tokens spent per read, as the graph grows
Illustrative — the shape is the point, not the exact numbers.
💡 The payoff: a read is a few small index-head reads plus only the node bodies you commit to — not the corpus, not a wall of retrieved chunks. Retrieval stays cheap exactly where naive context-stuffing and RAG get most expensive.
Memory that curates, ages, and re-checks itself.
Everything a real memory system needs — none of the infrastructure everyone told you it required.
It decides, not you
When a session ends, it asks the questions a person would — is this relevant, significant, novel? — and keeps only what passes. You build; it remembers.
Plain Markdown in git
Every node is a readable, diffable Markdown file. No proprietary store, no black box — git log is your full memory history.
Self-pruning by design
An Ebbinghaus forgetting curve and spaced-repetition boosts move knowledge through 🔥 hot / 🌤️ warm / ❄️ cold tiers. The landfill never forms.
Knows when it's stale
Every fact carries a verified clock. Past its horizon it's flagged for a re-check — so your agent re-confirms instead of confidently repeating something outdated.
Token-frugal reads
Route, don't retrieve. You read tiny one-line index heads to pick a path and open only the node bodies you commit to. Cost scales with your path, not the graph's size.
Every write is reviewable
Capture stages locally; a deliberate promote commits and pushes. You can inspect or un-stage anything first. Automatic, but never unaccountable.
Bootstrap from a repo
Point it at an existing codebase or docs and it distills years of ADRs, comments, and contracts into a connected graph — one command, idempotent re-runs, never a RAG dump.
A Console to see it all
A local web app draws your whole graph: node size and teal depth show usage, amber rings show what's due for a re-check, a time scrubber ages it months forward.
Drops into your agent
A first-class Claude Code plugin with auto-capture hooks and skills — plus a stdio MCP server for every other MCP-capable agent.
The only memory that's yours to read.
Other agent-memory projects lean on a database, a server, or manual note-taking. OpenMnemex needs none of them.
| Capability | OpenMnemex | claude-mem | mem0 | Zep / Graphiti | Letta (MemGPT) | Basic Memory | MCP Memory Server |
|---|---|---|---|---|---|---|---|
Storage you can read & git diff |
✓Markdown in git | ✗SQLite + Chroma | ✗DB rows | ✗graph DB | ✗Postgres | ✓Markdown | ~JSON file |
| No vector database required | ✓ | ✗Chroma | ✗ | ✗ | ✗ | ✓ | ✓ |
| No server / infra to run | ✓ | ~local index | ~self-host or cloud | ✗server | ✗server | ✓ | ✓ |
| Auto-decides what's worth keeping | ✓salience scoring | ~auto-compress | ~LLM extract | ~ | ~ | ✗you write notes | ✗agent must call it |
| Forgets & decays unused knowledge | ✓Ebbinghaus curve | ✗ | ✗ | ~temporal invalidate | ✗ | ✗ | ✗ |
| Flags stale facts for re-check | ✓freshness clock | ✗ | ✗ | ~ | ✗ | ✗ | ✗ |
| Token-frugal, route-don't-retrieve reads | ✓ | ✗semantic top-k | ✗top-k inject | ✗top-k inject | ~ | ~ | ✗loads graph |
| Bootstrap a graph from an existing repo | ✓distill, not RAG | ✗sessions only | ✗ | ✗ | ✗ | ~import notes | ✗ |
| Visual console for your memory | ✓hotness × freshness canvas | ~timeline viewer | ~cloud dashboard | ~ | ✓ADE | ~Obsidian | ✗ |
Comparison reflects each project's core architecture and default configuration as publicly documented; capabilities differ across tiers, plugins, and versions (e.g. claude-mem auto-captures and semantically retrieves Claude Code sessions). Names and marks belong to their respective owners.
Four verbs, mapped to how memory actually works.
Knowledge writing is split like git itself: capture is the commit, promote is the push.
Read
Route through indexes, overlay staged atoms, expand only what you need, flag anything stale. /mnx-read
Capture
Score each atom now / later / not-needed and stage it locally with its own provenance. /mnx-capture
Promote
Reconcile, merge, consolidate, doctor, and push — one atomic, reviewable git commit. /mnx-promote
Doctor
Validate every invariant and self-heal the derived files, so the graph is always trustworthy. /mnx-doctor
Hot rises. Cold fades. Structure protects.
Tier is literally read cost — the more it's used, the cheaper and closer to hand it stays.
Frequently recalled, top-of-mind knowledge. Lives in the routing head, read first, almost always enough on its own.
Still useful, read only on demand. Ready to rise again the moment it gets used, or to keep drifting if it doesn't.
Rarely touched. Cheap to keep out of the way, and eventually allowed to die — unless something structurally important still points at it.
Give your agent a memory in 60 seconds.
Open the Console, create a graph, and connect your agents with one click.
# 1 · Open the OpenMnemex Console (Python 3.10+) $ uvx openmnemex@latest # 2 · Inside Claude Code — add the plugin > /plugin marketplace add kritird/OpenMnemex > /plugin install mnemex@mnemex-marketplace