Memory is the part of the knowledge layer the system writes itself
Every other part of the knowledge layer is written by someone — a policy owner, a document author, a schema designer. Memory is the part the system writes on its own, which makes the question not how well it searches but what it was allowed to write down.
Why do memory systems fail?
They fail at the write, not the read. A retrieval miss is a gap; a bad write is a durable claim the system keeps making — the wrong fact, under the wrong attribution, with no expiry and no way to correct it. Retrieval quality is a measurable engineering problem. Write policy is a design decision most teams never make explicitly, so the system makes it by default.
Short term, medium term, durable
The first split is by horizon: each fails differently and answers to a different owner.
Working context
The current turn and the material assembled for it. Cheapest to get right, easiest to lose — a system that forgets what it just saw is not usable.
Session state
The last few days or weeks, the thread of what is going on. The question is currentness: which of these is still true, which has changed, which has ended. Stale facts look recent, which makes them costly.
Durable memory
Preferences, history, standing facts about a person or a project. The most valuable kind and the hardest to govern, because it is what the system keeps when nobody is watching the write.
Working context is also a delivery problem. What gets assembled into the window is context engineering; what that costs is token savings. Memory decides what is available — those two decide what is spent.
Episodic, semantic, procedural
The second split is by kind: the three need different rules about expiry and correction.
- Episodic — what happened, when, and with whom. Mostly append-only, and mostly what a person wants to be able to delete.
- Semantic — what is true: a preference, an address, a standing fact. This is the kind that goes stale, and the kind that should carry a source and a date.
- Procedural — how the system does things for this person: which format, which tone. It changes rarely and quietly, which makes a wrong procedural memory the hardest kind to notice.
Write policies
A write policy answers four questions. A system that does not answer them answers by default.
- What is worth remembering. The fact that will still matter tomorrow. A message is not a memory; the commitment inside it might be.
- What must expire. Anything with a shelf life — a status, a plan, a temporary preference. Expiry belongs on the record, as a property an agent can check, not in a cleanup nobody runs.
- Who can correct it. The person the memory is about, and anyone accountable for it. A correction must stick, not be re-learned from the same source on the next pass.
- Who can delete it. Consent, correction and deletion are duties, not features. A system that can remember but cannot forget is not a memory system; it is a record.
Recording is increasingly standardised. The Model Context Protocol defines a common way to expose tools, resources and prompts to a model — which is also how a system writes something down and reads it back. No protocol decides whether the write should have happened.
Memory without control is a liability
Memory is useful in proportion to how much of it there is, and dangerous in the same proportion.
- Stale facts. A preference the person changed, a status that ended, a plan that was cancelled. The system has no reason to doubt it, because it wrote it down itself.
- Wrong attribution. Something said by one person, in one context, retained as a fact about another — or a fact about the user that the user never stated.
- Records the user never agreed to. Nothing was wrong at the moment of writing. The problem is that a record exists at all.
The controls are ordinary: what the system knows, how long it keeps it, who else can see it, when it forgets, how it is corrected. That is the argument the personal assistant page makes at human scale, where the cost is private rather than operational. Attribution is provenance too — where a memory came from, and when, is what makes it correctable, the discipline PROV-O formalises for data generally. These failures compound once the system acts; see agentic AI.
FAQ
No. Retrieval searches knowledge someone else owns; memory creates a record that did not exist before. A retrieval miss is a gap, but a bad write is a durable claim the system keeps making.
It should be a deliberate decision: what is worth remembering, what carries an expiry, what records its source, who may correct or delete it. Where a person is the subject of a memory, they need a way to see it, correct it, and have it forgotten.
It changes the economics, not the design question. MemGPT's virtual context management moves information between a limited in-context working set and external storage. A window still cannot decide what deserves keeping, what has expired, or who may correct it.
It is the same argument at human scale: the memory concerns one person, the cost is private, and the controls that matter are the ones the person can exercise directly.
Sources
- Packer et al., MemGPT: Towards LLMs as Operating Systems — arxiv.org/abs/2310.08560. Virtual context management, a memory hierarchy of main and external context, and self-directed editing of memory through function calls.
- Model Context Protocol — modelcontextprotocol.io. An open protocol for exposing tools, resources and prompts to models, and for letting a model read and write external state.