Yesterday, Warner Bell dropped v3.2 of The Nathaniel Protocol, an open-source framework that gives AI assistants persistent memory and intelligence that actually grows over time. The release is quiet on social but loud in the developer circles that care about this stuff. Bell has been building this for two years, and v3.2 is the version where the architecture finally clicks into something you’d actually want to run daily, not just demo once and forget.
Here’s the twist: most memory tools just stuff context back into a prompt. They’re glorified copy-paste. Open a new session, dump in your notes, hope the AI connects the dots. This one builds three separate intelligence stores (patterns, knowledge, reasoning) that compound with every session. The AI gets better at working with you specifically, not at answering generic queries. The patterns store tracks how you like to structure problems. The knowledge store accumulates domain facts you’ve verified together. The reasoning store captures the logic chains that actually worked, so the AI stops re-deriving conclusions you’ve already landed on. After a month of use, the gap between a fresh session and a well-worn one is significant. That’s the compounding part. It’s not hype. It’s just arithmetic applied to memory.
Here’s how the workflow looks in practice:
- One-command setup, zero prerequisites on Windows. Bell spent a lot of time on the install experience specifically because most MCP setups are a mess of PATH errors and manual config edits. This one runs a single script that handles the rest, including writing the config file for Claude Desktop automatically.
- 📁 Pick your domains, 15 protocols available (dev, writing, research, security, planning, and more). You don’t activate all 15 at once. You pick the two or three that match your actual work. A solo developer might run dev plus planning. A writer might run writing plus research. The protocols define what kinds of patterns and corrections get tracked, so specificity matters here. Broad protocols miss the nuance; tight ones build fast.
- 💬 Work normally, patterns and corrections get tracked automatically across sessions. This is the part people underestimate. You don’t do anything differently. The protocol monitors what you accept, what you reject, and what you override. If you consistently rewrite the AI’s list formatting into paragraphs, it learns that. If you always add a risk note to deployment decisions, it starts anticipating that. The tracking is passive and cumulative.
- 🔍 Query your knowledge base with hybrid semantic and keyword search across 800+ entries. By month two, your knowledge base is genuinely useful on its own. The hybrid search means you can ask “what did we decide about the auth flow” and get the right entry even if you didn’t use those exact words when you logged it. Semantic search handles intent; keyword search handles precision. Running both together catches what either alone would miss.
- ⚡ High-stakes actions trigger full verification gates; routine tasks flow without friction. The system classifies actions on the fly. A quick note or a search query gets no gate. A schema migration or a production deploy gets the full checklist pulled from your reasoning store. You never manually decide which mode applies. The protocol reads the action type and routes accordingly.
Pro tip: The risk-proportional gate system is the underrated piece here. It doesn’t treat a quick note the same as a critical deployment. Complex decisions get full scrutiny; simple work moves fast. That distinction alone saves a lot of friction. Most teams either gate everything (slow, people start bypassing) or gate nothing (fast until something breaks). Bell’s approach is to use your own historical data to set the threshold dynamically. Actions similar to things that caused problems before get heavier review. Actions similar to things that ran clean get lighter review. The gate calibrates itself over time the same way the memory does. If you’ve been burned by a specific class of mistake before, the system starts catching it earlier in the workflow, before it reaches execution. That’s the part worth paying attention to.
Works with Claude Desktop, Cursor, Windsurf, and Kiro (the recommended pick for v3.2 specifically, because Bell optimized the MCP integration around Kiro’s tool-call structure). Data stays local. No cloud sync, no third-party storage, no subscription. Your knowledge base lives in a folder on your machine. You own the compounding.
👉 Grab the framework on GitHub and read the full architecture breakdown on Substack. The Substack post goes deep on how the three stores interact, which is worth the 10-minute read before you set up your first domain protocol.
I built an open-source framework that gives AI assistants persistent memory and a personality that actually learns [The Nathaniel Protocol v3.2]
by u/warnerbell in PromptEngineering