Why do AI agents forget?
Every AI session starts brilliant and ignorant. The model can reason, but it knows nothing about your last run: the decision you made Tuesday, the approach that failed, the file where the handler actually lives. So it re-explores, re-asks, and occasionally re-makes a mistake you already paid for. Teams feel this as a tax: the tenth run of a process costs nearly what the first did.
Context windows do not fix this; they are working memory, gone at session end (see agent memory for the definition). Bigger windows just raise the ceiling on how much you can re-paste. The fix is memory that persists outside the session and is recalled into it deliberately.
What is agent memory, and what is it not?
Agent memory is operational knowledge produced by doing the work: decisions and their reasons, corrections, learned constraints, and the layout of the territory. It is not document retrieval. RAG recalls what your organization wrote; agent memory recalls what your agents learned, which is usually not written anywhere else.
Ranking matters more than storage. A useful recall weighs semantic relevance, the situation at hand, recency and what agents actually used before, so the agent gets the eight things that matter rather than eighty that match.
What are the four types of agent memory?
Writers on agent memory usually borrow four types from the study of human memory. Working memory is what the agent holds right now. Episodic memory is what happened in past runs. Semantic memory is what is known to be true. Procedural memory is how the work is done. The split is useful because each type wants a different store and a different way of being recalled.
The mistake to avoid is treating them as one pile. A run transcript is episodic, a style rule is semantic, and a release checklist is procedural. Stored together and searched the same way, the checklist loses to whichever transcript happens to share the most words with the question.
| Type | What it holds | Example | Where it lives in ConvOps |
|---|---|---|---|
| Working | What the agent is handling in this session | The ticket text and the current draft | The context window, plus the current step the engine delivers |
| Episodic | What happened, and why it went that way | The branch a past run took, with the reason | Decision and context memories linked to the task, and the step history |
| Semantic | Facts, rules and preferences that stay true | Invoices from this supplier are always in euros | Knowledge, preferences and decisions, ranked by meaning and use; routes for where things live |
| Procedural | How the work is done | The steps of the month-end close | The workflow itself, plus procedure memories for the details around it |
Is memory the same as a bigger context window?
Larger context windows are useful, and they change how much an agent can read at once. They do not change what survives the session. A window of any size starts empty, holds whatever was pasted in, and is gone when the session ends. Memory is the part that is still there the next day, for the next agent.
Cost and focus matter too. Everything in the window is paid for on every turn, and a model given more text does not always use the right part of it. Recall that returns a short ranked list keeps the window for the work itself.
| Question | A bigger context window | Agent memory |
|---|---|---|
| Does it survive the session? | No, it ends with the chat | Yes, it is stored outside the session |
| Who can use it? | The one session holding it | Every agent and person with access to the workspace |
| What does it cost? | Every token, on every turn | A short recall before acting |
| How is the right part found? | The model has to notice it | Recall ranks by meaning, situation, recency and use |
| What happens when it is wrong? | The next session repeats it | The entry is corrected once, for everyone |
Why split WHAT from WHERE?
The two questions an arriving agent asks are different in kind: "what do we know?" and "where do things live?" Mixing them degrades both. Knowledge (the WHAT) wants recall ranked by meaning and use. Location (the WHERE) wants a semantic map: this feature lives in these files, that doc governs this process, so the agent navigates instead of re-exploring.
In practice the split pays off in one call: a single context query answering both, plus the related work items (how ConvOps memory works), means the agent starts every step already oriented. That is the mechanical content of "recall before acting."
How should agents capture memory?
Recall is only as good as what was captured, and capture fails in two directions. Automatic-everything produces a landfill: transcripts stored wholesale, signal buried. Voluntary capture produces silence: nobody writes the memory at 6pm on a Friday.
The durable pattern wires capture into the process: the step where a decision happens carries the recording of that decision, as part of advancing. Make it mandatory exactly where the why matters (a gate that will not close without context) and optional elsewhere. Then maintain the store like the asset it is: deduplicate noisy categories, make forgetting reversible, and let unused memories decay in ranking. For a team, the same store has to be shared: see shared memory for AI agent teams.
How do you build memory for AI agents?
The steps below work for any memory system. Each one ends with how it is done in ConvOps, where the store is shared by every client and executor that connects to your workspace.
- 1
Decide what is worth keeping
Keep decisions with their reasons, corrections, learned constraints, preferences and procedures. Skip what the code or the documents already say. In ConvOps, each memory carries one of four categories (preference, decision, knowledge, procedure) and up to five situations it applies in. A rule that must always hold is pinned. A correction replaces the memory it corrects instead of being a category of its own.
- 2
Keep WHAT apart from WHERE
Store knowledge as memories and locations as a map, so each is recalled the way it is used. In ConvOps, routes map files, modules and docs, and memories hold what is known.
- 3
Recall before acting
Make the first move of every step a lookup, not a search through the files. In ConvOps, one context query returns the relevant routes, memories and related tasks together.
- 4
Capture at the step
Record the decision where it is made, as part of moving on. In ConvOps, a memory can be stored with the step that produced it, and a require_context gate can hold a step until the reason is written down.
- 5
Maintain the store
Correct entries instead of adding contradicting ones, and let forgetting be undone. In ConvOps, related memories in one category can be consolidated into one entry, with a preview before anything merges, and forgetting is soft, so it can be undone.
How does memory work for a whole team?
Memory pays off most when it is shared. A correction one person makes on Monday should reach the agent another person runs on Tuesday, in a different tool. That only works when memory lives with the team's work rather than in one person's client or one model vendor's account.
Sharing also raises the question of boundaries. A team wants one search across everything it may see, while each write lands in exactly one place, so a client's knowledge stays with that client. In ConvOps, recall spans every workspace you belong to, each memory belongs to exactly one workspace, and the same store answers Claude Code, Codex, Cursor or any other MCP client. The shared memory guide covers the details.
- Support: a reply agent learns that one product's refunds need a manager, and every later run on every shift starts knowing it.
- Enterprise with several business units: each unit keeps its own workspace and memory, and a central platform team can search across all of them.
- Agency: one workspace per client keeps each client's preferences separate, while the agency's own procedures are shared across its staff.
How does memory make run 40 better than run 1?
Put recall and capture on the same loop and the economics invert. Run 1 explores, decides, records. Run 15 arrives knowing the style rulings, the rejected approaches, the file map, and spends its budget on the actual work. Run 40 is faster, cheaper, and less supervised, not because the model improved, but because the system around it accumulated.
This is the quiet argument for structured autonomy in general: the process carries the quality, and the memory carries the learning. The model becomes a replaceable part in a system that gets better with use.
Frequently asked questions
What is agent memory?
Agent memory is knowledge that carries across AI sessions: decisions and their reasons, corrections, learned constraints and where things live, stored outside the session and recalled into the next one. In ConvOps, it is shared memory, a store used by every client and executor in your workspace, which agents read before acting and write to as they work.
What are the four types of agent memory?
Working memory is what the agent holds now, episodic memory is what happened in past runs, semantic memory is what is known to be true, and procedural memory is how the work is done. In ConvOps, working memory is the session plus the current step, the workflow is the procedure, and stored memories and routes cover the rest.
Is agent memory the same as RAG?
No. Retrieval over documents recalls what your organisation wrote down, while ConvOps shared memory holds what your agents learned by doing the work. That knowledge is usually written nowhere else: the approach that failed, the decision and its reason, the file that really holds the logic. The two can sit side by side, each answering a different question.
How does ConvOps decide which memories to recall?
ConvOps ranks memories by meaning, situation, recency and use, so knowledge that agents actually use keeps its place and a pinned rule is never dropped. One context query returns the top memories together with the routes and related tasks, which keeps the list short enough for the agent to read before it acts.
Can a memory be corrected or removed?
Yes. In ConvOps, a stale or wrong memory can be forgotten, and forgetting is soft, so it can be undone if it was a mistake. Related memories in one category can be consolidated into a single entry, with a preview before anything merges, so the next run finds one current answer instead of several that disagree.
Who gets the most out of agent memory?
Any team whose AI agents keep relearning the same things across sessions: engineers using Claude Code or Codex daily, and operations teams running agents on schedules. ConvOps gives them memories with a category and the situations they apply in, recall that ranks by meaning, situation, recency and use, and routes that map where things live, so each session starts from what earlier ones learned.