Why Your AI Keeps Forgetting Things

When most people picture AI memory, they imagine something like a contacts app. The assistant writes down the fact, looks it up later, and reads it back. Simple, deterministic, like a phone number.

The reality is messier. AI memory is layered. There is the conversation right now (whatever is being typed back and forth), there is what the model was trained on months or years ago, and there is whatever store the application has bolted on to track things between sessions - which might be a database, a vector store, a plain text file, or all three.

The bolted-on layer is where the trouble lives. It is the part that has to decide what to keep, what to throw out, how to recall things, and what to do when two recalled things flatly disagree. None of that is what a database is designed for.

Imagine you keep absolutely everything anyone ever tells you in one drawer. Receipts, birthday cards, takeaway menus, the warranty for a fridge from 2008. Whenever you need to recall something, you tip the drawer onto the table and rummage.

This is a fair picture of "store everything, retrieve later" memory. The problem is not the storing - that bit is easy. The problem is what you find when you rummage. The fridge warranty is irrelevant. Half the takeaway menus belong to restaurants that closed years ago. The birthday card from your aunt is sweet but is not helpful for working out what to make for dinner.

AI systems that retrieve from this kind of drawer do exactly what you would do - they grab the most superficially relevant scraps and combine them. Sometimes the result is right. Often it isn't. Five failure modes recur often enough to deserve names.

Human memory is not flat. The phone number you used yesterday is sharper than the phone number you used in 2014. This is decay - facts losing weight over time unless something refreshes them. It feels like a bug, but it is the feature that stops your head filling up with rubbish.

Good AI memory mimics this. A fact gets a freshness score that quietly drops over the weeks. When the system goes to recall something, fresh facts are louder than stale ones. If two facts disagree and the older one has decayed substantially, the newer one wins by default.

The everyday version is the loft clear-out. You haul a box down, look at it, decide most of it can go. You did not delete the memories themselves - if you needed a specific one back, you could remember the box existed. You demoted them, which is what decay does mechanically. The fact still exists; it just no longer shouts when you go looking.

Contradiction is the failure mode that produces the strangest AI behaviour. You told the assistant in January that you have one cat. You told it in May that you have two. A naive retrieval grabs both and either picks one essentially at random or, even worse, returns both and lets the model pick which to believe.

The right behaviour is for the newer fact to supersede the older one, with a record that the older one existed in case it turns out to be the correct one after all. This is exactly how editing works in a notebook - you cross things out rather than rip the page, so you can change your mind back later.

Building this properly is harder than it sounds. "I have two cats now" is easy to spot as superseding "I have one cat". "I might get a second cat eventually" is not. Real systems use timestamps, similarity scores, and small models to judge whether two facts genuinely contradict or just sit alongside each other.

Not every fact is equally well-supported. "My partner is allergic to peanuts" is a hard fact that you have stated several times. "I think the new restaurant on the corner is Korean, maybe" is a guess you mentioned once.

A well-built memory system attaches a confidence score to each fact. Strong facts get retrieved with weight; weak facts are flagged as uncertain. When the assistant uses them, it can hedge appropriately - or, better, ask. The worst behaviour is for a low-confidence fact to be retrieved and then used with the same swagger as a high-confidence one.

This is the difference between a knowledgeable friend and a know-it-all. The knowledgeable friend says I think when they think; the know-it-all does not. The thing that makes AI useful in everyday life is the same thing that makes a friend useful - knowing when to be sure and when to ask.

If you store every single thing the user has ever said, three things happen. Storage costs grow forever. Retrieval gets slower as the haystack grows. And the signal-to-noise ratio drops, because most of what anyone has said is forgettable.

Compression is the answer. Instead of keeping seventeen separate notes that "the user prefers spicy food", you keep one. Instead of keeping every casual mention of the dog over three years, you keep a richer single record - the dog's name, breed, age, vet, food preferences - and discard the noise.

The kitchen-drawer analogy is the right one again. You do not throw out the spatulas; you tidy them into a tray. When you next need a spatula, you find it instantly rather than knocking over a corkscrew, a roll of cling film, and three loyalty cards on the way. The information is the same; the organisation is what makes it useful.

Some facts have a clear sell-by date. "I am on holiday next week" is true until the following Monday and then quietly false forever. "My fridge needs servicing" is true until it has been serviced. "My eldest daughter starts secondary school in September" is correct for one specific autumn and never again.

Expiry is the rule that says these memories should die when their time is up, not linger as ghosts. Without it, an assistant happily reminds you about a trip you took last year, or recommends an oven repair you completed six months ago, or refers to your daughter as starting school when she is now in Year 9.

Most current AI memory systems are weak at this. They either keep everything forever or they delete things by age, which is too blunt. The mature design lets the system attach an expiry to facts when they are stored, so a trip booking auto-expires after the dates pass and a school year auto-expires the following summer.

If you have followed our guide to running a local LLM on a Raspberry Pi 5 or experimented with local image generators, you have probably found that the "out of the box" memory experience is poor. The model forgets things you would expect it to remember and remembers things you wish it had forgotten.

This is not a sign your hardware is too small. It is the same memory-design problem affecting cloud assistants, just visible at the seams because there is no big corporate plumbing hiding it. Several open-source projects are now experimenting with the five rules above. A common shape is a small SQLite database holding plain-text notes alongside the model, with a tiny scoring script that handles decay, confidence, and expiry. The Towards Data Science write-up that prompted this article describes one such design in detail, and the broader research community has been moving in this direction for some time.

The practical upshot for home users is that local AI memory will get noticeably better over the next year as these designs mature. If you are running anything memory-heavy today - a personal assistant, a home automation helper, a research tool - it is worth keeping the install pattern flexible so you can swap in a better memory backend without rebuilding everything else.