The ten memory systems, and the one thing the list forgets

A list has been going around: the ten AI memory systems every AI engineer should know. Short-term and long-term. Semantic and episodic. Vector, graph, retrieval, procedural, shared, hybrid. It is a good list. It is also a good description of what RepoOps already is.

So here is the map, one memory type at a time, and then the one thing the list leaves out.

Short-term memory

The working memory of the current task: the live conversation, recent actions, the immediate context. In RepoOps, every coding session opens with a briefing already loaded, the recent events, the errors to avoid, the decisions in play, the roadmap, the open questions, all scoped to this repo and branch. The agent starts oriented, not cold, so the first prompt does real work.

Long-term memory

Knowledge that survives across many interactions. RepoOps keeps it as a plain-text brain in your git history: decisions, lessons, patterns, and session records that survive every reset, machine, and tool. Nothing is destroyed, and every tracked repo's brain unifies into one account-wide corpus you can move between and never lose.

Semantic memory

Factual knowledge and concepts, the what of a domain. A glossary, a concept wiki, and a set of state files hold the vocabulary and architecture of your project, so an agent can answer what a term means or how a subsystem fits without re-deriving it from the code each time.

Episodic memory

Experiences and past events, what happened and what came of it. RepoOps records what every run did, then ties a shipped defect back to the session and the prompt that produced it. The system learns from what actually happened instead of treating each task as new.

Vector memory

Information stored as embeddings for similarity search. RepoOps embeds brain content under your own key, so a question finds the passages that match its meaning, not only its keywords. Vector recall blends with keyword search behind one query and returns cited answers.

Graph memory

Entities and the relationships between them. RepoOps links prompts, sessions, commits, defects, people, and lessons in a node-and-edge store, so you can walk the chain from a prompt to the commit it wrote to the defect it introduced to the lesson that fixed it. A local Knowledge Graph view renders it; a redacted team snapshot rolls up to the hosted dashboard.

Retrieval memory

A store, retrieve, rank, respond loop for finding the right context on demand. Ask the brain a question and that loop runs end to end: store the corpus, retrieve candidates by keyword and by meaning, rank them, answer with citations back to the exact source. It spans every repo in your account by default.

Procedural memory

How things should be done: instructions, workflows, agent behaviors. RepoOps captures the workflows your team repeats, and turns every fix into a rule the agent must follow on the next run, checked at the merge gate. It remembers not only facts but how the work gets done here.

Shared memory systems

Memory that many agents read and write so they can coordinate. A team brain pools lessons and decisions across every developer and repo, so the group compounds what it learns instead of re-learning it. Opted-in slices synthesize into shared topic pages, each attributed to who learned it.

Hybrid memory systems

The combination of several types, because the strongest systems do not rely on one. RepoOps fuses keyword, vector, graph, and episodic recall behind a single question. This is the whole design, not a feature bolted on the side.

The one thing the list forgets

Read the ten back to back and you notice what none of them measures: what the memory cost to build.

Every one of these systems answers a version of "what do we know." None answers "what did learning it cost, and was it worth it." A team can have perfect recall of a decision that wasted a week, and the memory layer will happily serve it back with no price attached.

RepoOps joins the two. Every lesson carries the spend behind it, reconciled against real billing. The brain does not just tell you what happened; it tells you what that knowledge cost, so the next run starts ahead of the last one and you can see which memories earned their keep.

That is the wedge. The ten systems are how an agent remembers. Cost-fused memory is how a team decides what was worth remembering.

RepoOps is free, it is local, and it does not phone home. Point it at the agent you already run. See all ten on the Why RepoOps page.

repoops.ai