Why your agents keep forgetting, and what actually fixes it

Every agent you use already has a memory feature. Claude Code reads a CLAUDE.md. Cursor has rules files. Copilot has repo instructions. Windsurf has Cascade Memories. On paper the problem is solved five times over.

In practice your team still re-explains the same architecture every week. That is not because the memory features are bad. It is because each one is a private notebook, and the work is not private.

Three failures, not one

"My agent forgets" is really three separate problems, and most tools only solve the first:

• • It resets between sessions. You close the window and the context goes with it.
• • It is siloed per tool. What Cursor learned on Tuesday is invisible to Claude Code on Wednesday, and to the engineer who joins on Thursday.
• • It is unsourced. A rules file states that the billing service owns retries. It does not say who decided that, when, or whether it is still true.

The first is annoying. The second wastes the team's time. The third is the one that quietly costs you, because an agent confidently acting on a decision that was reversed six months ago produces work that looks right and is not.

Why static rules files drift

A rules file is a snapshot someone maintained once. It does not learn, so it starts accurate and decays. Nobody notices the decay, because nothing in the system tracks whether a line is still true — and the moment an engineer stops trusting it, they stop reading it, and it decays faster.

The failure mode is not "the file is wrong". It is that you cannot tell which lines are wrong without asking a person, which is the work the file was supposed to save.

What shared, sourced memory changes

Shared means one memory every agent and teammate reads and writes, rather than one per tool. A decision made while pairing in Cursor is available in Claude Code, and to the engineer who was not in the room.

Sourced means every fact carries where it came from, who asserted it, and how confident it is. That is what makes correction possible: you fix it once, and everyone gets the fix. Without provenance you cannot correct anything, you can only overwrite it and hope.

The practical test is simple. When a fact turns out to be wrong, how many places do you have to fix it, and how do you know you got them all? If the answer is "every rules file in every repo, and you don't", the memory is not shared — it is copied.

What this does not solve

Shared memory does not make an agent better at reasoning, and it will not rescue a codebase nobody understands. It removes one specific tax: the cost of re-establishing context that somebody on your team already established.

That tax is worth measuring before you pay anyone to remove it. Count how often a session opens by re-explaining something already written down somewhere. If the answer is rarely, you do not have this problem.