Agent memory: a reading path from personal context to company knowledge

Fifteen thousand stars for a git-backed wiki of markdown files is a strong signal. ai-memory is a solution for long-term memory for agent coding CLIs, and more than twenty harnesses, Claude Code, Codex, Cursor and the rest, feed one shared memory. People want memory they can read and grep. So I would start with a simple tool for basic memory, then explore the managed solutions, and finish with a custom made one. Each step shows you something the next one has to solve.

The reason to walk the path at all is accuracy. You have to understand how memory and context management can improve AI accuracy and effectiveness before you can tell which solution fits your needs. That is why the order runs from a single file to a governed layer. By the end, the question is no longer what the tool does. It is what your organisation needs it to remember.

Files you can grep

ai-memory keeps the files as the truth and treats the index as derived and rebuildable. That decision is why it can survive twenty harnesses: quit Claude Code mid-task, open Codex in the same directory, and a handoff carries where you left off, what failed and what is still open. Handoffs are a typed protocol, each one has an owner and is claimed exactly once, and the memory lives on a server you run. Creed is the smaller version of the same idea, one personal context file that every connected agent reads over MCP, so you set who you are and how you work once. note.md goes further on the personal side: a local-first macOS markdown workspace where the cited vault doubles as memory an agent can read.

Memory becomes its own layer

Mem0 makes the case that memory deserves to be a layer of its own, with a compression engine that condenses chat history into compact memories to cut tokens and latency. The page claims 62,590 GitHub stars and more than 150,000 developers, and the pitch is drop-in: persistent memory without pipeline changes. I have rebuilt the same session context by hand in more than one agent prototype, so the shape is right. A layer with a compression engine is doing the work I was doing badly.

supermemory pushes the same idea further out. learner-1 extracts and dreams on the context of every user, task and tenant, stores it in a vector-graph database, and injects tokens back into the model’s context. The page says it serves 100k+ organizations and over a trillion tokens a month, and its argument is explicit: “Learning and memory live outside the model providers, so they carry across models and harnesses and stay interoperable, in context, and yours.” Keeping memory out of the model providers is the right call. Moving memory out of the provider and owning the data model are two different things. The first is what the page argues. The second is what I have never regretted.

A diff before the agent acts

Letta’s Context Repositories rebuild agent memory on git-based versioning, from February 2026. The consequence is the one that matters to me: what an agent learned becomes a diff I can review before it acts, the same way I review code. Neo4j gives the other half of the picture. Its three-tier context graph puts long-term knowledge, conversation history and decision traces in one place, and that is exactly what walks out the door when a team reorganises. Neo4j Context Engine adds that every answer and step is governed and explainable, which is what makes a graph reviewable and not only stored.

Rules no model was trained on

Cognee connects a GitHub org, Slack or Linear, plus warehouses, docs and APIs, into one recallable memory layer, and the page claims 33k GitHub stars and 5M+ SDK runs a month. The part that stands out is the ontology. Cognee generates the ontologies your agents follow, and rules no model was trained on are exactly where my teams kept inventing answers. Zep ends the path at the enterprise, with entities and facts kept apart: its live demo graph shows 1,820 entities, 9,330 facts and 2,471 episodes for one production agent. “Zep unifies business data, documents, and conversations into shared, governed context so agents can complete tasks correctly.” Entities and facts kept apart is the right model, and I have watched teams bury context inside a provider and lose the graph when they switched.

Continuum is the reminder that memory has a scope. It remembers what you know about the people you manage, built for 1:1s and performance context, and stays away from general note-taking. That is the same choice the bigger systems make at company scale, only narrower. The path ends where memory stops being personal: decision traces, ontologies, facts kept apart from entities. The thing that leaves with the switch is the graph itself, and no engine on this list brings it back.