the memory guide

Why AI agents forget, and the memory that makes run 40 beat run 1

AI agents forget because what they learn lives in a context window that ends with the session. Agent memory fixes that: decisions, corrections and file locations stored outside the session and recalled into the next one. This guide covers what memory is and is not, the WHAT/WHERE split, and the capture habit that makes run 40 beat run 1. In ConvOps, memory is shared memory: one store your agents read before they act and write to as they work.

the route

9 sections · 11 min

  1. The amnesia tax
  2. What memory is
  3. Four types
  4. Versus a bigger window
  5. WHAT and WHERE
  6. Capture is a discipline
  7. How to build it
  8. Team memory
  9. Compounding
01The amnesia tax

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.

without memory
run 1run 15run 40effort per run
fig 1 Illustration. Without memory, every run pays the same.
02What memory is

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.

Learned by doingdecisions, fixes, reasons
Ranked recallmeaning, situation, use
fig 2 Ranked, so the agent gets the few things that matter.
03Four types

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.

The four types of agent memory, and where each lives in ConvOps.
TypeWhat it holdsExampleWhere it lives in ConvOps
WorkingWhat the agent is handling in this sessionThe ticket text and the current draftThe context window, plus the current step the engine delivers
EpisodicWhat happened, and why it went that wayThe branch a past run took, with the reasonDecision and context memories linked to the task, and the step history
SemanticFacts, rules and preferences that stay trueInvoices from this supplier are always in eurosKnowledge, preferences and decisions, ranked by meaning and use; routes for where things live
ProceduralHow the work is doneThe steps of the month-end closeThe workflow itself, plus procedure memories for the details around it
04Versus a bigger window

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.

A bigger context window and agent memory, compared.
QuestionA bigger context windowAgent memory
Does it survive the session?No, it ends with the chatYes, it is stored outside the session
Who can use it?The one session holding itEvery agent and person with access to the workspace
What does it cost?Every token, on every turnA short recall before acting
How is the right part found?The model has to notice itRecall ranks by meaning, situation, recency and use
What happens when it is wrong?The next session repeats itThe entry is corrected once, for everyone
05WHAT and WHERE

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."

Whatwe know, and why
Wherethings live
Linkedto the task that made it
fig 3 Two different questions, answered in one call.
06Capture is a discipline

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.

recalllook first
work
decideapproval
capturememory + reason
next runstarts ahead
fig 4 The decision is recorded at the step where it happens.
07How to build it

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. 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. 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. 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. 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. 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.

08Team memory

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.

  1. Support: a reply agent learns that one product's refunds need a manager, and every later run on every shift starts knowing it.
  2. Enterprise with several business units: each unit keeps its own workspace and memory, and a central platform team can search across all of them.
  3. Agency: one workspace per client keeps each client's preferences separate, while the agency's own procedures are shared across its staff.
09Compounding

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.

without memorywith recall and capture
run 1run 15run 40effort per run
fig 5 Illustration. Recall and capture on one loop: each run starts further ahead.

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.