When people say an agent “remembers,” they’re usually pointing at one thing — a notes file, a vector database, the context window. The more useful frame, and the one we’ve been forced into by running an agent-first shop, is that there isn’t one memory. There are at least seven kinds, they do different jobs, and the hard part isn’t recall — it’s putting the right kind in the right place.
We ran our own stack against the taxonomy. Here’s the honest scorecard.
The seven
Working memory is the live context window — what the agent is holding right now. We have it, and we fight it constantly: compact, summarize, flush to disk. Cheap to have, expensive to manage.
Semantic memory is facts and preferences — who you are, what you like, the
standing rules. Ours lives in hand-curated markdown: a MEMORY.md, a USER.md,
a folder of small fact files. It works, but a human writes it. Nothing derives
it from what actually happened.
Episodic memory is specific past events — this conversation, that task run, the time the deploy broke. We keep daily logs and session transcripts, but they’re write-only narrative. You can read them; the agent can’t really query them. This is our weakest layer, and it turns out to be the one that matters most for anything that learns from its own history.
Procedural memory is how-to — skills, workflows, the muscle memory of “when X, do Y.” This is our strongest layer, almost by accident: it’s the whole skills system plus a directory of scripts. The architecture handed it to us.
Retrieval memory is the RAG layer — a vector store you search semantically. We have a thin version (semantic search over files) but no real vector database. Another gap.
Parametric memory is knowledge baked into model weights. We have none, on purpose. Everything we keep is text you can open, inspect, and swap. For a small operation that values being able to see what the agent knows, that’s a feature, not a hole.
Prospective memory is intentions — scheduled goals, “remember to do this later.” Cron jobs, a heartbeat loop, a task board. Strong, and underrated; most memory writeups skip it entirely.
What the scorecard actually says
We’re strong exactly where it was cheap — procedural and prospective both fell out of the platform for free. We’re thin exactly where it’s expensive: episodic and retrieval, the two layers that let a system learn from its own runs instead of just executing them.
That’s not a coincidence, and it’s the useful takeaway for anyone building one of these: the layers you get for free are not the layers that make an agent feel like it’s getting better over time. Those you have to build on purpose.
It also lines up with something we hit from a different direction: wiring a real memory substrate into one of our agents and watching the same lesson fall out. Memory isn’t one thing, and the design challenge is scoping, not recall. Two roads, same conclusion. And it’s a direct sequel to an earlier post where we found our memory index was 56% redundant junk — the cleanup was step one; knowing which kind of memory each piece was supposed to be is step two.
The question we’ve stopped asking is “does the agent remember?” The better one: does the system put the right kind of memory in the right place, at the right time, for the right agent?