Ask most people what an AI agent needs in order to continue your work and they will say “memory”. Give it everything it has seen and it will know what to do. Testing behind Unforgetter says otherwise, repeatedly. The agents that failed were not short of memory. They had too much of the wrong kind and none of the right kind.
The task that made it obvious
The reference task is small. A booking product needs a late-cancellation fee, and the fee has to be charged against the right date. On 22 July a draft rule said “the rescheduled date”. On 6 August that was reversed: the fee measures against the original booking date, because customers were gaming the reschedule window. A separate thread about splitting capacity across two locations was open and deliberately left open.
Hand that task to a second agent with a full transcript of everything that happened and it does one of two things. It finds the 22 July draft first, because it is earlier and phrased more confidently, and implements the wrong rule. Or it finds both, cannot tell which one applies, and asks you. Either way you are back in the loop on something you already decided.
Hand it the same task with no memory at all and it asks you the same question the first agent asked three weeks ago.
What it actually needed
The bundle that made the second agent continue correctly had five things in it, and none of them was a transcript.
- The decision that applies now, with its reason and date. “Fee measures against the original booking date, 6 August, supersedes the 22 July draft.” The supersession is the important word. Without it the older rule is still a candidate.
- The thread that is still open. “Capacity split unresolved; do not implement around it.” Not so the agent can solve it, but so it does not quietly close it by implementing the fee in a way that assumes an answer.
- A working method. “Money is stored in minor units, never as a float.” A convention that applies to every coding agent in the project, carried in rather than restated.
- A scope. “Booking product only.” Finance and client material are out. This is not about secrecy; it is about not making the agent read forty things to find four.
- Provenance and freshness. Three sources, the freshest from 6 August. The agent can cite them and a reviewer can trace them.
What stayed out is as deliberate as what went in: the rejected 22 July proposal, four months of session transcripts, every other project in the workspace.
Memory is the input. Context is the output.
The useful distinction is this. Memory is everything you have retained. Context is what a specific agent receives for a specific task. Confusing the two produces the two failure modes above: either the agent gets the whole retained history and has to do your reconciliation for you, badly, or it gets nothing.
A memory system that returns everything relevant to a query is a search engine. It answers “what do we have about cancellation fees?” and hands back both rules. What the agent needs is an answer to “what applies now, for this task, within this scope, and how sure are we?” That is a compiled artefact, not a query result.
Why the compilation cannot be done at read time by the agent
The obvious objection: let the agent read everything and reconcile it itself. Modern models are good at that. Three reasons this does not hold up in practice.
First, supersession is a fact about the record, not something inferable from the text. Two confident rules with different dates could be a reversal or a refinement. The record has to say which.
Second, scope is a policy, not a relevance judgement. An agent working for one client must not read another client’s material even if it is relevant. That has to be enforced before the agent sees anything.
Third, corrections must be durable. If you told one agent “no, the original date” last week, and the reconciliation happens fresh in every session, the correction is only as good as the agent’s ability to find it again among everything else. Corrections that have to be rediscovered are not corrections.
What this means for a product
It means the core object is not a store. It is a maintained record of what applies now, with supersession, open threads, methods, scopes and provenance as first-class parts, and a compiler that turns it into a small bundle per task. Unforgetter calls that record the working truth. The demo on the homepage shows the fee task with and without it, and How it works shows what happens at each step.
If you build your own, build the record before the retrieval. Retrieval over an unmaintained record is how you get two confident answers to one question.