The idea
One brain on the server, many agents plugged into it. Agents don't carry context between sessions — they check out exactly one project's current truth at session start, write back durable outcomes the moment they happen, and everything else stays in the database costing nothing until asked for.
Session lifecycle
No hooks anywhere. The instruction file tells agents when to call; the server does the rest. A killed session loses nothing because writes happen at decision-time, not at session-end.
Every retrieval & write point
Deterministic SQL — no similarity search. Returns ALL current rules (project + global) and current facts.
Hybrid search: vector + full-text fused, optional AI rerank. Scoped to one project.
Reconcile-before-add: contradictions supersede the old version instead of piling up next to it.
memory.md is a live projection — re-rendered from the database on every read. Not a file; can't rot.
Fired only by your click on a memory. Output saved back as extended context in the same project.
Open threads get closed (or reopened) by agents via MCP when the work actually happens.
Scoped memory flow
Scopes are hard walls at query level: a DataForSEO question in one project can never surface another project's billing noise — the failure that made v1 useless.
Borrowing context across projects
Working in one project and need an old one? You borrow one drawer — the rest of the cabinet stays shut.
Agent calls recall on the other scope mid-session. Gets ~8 snippets, nothing else.
That project's current truth as markdown — paste it into any tool, session, or doc.
One clean page, human-readable, always current.
Why other projects can't leak in
The scope isn't a search preference — it's a wall before the search even starts.
v1 failed because similarity ran over everything and hoped for the best — a DataForSEO budget question surfaced Google Cloud billing noise. v2 deletes the possibility: memories outside the scope are not ranked lower, they are not in the race at all.
How memories are cataloged
Two layers, like a library: a Dewey-decimal address everyone can compute, plus a librarian who remembers what every book means.
Rules and current facts are fetched by address — complete, no guessing. History is fetched by meaning — the graph you fly through is literally this second layer made visible: nodes that sit close together have similar fingerprints.
The write path — why contradictions can't pile up
Agents reading state only ever see one current answer per subject. The $50 version still exists — as history, findable when you ask "what changed?", invisible otherwise. Database-level constraint enforces one-current-per-subject even under crashes.
Dashboard features
That cluster's current truth as markdown — copied to clipboard and downloaded. Paste it into any AI session, doc, or tool.
Pushes the same snapshot as MEMORIZE.md into the project's GitHub repo, marked as generated with a pointer to the live source.
Write a rule, fact, decision, or gotcha by hand — goes through the same contradiction-checking as agent writes.
Deepen any memory on click; the result is saved back as extended context on that subject.
Every client that talks to the memory server — Claude Code, Codex, Hermes, scripts — with live/idle status and last-seen. New memories record which client wrote them.
Scrub or replay the graph chronologically — watch memory grow.
The server compares when each project was last worked on (any agent read) against when memory was last written. Recently active but nothing saved → amber dot on the project, with exact "worked on / last write" times inside.
If a gap opens while you're working — an agent reading a project but writing nothing back — a real-time alert appears within a minute. The fix is one sentence to the agent: “save what we decided or learned.” Silent context loss becomes a visible, fixable event.
How this differs
Most tools do one of these things. The point here is the combination — every column ships in one self-hosted box.
| this system | mem0 | Zep / Graphiti | Context7 | Obsidian | |
|---|---|---|---|---|---|
| What it is | agent memory OS | memory API | temporal knowledge graph | library docs feed | manual notes |
| Deterministic rules read (same answer every time) | ✓ | ✗ similarity search | ✗ graph traversal | n/a | ✗ you search |
| Contradiction handling | ✓ supersede, old kept as history | partial — update-omission documented | ✓ edge invalidation | n/a | ✗ manual |
| Hard scope isolation (projects can't leak) | ✓ enforced in SQL | ✗ shared vector space | partial — groups | n/a | folders only |
| Detects agents that forget to save | ✓ gap alerts + push | ✗ | ✗ | n/a | ✗ |
| Works with Claude Code / Codex / any MCP agent | ✓ native MCP | ✓ MCP | ✓ MCP | ✓ MCP | ✗ plugins |
| Self-hosted, your Postgres, no per-call vendor fee | ✓ | cloud or self-host | cloud-first | cloud | ✓ local |
| Zero hooks / zero client machinery | ✓ instruction-driven | SDK calls | SDK calls | ✓ | n/a |
| 3D graph of what your agents know | ✓ | ✗ | ✗ | ✗ | ✓ 2D |
Context7 solves a different problem (up-to-date library docs) and pairs well with this rather than competing. Obsidian is for humans; this is for agents.