The Tri-Node Memory System
A framework for agentic memory that separates user input and an agent's own memory. https://github.com/CorbanMonoxide/Tri-Node-Memory
The Tri-Node Memory System
Agents have the ability to utilize a persistent memory. An agent wakes up each session, reads its memory files, and rebuilds context. Harnesses like Open Claw do this by default. This approach has a fundamental problem: everything gets dumped into the same memory bucket. Session notes, project context, personal preferences, and even random observations all get tossed together. The session memory quickly gets muddied and sometimes it’s difficult to know where the LLM is drawing information from.
When I first started using Open Claw and AI agents in general, I wanted a system that reliably captured and organized my own personal notes. What I ended up with is my own personal solution to the AI memory problem that makes collaboration more efficient while helping to avoid some of agentic AI’s biggest pitfalls.
I call it the Tri-Node Memory System. To create this system, you’ll keep a knowledge base, your agent will keep its own knowledge base, and that knowledge is melded together in the inference layer of your choice.
The Problem Isn’t Memory. Agentic Harnesses Already Have A Memory. But Whose Memory Is It Really?
Agentic harnesses have made enormous strides in keeping LLMs alive across sessions. By using markdown and loading information to the beginning of a session, an agent comes alive rather than robotically answering limited questions. Now instead of starting from zero every time you load a session, your agent persists and can draw from specific data to distinguish its processes from every other session. Open Claw allows for this at a granular level while other harnesses like Claude Code and OpenAI’s Codex perform some of this behind the scenes.
But persistent memory introduces a new problem: the agent doesn’t know the difference between your decisions and its observations. It treats everything as raw material to reorganize, summarize, and “improve.” Depending on your reasoning level, agents can even confuse your input for its own thoughts. Default agentic solutions dump all important thoughts into one MEMORY.md file and attempt to manage every important thing across all of your sessions in a centralized place. This approach does not allow you to make your own decisions for what your agent should think about.
Your agent’s effectiveness and potential self improvement ability is determined by the heuristics you create guides for. Without a solid way of organizing its own thoughts and distinguishing yours, an agent can be prone to overwriting notes or overruling your rules with its decisions. The agent means well without respecting boundaries because the boundaries are not clear.
The Tri-Node Approach
To address the memory muddying issues explored in the previous section, I developed a set of skills and rules for my agents to use that force them to create their own memory pool separate from the one that I maintain.
What do I need to provide to an LLM so it knows about my work? A personal knowledge database.
What does an Agent need to manage its own memory? An agentic knowledge database.
How does the agent utilize user knowledge alongside its own knowledge? An inference layer that allows it to access both knowledge databases and combine them to produce a stronger output.
This is the Tri-Node memory system. Each node has clear rules about who reads and who writes.
Node 1 - The Human Vault: My project notes, architecture decisions, design docs, and even personal information all live in my own personal Obsidian vault. I save my Obsidian vault as a git backed repository. Any note my agent captures for me (via voice or text) utilizes a custom agent skill that tasks the bot with recording the note verbatim before adding any additional information. The agent reads but never writes (Unless directed).
Node 2 - The Agent’s Journal: The agent gets its own space. This is a separate git repo than my own personal vault. The agent owns it and writes a daily reflection. Sometimes the LLM will keep track of certain aspects that I didn’t find important to our work but later surfaces as helpful. The agent writes and you can read. I personally never make changes to my agent’s vault but you would be able to if you wanted.
Node 3 - The Inference Layer: This is the traditional LLM chat layer. Once the agent and I have our individual knowledge bases defined, all work is performed using each database’s information within an inference layer. This is the LLM of your choice. Nothing persists unless one of us explicitly promotes it. Think of it as a whiteboard. When the session ends, it gets erased. I’ve had my agent suggest I save a conversation to my database from time to time if the topic is relevant enough.
The Feedback Loop
In practice, this system shines when I have multiple projects in my vault and long timelines. When sitting down to work on a project, my agent quickly surfaces all relevant information about the project right to the front. I don’t have to spend any time recontextualizing my work to the agent. It already remembers what it worked on and it grabs my own notes and we’re ready to work. In an agentic harness with development space, skills and internet/API access all working with the tri-node system, your agent will seem like it can pick up mid-sentence where you left off.
The Tri-Node memory system allows you to direct attention in the inference layer with increased accuracy using fewer tokens. Andrej Karpathy outlined this idea already with his Obsidian RAG framework. Basically, an agent can traverse each Obsidian vault by first reading the YAML headers and deciding only to read full pages if necessary. By developing sufficient documentation on a project, either as you go or by having AI analyze a code base, the agent can use fewer tokens.
Agentic harness systems have their own way of handling and distilling memory that already handle persistence at a high level. Organizing that data into an obsidian vault allows for metadata handling and long term persistence because once YAML metadata is being used to traverse the knowledge base, an agent can ignore irrelevant information.
Once the memory systems are in place and your own knowledge base is connected, then you can design feedback loops for agentic engineering. You can work on projects by managing intent. Larger outlines can be iterated within your knowledge base by prompting and manual input to accurately design and ultimately execute.
How to Set This Up
The implementation is straightforward. You need:
An Agentic Harness : Open Claw, Hermes, Codex, Claude, etc.
A LLM Provider : Google, Anthropic, Local LLM, etc.
Obsidian :
https://obsidian.md/
Obsidian Git Plugin: Available in the obsidian community plugin menu: https://github.com/Vinzent03/obsidian-git
A human vault : A github repo for your Obsidian vault
An agent journal : A separate git repo for the agent’s Obsidian vault
The Tri-Node Memory Framework: https://github.com/CorbanMonoxide/Tri-Node-Memory
Template files : I have written template SOUL.md, USER.md, AGENTS.md, and MEMORY.md files to inspire your own agent to use this system
Agent Skills : The skills that the agent will use to capture notes and perform daily reflections.
Simply point your AI agent at my github repo and provide your additional git repositories for the two vaults and let your agent do the heavy lifting.
If you’re using Open Claw, once you have the system set up, try having your bot capture a note using the vault-capture skill “Please create a test note using the vault capture skill: Today is a great day to learn about AI memory systems! I enjoy talking to agents that have memories!” Your agent will capture the note, use the most relevant template and tags and push it to the github repo. Simply pull the note down from github (git pull) or use the github community plugin in Obsidian to sync the note with your local installation.
What’s Next?
This is a framework that makes working with your AI agent easier and more relevant. Visit to see my open source repo and consider creating a template others can use for your favorite harness! https://github.com/CorbanMonoxide/Tri-Node-Memory
I write about AI agent architecture, memory systems, and the boundary between human and machine. Follow my Substack for more ideas.