All Things AI · Season 3 · What You Can Build · Episode 2
A chat forgets when you close it. That is a product decision, not a limit. You can give a model memory that holds your rules, corrections, and past work for months, searches all of it on every request, and stays identical across every computer you use.
The second time you explain yourself is the signal
There is a specific moment most agents hit in week two. You tell the model something about how you work. It produces something good. The next morning you open it again and it has no idea who you are, so you tell it the same thing, and it produces something good again.
Most people ignore that moment for about a year. They build a document of instructions they paste at the start of every session, which works until the document is long enough that pasting it becomes the chore, and then they quietly stop.
The fix is not a longer paste. It is memory that persists on its own and gets consulted automatically.
What memory actually means here
Three separate things get called memory, and they are not equally useful.
Conversation history
Everything said in the current session. Useful, automatic, and gone the moment you close it. This is what most people mean when they say the model remembers, and it is the weakest form.
A standing instruction file
A document the model reads at the start of every session. Better, because it survives. It has a hard ceiling: everything in it is read every single time, so it costs you on every request, and once it is large it starts crowding out the actual work.
Retrieved memory
Hundreds or thousands of small notes stored separately, searched at the moment you ask a question, with only the handful that are relevant pulled in. This is the one that scales. You can accumulate rules for years and the cost per request stays flat, because you are never reading all of it, only the part that matters right now.
Why retrieval is the version worth building
The difference is not subtle once the volume grows. A standing file with four hundred rules in it is unusable, because every request drags all four hundred along and the model has to decide which of them apply. Retrieval turns that into a search problem, which computers are extremely good at.
The mechanism is worth understanding once. Each note is converted into a set of numbers that represents its meaning rather than its exact words. Your question gets converted the same way. The system finds the notes whose meaning is closest to your question and hands those to the model.
The practical consequence is that a rule written as do not use that phrase in listing copy will surface when you ask about writing a property description, even though you did not use any of the same words. It is matching on meaning, not on keywords, and that is why it keeps working as the collection grows.
What goes in it
The instinct is to store facts. The value is mostly in storing decisions.
- Corrections. The single highest-value category. Every time you tell it something was wrong, that becomes permanent instead of something you will say again next month.
- Preferences with the reason attached. Not just do it this way, but do it this way because of what happened when we did it the other way. The reason is what lets it apply the rule to a situation you never anticipated.
- Standing constraints. The things that are never acceptable, written once.
- Context about ongoing work that is not in any file. What a project is for, what was already tried, what was decided and why.
Making it identical everywhere you work
Most agents work on more than one machine. A laptop that travels and something that stays put. The moment memory becomes valuable, having two versions of it becomes a real problem, because you correct something in one place and the other place carries on being wrong.
Two machines can be set to reconcile their memory to each other on a schedule. The safe design is union only: anything new on either side gets copied to the other, anything newer wins, and nothing is ever deleted by the sync. That last rule matters more than it sounds, because a sync that can delete is a sync that can quietly destroy months of accumulated corrections on a bad day.
Run it hourly rather than nightly if one of the machines sleeps, because a nightly job aimed at a sleeping laptop simply never happens.
What it grows
Compounding, which is a word worth being precise about.
Every other tool you use is as good on day four hundred as it was on day one. Memory is the only part of this that gets better while you are not working on it, because every correction you make is permanent and every permanent correction removes a future error.
The practical version is that month six is noticeably better than month one without you having done anything extra. That is rare enough in software to be worth building deliberately.
Where this goes wrong
Four things break memory systems, and three of them are habits rather than technology.
Storing facts instead of decisions. The instinct is to fill it with information, which is exactly the material that goes stale and that your files already hold more reliably. The durable value is in decisions and corrections: what you chose, and why, and what happened when you tried it the other way. A fact expires. A reason keeps applying to situations you have not met yet.
Letting the sync delete. If you run memory across two machines, the reconciliation must copy and update and never remove. A sync with delete permission will eventually mirror an empty or partial folder onto a full one, and the failure is silent, which means you find out weeks later when a rule you rely on has quietly stopped being enforced. Take a dated copy before every run.
Never writing the note. The system only knows what you tell it, and the moment of correction is the moment you are least inclined to stop and write something down. This is the entire discipline of the thing, and it is the reason most people’s memory layer is thin. One sentence at the moment of the correction is worth more than an hour of organising later.
Treating it as authority. Memory records what was true when it was written. If a rule names a file or a tool, that file or tool can be gone by the time it surfaces. It is a strong prior, not a fact, and anything consequential still gets checked.
What it costs
Nothing per month if you run the search locally, which is the normal setup. The storage is a file on your disk, the search runs on your own processor, and the only real cost is the discipline of writing a note when you correct something instead of just correcting it.
Questions agents actually type
Can AI remember things between conversations?
Yes, but not by default. Conversation history disappears when you close the session. Persistent memory has to be built as a separate layer that stores notes and retrieves the relevant ones at the moment you ask, which is what makes it survive across months rather than minutes.
What is the difference between an instruction file and AI memory?
An instruction file is read in full on every request, so it has a hard size ceiling and gets expensive as it grows. Retrieved memory stores notes separately and pulls in only the few that match your current question, so it stays cheap no matter how much accumulates.
Can two computers share the same AI memory?
Yes. A scheduled reconciliation can keep both sides identical. The important design rule is union only, meaning it copies and updates but never deletes, so a bad run can never destroy accumulated work.
What should I actually put in AI memory?
Decisions and corrections rather than facts. Every time you tell it something was wrong, record that with the reason attached, because the reason is what lets the rule apply to situations you never anticipated. Facts belong in your files, where they can be kept current.
Season 1 is Claude Code for Real Estate Agents, filmed and on its own hub. All three seasons: AI for real estate agents.