A language model is stateless — it forgets everything the moment a conversation ends. For an agent meant to work over time, for the same people, that's disqualifying.
Agent memory is the layer that fixes it: a persistent store, separate from the model, that captures what happened, keeps it past the context window, and surfaces the relevant pieces back when they're needed.
It's built from four kinds of memory and one repeating loop — and once you see the shape, every memory system reads as a variation of it.
Why statelessness is the whole problem
A language model is trained once and then frozen. Each request is answered in isolation, with no record of what came before beyond what happens to sit in the current context window. Close the session and reopen it, and the model has no idea it ever spoke to you. For a one-shot question that's fine. For an agent — something meant to work on related tasks over time, for the same people, in the same domain — it's disqualifying.
- No continuity — every session starts from zero; the agent re-asks what it was already told.
- No learning — corrections don't stick; next session, the same mistake.
- No personalization — the agent can't adapt to anyone, because it retains nothing.
What memory actually is
Memory is a persistent store, separate from the model, that captures what happened, holds it beyond the life of a single context window, and surfaces the relevant pieces back into context when they're needed again. The model stays stateless; the system around it remembers.
The tempting shortcut — paste the entire history into every prompt — fails on three fronts at once: the context window has a limit you'll hit, cost grows with every turn as you resend everything, and models attend poorly to information buried in a huge context. Memory is a dedicated component precisely so the agent holds only the relevant few facts in context, not its entire past.
A model is stateless.
Memory is the state.
The four kinds of memory
"Memory" isn't one thing. Agents need several distinct kinds, and confusing them is the root of most memory design mistakes. The field borrows its vocabulary from human cognition, because the same constraints produce the same solutions.
- Working memory — what the agent holds right now: the current task and recent turns. This is the context window.
- Episodic memory — specific past events, tied to time: "the user reported this last Tuesday."
- Semantic memory — general facts distilled from experience: "this user prefers concise answers."
- Procedural memory — how to do things: skills and workflows, often held in instructions and tools.
The memory loop
Every memory system is the same loop running around the stateless model: an interaction happens, something is extracted from it, the result is stored, later it's retrieved, the agent uses it, and periodically the store is consolidated and pruned.
# writing (after an interaction)
memories = extract(conversation)
store.add(memories) # with subject, type, time, source
# reading (at the start of the next one)
relevant = store.retrieve(subject=user, query=now, top_k=5)
answer = agent(prompt(now, relevant))
Free Agent Memory Quick-Start — the four kinds of memory and the whole loop (store, retrieve, reflect, forget) on a few pages. Download it free.
Memory retrieval is RAG, plus time
Retrieving the right memory for the current moment is, mechanically, a retrieval problem — the same pipeline as RAG. Embed the current situation, find the closest memories, optionally rerank. What memory adds is time: recency and importance matter, so yesterday's correction should outrank a year-old passing remark. If you know retrieval, you already hold the reading half of memory.
Where memory sits in the stack
Memory is one layer of modern AI engineering. It's a key source for context engineering (what enters the window). Its reading half is RAG (retrieval pointed at the agent's own past). And it's what turns an agent from a stateless responder into one that learns. Master the loop and you hold the piece that makes agents feel like they know you.
Going deeper? AI Agent Memory: The Complete Guide is the full reference — 41 pages, 15 chapters, 5 appendices, with a worked support-agent example and a 30-day adoption path. Get the guide.
FAQ
What is AI agent memory?
A persistent store, separate from the language model, that captures what happened in past interactions and surfaces the relevant pieces back into context when needed. It's what lets an agent remember across sessions, since the model itself is stateless.
Why do AI agents forget?
Because language models are stateless — each request is answered in isolation, with no memory of previous ones beyond what's in the current context window. Close the session and the model retains nothing. Memory is the external layer that fixes this.
What are the types of agent memory?
Four: working (the current task, in the context window), episodic (specific past events), semantic (general facts distilled from experience), and procedural (how to do things). Confusing them is the root of most memory design mistakes.
Is agent memory the same as RAG?
Memory uses RAG. Retrieving the right memory is a retrieval problem — the same pipeline. But memory also covers writing, consolidation, and forgetting, which RAG doesn't. RAG is the reading half of memory.
Can't I just put everything in the prompt?
Not for long. The context window has a limit, cost grows as you resend everything each turn, and models attend poorly to huge contexts. Memory exists so the agent holds only the relevant few facts in context.
Top comments (0)