Remem and normal memory

Last verified against the code: 2026-11-13 (0.9.0)

How Remem differs from the memory most AI tools have, measured where it can be and argued where it cannot. Run the measurement on your own history with remem compare (USER-GUIDE.md).

The short version

Normal AI memory remembers what you said and, on every message, puts back what looks similar. Remem remembers what went wrong (your corrections, the agent's failed calls, its own surprises), turns repeats into lessons overnight, keeps only lessons that predict, and speaks only at the moment one applies: when your message meets a lesson, or when the agent is about to make the mistake the lesson is about.

Measured: a replay of the owner's real history

remem compare walks every conversation on the machine in time order. The test cases are the owner's repeated corrections: each time they had to correct the agent with something an earlier correction had already said. For each: was the earlier correction itself in front of the agent in time (put back for the message it answered, or as the end-of-turn reminder)? And across all turns: how much did each system put in front of the agent, how often was the person about to correct it when it spoke, and how often was it wrong?

"Normal memory" is given every earlier message verbatim (more than a fact extractor would keep) and puts back the k most similar on every turn; both systems get memory instantly. Owner's machine, 2026-10-24, 61 turns, 4 cases:

On catches per item, Remem is about 33 times normal memory's best setting; against the usual setting (3 memories a turn) normal memory caught none. Every one of the 20 end-of-turn reminders was followed by the person correcting the agent ("do it always dont ask", "you fix it", "You do it", "Can you do it"), pushing it further ("really think deep about this", "Next!") or approving anyway ("yes"); none by a decline.

The cases:

How to read it.

• Similarity looks at the wrong thing. The message before a repeated correction rarely resembles the correction ("Do it all", "show a demo…"); the agent's behaviour does: it offered, it waited, it put work off. Remem triggers on behaviour; normal memory can only match words.
• "In front of the agent" is not "prevented". The paper's first finding (§7.1) is that a lesson already in context did not change what the agent did. Only the randomized experiment (half the sessions held out) will say what either actually prevents.
• Tuned on this replay; four cases. Remem's first run caught 0 of 4 and every rule that got it to 3 was changed after seeing the replay: a lesson bears on offers when any of its corrections followed a hand-back (it was most), the reminder fires at every offer (it was once a session), a reply that leaves named work counts like an offer, one lesson per reminder. Normal memory was not tuned. The coming weeks are the test.
• Corrected today. 0.6.2's first version of this page credited normal memory with 2 of 4 at top 3: its scoring counted the message before an earlier correction, which normal memory never hands over. Fixed in 0.6.3.

Measured under control: does the memory change what a model does?

The replay above counts what was in front of the agent. remem experiment measures what the model then did (paper §7.3): 20 situations where agents tend to hand work back, three open model families, 360 replies per arm.

Memory up front, the way normal memory works, made models more likely to hand work back, even when the block held only an unrelated lesson. Delivered at the moment of the act, the same memory cut it to about a fifth. Synthetic scenarios and single replies; the raw replies are in results/.

How it differs, piece by piece

Against particular systems (as generally described, late 2026)

• ChatGPT's and Claude's built-in memory keep facts and preferences, and can search past chats, inside one product. They are polished, hosted and need nothing set up. They do not learn from what went wrong, do not verify what they keep, and do not follow you into other agents or models.
• mem0 and similar memory layers extract facts from conversations with an LLM and retrieve them by similarity: the "normal memory" of the replay, done better (an extractor drops noise the replay kept). Mature APIs, multi-user, hosted options. No notion of surprise, prediction or the moment a memory applies.
• Letta (MemGPT) lets the agent manage its own memory (core blocks in context, an archive it pages through). Powerful for long-running agents; the agent decides what to keep. Remem decides from evidence what was surprising, and the person can veto.
• Zep and knowledge-graph memories track facts and how they change over time. Strong for "what is true now". Remem is about "what keeps going wrong", and is not a fact store.
• Claude Code's own memory files (CLAUDE.md, the memory folder) are read at the start of a session. Remem writes into them, and adds what they lack: reminders at the moment, consolidation, verification, other agents.

Where normal memory is better

• Facts. "My staging URL is…", "we use pnpm". Remem keeps them only as notes (remember) or session summaries, with plain recall. A fact store is better at facts.
• Scale and polish. Normal memory systems serve many users with hosted APIs and years of use. Remem is one person's machines, weeks old, with English rules for corrections and offers.
• Recall on demand. In the replay, retrieving 20 memories a turn found every repeated correction, at 44 times Remem's volume. When context is cheap and the question is "have we discussed this?", retrieval wins.

And human memory

Remem borrows from how people learn, not how they store: prediction error is what gets remembered (the surprise), sleep consolidates and prunes, memories that are used stay and the rest fade, and a reminder works best as a cue bound to a moment (a habit) rather than a fact recalled at will. The owner's own finding (paper §7.1): a lesson the agent had read did not change what it did; the same lesson put in front of it at the moment of the act is the bet.