AI agent memory, part 2: what happens when facts change
When a fact changes, an agent's memory has three jobs: answer with the new fact, notice that something changed, and tell me when my own question still assumes the old fact. On two months of my own work history, overwriting old facts failed the second job badly. It said "I don't know" 34 times, and in all 34 the new fact was sitting in the notes it was shown. Keeping old facts with a "no longer valid" label did best, but no design handled the third job (0% to 9%) until I added one sentence to the answer prompt, which took it from 3% to 91%.
This follows my first five memory experiments on Saati, my personal agent. Same data, same small free model (Gemini 3.5 Flash-Lite), same rules: I wrote down the setup and my predictions before each run, cached every model call, and graded answers blind.
Key takeaways#
- Memory isn't one skill. Regrouping my first five runs by the abilities in the LongMemEval benchmark, every ability had a different winner.
- Overwriting a changed fact made the agent unable to notice the change: 34 "I don't know" answers with the new fact in front of it. Labelled old facts scored 59% against 33% (95% CI of the gap +14 to +37).
- Every design failed when my question assumed an outdated fact (0% to 9%). The cause was the answer prompt, not the memory. One sentence raised it to 91%.
- That sentence over-fired at first, calling 4 of 20 ordinary questions outdated. A tighter wording kept the gain with no false flags, and it held on 36 new questions (21% to 88%).
- In the live agent, strict project matching plus a confirmation step cut invented projects from 3 to 0 over 78 tries, at a small cost to creating real ones.
The question#
Part 1 ended with a clear rule: never overwrite a fact, keep the old one and mark when it stopped being true. Labelled facts scored 95% against 76% for overwriting. But all of Part 1's questions asked about the past or the present directly. Real conversations are messier than that. I often ask things like "since the repo is still private, what should the README say?", when the repo went public a week ago. A good assistant should catch that.
So this round asks a narrower question. When a fact changes, does the memory let the agent notice the change, and does it push back when my question is out of date?
Two 2026 papers shaped the tests. STALE (Chao et al.) checks whether a memory system catches outdated information in three ways, which I copied. And LongMemEval (Wu et al., ICLR 2025) splits memory into separate abilities, which gave me a better way to read my old results. The last run comes from a different problem, an annoying bug in Saati itself, and borrows its scoring from τ-bench (Yao et al., 2024).
Setup#
- Data and memory: the frozen memory stores from Part 1's first run, built from 23 of my coding sessions (about 2.1 million characters, July to November 2026). Three stores: append (keep every fact), overwrite (replace a fact when it changes, as in the 2025 Mem0 paper), and labelled (keep old facts, marked "no longer valid since
"). - Answering: keyword search (BM25) picks the 10 best notes, then
gemini-3.5-flash-liteanswers from them, with Part 1's prompt unless a run changes it. - Grading: blind and shuffled; correct, partly correct (half a point), or wrong. In each run I mixed already-graded answers into the sheet as a consistency check, and they were re-graded the same way every time. A second, independent AI grader re-graded 30 answers from these runs and agreed on 26 (Cohen's kappa 0.78). All 4 disagreements were "partly" against "wrong"; I went through them and kept the original grades. Using the second grader's grades instead would move any score by 3 points at most.
- Statistics: paired bootstrap 95% confidence intervals (CI). If a CI includes zero, the difference could be chance.
Memory is several skills, not one#
Before running anything new, I took every grade from Part 1 and regrouped it by the abilities LongMemEval defines. This cost no model calls; it's the same grades, read a different way. The mapping was fixed before I scored anything: current-state questions count as knowledge updates, history and date questions as temporal reasoning, cross-project questions as reasoning across sessions, and stable and technical questions as extracting details.
| Design | Details (IE) | Across sessions (MR) | Time (TR) | Updates (KU) |
|---|---|---|---|---|
| Labelled facts (Run 1) | 100% | 50% | 100% | 98% |
| Raw search, Gemini embeddings (Run 4) | 88% | 30% | 36% | 72% |
| Hybrid, keyword + embeddings fused (Run 5) | 71% | 70% | 93% | 93% |
| Raw search, keyword (Run 2) | 67% | 60% | 30% | 74% |
The labelled-facts details score covers only 7 stable questions, since Run 1 had no technical ones, so it isn't directly comparable to the others.
What it means. Labelled facts win on time and updates, raw search with good embeddings wins on details, and everyone is weak at connecting facts across sessions. This lines up with a 2026 comparison of 12 memory systems (Zhou et al.), which also found that no architecture won everywhere. It also showed me a gap: none of Part 1's questions tested whether the agent knows when not to answer, or when to push back. That's what the next runs do.
Run 6: does the agent notice a change?#
I took 17 real changes from my data, all cases where a fact was truly replaced (not just refined), and asked about each one in the three ways STALE does:
That's 51 questions on each of the three stores, 153 answers in total. Before running anything, I checked that the labelled store's search actually surfaced the old, invalidated fact for all 17 premise questions, so the test really did put outdated memory in front of the model.
One honest caveat about this run: the changes in my data are explicit (I said "we moved to X"), while STALE's hard case is an implicit conflict the agent has to infer. So this is an easier version of their test, not a copy of it. Also, an AI assistant drafted the questions and screened them against the stores. While screening, it reworded 7 questions whose new fact the labelled store's search missed, and dropped none.
| Question type (17 each) | Append | Overwrite | Labelled |
|---|---|---|---|
| "Is the old state still true?" | 68% | 41% | 91% |
| A question built on the old state | 9% | 0% | 3% |
| A task that needs the new state | 53% | 59% | 82% |
| Overall (51) | 43% | 33% | 59% |
Labelled beat overwrite by 25 points (CI +14 to +37) and append by 16 (CI +5 to +27). On "is the old state still true?", the gap to overwrite was 50 points (CI +26 to +74).
Findings. The interesting part is how each design failed. Append was the only one that confidently gave me outdated facts, 8 times, because it had both versions and no way to tell which was newer. Overwrite never gave an outdated answer, which sounds good until you see why. It said "I don't know" 34 times, and I checked every one: the new fact was among the notes in all 34. With the old fact gone and no label, the model couldn't tell that "tests run on all 6 universes" answers "are the tests still only planned?". Nothing in front of it said a change had happened.
And no design handled questions built on an old fact. They didn't agree with me, either. Across the three stores, 46 of 51 of those answers were "I don't know". The model refused instead of correcting me.
What it means. Part 1 said overwriting loses history. This run says something stronger: it loses the ability to notice change at all. Labels fix that. But the refusals pointed at the prompt rather than the memory. Part 1's answer prompt says "if the notes do not contain the answer, say I don't know", and a question with a false premise has no answer in that literal sense. So I tested the prompt next.
Run 6b: one sentence#
Same labelled store, same 51 questions. The only change was one sentence added to the answer prompt: check whether the question assumes something the notes show is no longer valid, and if it does, say so, give the current state, and then answer if possible.
I predicted the premise questions would rise by at least 20 points and the other two types would drop by no more than 10.
| Question type (17 each) | Labelled, Part 1 prompt | Plus one sentence | Change (95% CI) |
|---|---|---|---|
| "Is the old state still true?" | 91% | 88% | −3 (−18 to +9) |
| A question built on the old state | 3% | 91% | +88 (+74 to +100) |
| A task that needs the new state | 82% | 76% | −6 (−18 to 0) |
| Overall (51) | 59% | 85% | +26 (+13 to +40) |
"I don't know" answers fell from 20 to 5, and there were still zero outdated answers.
What it means. The 3% in Run 6 was a prompt problem, not a memory limit. Once the notes say which facts are outdated, the model can correct me; it just needs permission to do so. The task column's CI reaches −18, so a small cost there can't be ruled out. I added the sentence to Saati that day.
Run 7: does it start making things up?#
A sentence that tells the model to push back could also make it bolder in general. LongMemEval treats knowing when to abstain as its own ability, so I tested that. I wrote 20 questions about my real projects that the notes can't answer (I checked with a text search over all 259 notes, and checked by hand the three that came closest), plus 20 ordinary answerable questions sampled from Run 1.
| Questions (n) | Part 1 prompt | Plus the sentence |
|---|---|---|
| Not answerable, said "I don't know" (20) | 100% | 100% |
| Answerable, correct (20) | 98% | 93% |
No invented answers, which was the main worry. But reading the answers turned up a side effect. On 4 of the 20 ordinary questions, the agent told me my question assumed something outdated when it didn't. The answers themselves were still right, but being corrected for no reason gets old fast.
Both prompts scored 100% on the unanswerable questions, so this set was too easy to separate them. I fixed that in Run 7c.
Run 7b: a tighter sentence#
I rewrote the rule so it fires only when the question itself relies on a fact that has changed, and so it treats history questions ("what was it called before?") as normal questions. Then I reran Run 7's 40 questions plus Run 6's 17 premise questions.
| Questions (n) | Part 1 prompt | First sentence | Tightened |
|---|---|---|---|
| Outdated questions corrected (17) | 3% | 91% | 91% |
| Not answerable, said "I don't know" (20) | 100% | 100% | 100% |
| Answerable, correct (20) | 98% | 93% | 100% |
| False "your question assumes" flags (of 20) | 0 | 4 | 0 |
Same gain, no false flags. But I wrote this wording after seeing which 4 questions it had flagged, and then tested it on those same questions. That's exactly how you fool yourself, so it needed fresh questions.
Run 7c: new questions#
36 questions written and checked against the store before any model saw them: 12 built on an outdated fact, 6 history questions, 6 ordinary ones, and 12 harder unanswerable ones about topics that do have related notes, so the search returns near misses.
| Questions (n) | Part 1 prompt | Tightened rule | Change (95% CI) |
|---|---|---|---|
| Built on an outdated fact (12) | 21% | 88% | +67 (+42 to +88) |
| History, "what was it before" (6) | 67% | 67% | 0 |
| Ordinary (6) | 100% | 100% | 0 |
| Not answerable, harder (12) | 92% | 92% | 0 |
| Overall (36) | 65% | 88% | +22 (+7 to +38) |
Zero false flags on the history and ordinary questions.
Findings. It held. One error showed up in both versions, and it's a different kind of error. I asked which Python version my time-series dashboard uses, and the agent answered with my portfolio project's Python 3.12, taken from a similar-looking note. Neither prompt prevents that, because it isn't about time at all: the model mixed up two projects.
One limit worth knowing: 10 of the 12 outdated-fact questions reuse Run 6's changes with new wording, because my data doesn't have many other real changes. The wording is new; the underlying facts aren't.
The tightened rule is what runs in Saati now.
Run 8: does the agent invent projects?#
This one came from using Saati rather than from a paper. It kept creating projects that didn't exist. A folder name in a message would become a project. A passing mention of a tool would become a project. Once, it created one right after I said "don't add it". The cause was loose name matching plus creating projects automatically whenever it wasn't sure.
The fix on 15 November had three parts: strict name matching, aliases (so a folder name maps to the project it belongs to), and a two-step confirmation, where Saati asks and only creates the project after I say yes in a later message.
To measure it I borrowed τ-bench's pass^k: a conversation only counts if the agent handles it correctly on all k repeated tries. That's a fair test for an agent you rely on every day, because a fix that works two times out of three still leaves you cleaning up the database.
Setup. 26 scripted conversations of 7 types, 3 tries each, run against both the old code and the new code. Both started from the same database backup, loaded fresh into memory for every try. The model calls were real; Telegram was stubbed out; and the score came from rules applied to what changed in the database. An AI assistant wrote the scenarios.
| Conversation type (n) | Before | After |
|---|---|---|
| Known project by name (4) | 100% | 100% |
| Alias or folder name (4) | 50% | 100% |
| Vague reference (4) | 100% | 100% |
| Hypothetical idea (4) | 25% | 50% |
| Passing mention of a tool (4) | 25% | 50% |
| New project, then "yes" (4) | 100% | 75% |
| New project, then "no" (2) | 50% | 100% |
| All (26) | 65% | 81% |
Findings. Invented projects fell from 3 to 0 across 78 tries, and items attached to the wrong project fell from 11 to 7. Aliases now work every time. The cost is in the "yes" row: one genuinely new project got saved as an idea instead in 2 of its 3 tries. And ideas or passing mentions still get attached to a loosely related existing project half the time. I'd predicted the vague, hypothetical, and passing-mention types together would improve by 30 points; they improved by 17, so that prediction failed.
A mishap worth admitting: midway through, network errors hit 74 of the 156 conversations, and Saati replied "I hit a snag" instead of doing anything, which looked like the agent behaving perfectly cautiously. I added retries, flagged those replies as infrastructure errors, and reran those 74. The first pass is kept on file, but its numbers aren't used.
What I changed in Saati#
- Old facts stay, marked as replaced with a date. Nothing gets overwritten.
- The answer prompt corrects outdated assumptions, but only when the question itself relies on one.
- New projects need an explicit yes in a later message, and names match strictly or through aliases.
Limits#
This is a case study: one person's data, one small model, and 6 to 17 questions per group, so differences under about 15 to 20 points could be chance. Only the results whose confidence intervals exclude zero are firm. An AI assistant drafted and screened the Run 6 questions and wrote the Run 8 scenarios, and an AI grader graded everything. A second AI grader checked 30 answers, and I reviewed the disagreements. The changes in my data are explicit, which makes this easier than STALE's own test. Most of Run 7c's outdated-fact questions reuse Run 6's changes. Run 8's conversations are scripted, not real use, and each was tried only 3 times.
Next, I want to tackle the cross-project mix-up from Run 7c, and test memory poisoning: what happens when something false gets written into memory in the first place.
Sources#
- Wu et al., LongMemEval, ICLR 2025.
- Chao et al., STALE, 2026.
- Zhou et al., agent-native memory comparison, 2026.
- Yao et al., τ-bench, 2024.
- Chhikara et al., Mem0, 2025.