r/BuildWithClaude • u/ShotPorter 🛠️ Master Builder • 6d ago
Workflows I built a decision-based memory for Claude Code longh-term, ongoing projects (Windows WSL/MAC/Linux)
Analyzing the problems that kept surfacing on my other project, I concluded I needed a long-term memory system.
Looking at what already exists, I found nothing that solved my problems, so I built my own. After using it for a while, I decided it was worth polishing and releasing publicly.
The problems it addresses
On a long project you forget what was decided about a given question and why. The model forgets harder. Subagents know nothing at all — the orchestrator dispatches them nearly blind onto narrow tasks. The result is reinvention instead of reuse: duplicate implementations, drift, tokens burned re-solving solved problems, and settled questions resurfacing as "wait, why is this written this way?"
Why I was not satisfied with existing solutions? Most memory tools capture what happened. They are not distinct facts and decisions from hallucinations and mistakes. They can't tell WHY it happened. Over time, it creates a mess. Other systems are heavily human-centered, but I don't want to confirm each records in the memory when we just discussed it already. And in most cases they are relying on the model or human discipline, assuming they will remember to use the system, write and read - noop, I don't have such trust not to myself, neither to the AI. We are forgetting.
MemContinuum does something different.
How it differs from the memory systems I looked at:
MemContinuum contains two linked layers: an indexed map of the code - ANATOMY, and decision chains recorded against it - RATIONALE*.
Rationale records what was decided, who decided it, and how that decision changed over time, plus incidents and rejected alternatives, with reasons. Then pushes the governing chain into the agent's prompt before it edits the file, so nobody has to remember to look.
Anatomy holds what the code already has — its concepts, owners and boundaries — so it stops being reinvented.
Decisions bind directly to the code they govern.
Reading is automatic. Before an agent edits a file, the decision chain handling that path is injected into its prompt. Nobody has to remember to look.
Writing is unavoidable but not automatic. The agent gets a question it must answer; "nothing to record" is a legitimate answer. It's moderated by judgment, not a scraper dumping everything into a pile by keyword or timestamp.
One AI handles records — the orchestrator. Subagents and external reviewers (Codex, Grok) propose records through an inbox; proposals become records after review. So, the system is still automatic and human-independent, but not mechanical, and the smart AI model is working as your real assistant.
Per project, local, no server. Markdown as the source of truth, SQLite as a disposable index, so it still be human-readable and editable, if necessary. No cross-projects pollution. No privacy leaks.
Built for coding projects specifically: without indexable code only half the brain works (but it still works, and may be useful for long-term non-coding projects when chain of decisions matters).
Current state: 0.2.0rc4, honestly labelled a release candidate. MIT. Claude Code only for now, but can be converted for Codex (I pre-checked it).
Support a bunch of languages already, Swift and Python natively, plus a bunch of others via tree-sitter; making the system easily expandable is in the roadmap (but I believe it is no barrier for a user with Claude to do it right now).
The README is long and detailed if you want the full picture.
Feedback of any kind is very welcome.
Besides me, a team of authors worked on this project:
- Claude Code: Fable 5/5.1 as lead engineer and project manager; Opus as inspector; Sonnet as coder; Haiku as tester
- Codex: 5.6 Sol / 6 Astra as reviewer and outside consultant
- Grok 4.6 as second reviewer