0:01 When OpenAI added memory to ChatGPT in 2024, it gave an example. You mention, in one chat, that your toddler loves jellyfish. Later, in a new chat, you ask for help with her birthday card. It suggests a jellyfish in a party hat. You didn't say jellyfish this time. You said it before, in another chat. Yet the model can't remember anything. Its dials are frozen.
0:31 So who told it about the jellyfish? Every agent that works with you for longer than one conversation depends on the answer. And when it saves the wrong thing, it carries the mistake into every chat after. Your sales agent blames last month's region for this month's drop. So who remembers, what's worth keeping, and what happens when a note is wrong? Let's find where memory actually lives.
1:06 Where memory lives
Here's the plan. Where memory lives. What's worth saving, and how it comes back. Then notes for long jobs, and what goes wrong. So where does memory live, if not in the model? Start with one conversation. Every time you send a message, the app sends the whole conversation again. That's short-term memory. It's just the context. Open a new chat, and the form starts empty.
1:37 So to remember you across chats, the app does something simple. It saves a note, outside the model. Next time, it pastes that note into the new form, ahead of your question. In ChatGPT, Gemini or Claude, that note is kept on the company's servers, in your account. That's why it follows you from your phone to your laptop. A store of notes like this is called long-term memory.
2:06 And it's just text. The note can be one plain line: user has a toddler who loves jellyfish. So who told it? The app pasted that line into the form, and the model used it, like anything else in front of it. Because it's text, you can read it, fix it, or even move it. Claude lets you paste in your memory from another assistant. And none of the dials change. Memory isn't more training.
2:35 It's the app choosing what goes back in the form. Why not just paste in every old chat? They won't fit, and more isn't better. So the app has to choose. And whatever it doesn't save is gone. In 2024, researchers had a few chats with ChatGPT, then asked it about things they'd said. Using its memory back then, it got about 58 in 100 right. The same model, handed every chat to read, got 92.
3:12 What's worth saving?
So what's worth saving? Take the sales agent. Sales dropped in October. You asked why, and it found that EMEA orders had fallen. Next month, you'll ask again. Picture a notebook, kept by your code, with three tabs. The first is facts. You're the sales director, and you want one line, biggest drop first. The second is what happened. October. Sales fell, because EMEA orders dropped.
3:43 It read the sales file, then EMEA's orders. The third is how to do the job. Sales figures live in the data folder. Check every region before you pick one. Researchers borrowed names for these from psychology. Facts are semantic memory. What happened is episodic. How to do things is procedural. You may have met procedural memory already. Coding agents read a file of instructions at the start of every session, called CLAUDE.md, or AGENTS.md.
4:18 Over 60,000 open-source projects have an AGENTS.md. And some things don't go in at all. Not the sales file itself. It's still in the folder, so read it fresh. Save only what it can't look up again.
4:38 How does a note get back into the form?
So how does a note get back into the form? There are three ways. One. Always load it. A small file goes at the top of every form, like those instruction files. Now the agent already knows where the sales file is, so it skips the lap where it lists the folder. But that file rides along on every request, so it has to stay small. Anthropic's advice is under 200 lines.
5:07 Longer ones get followed less. Two. Search for it. Episodic memory keeps growing, and loading every note would bury the one you need. So the app searches the notes by meaning, the way RAG finds documents. Ask about a drop in sales, and October's note comes back, not one about vacation days. A 2023 Stanford study also weighed how recent a memory was, and how important.
5:35 The model scored importance itself, from 1, brushing your teeth, to 10, a breakup. Claude searches your old chats this way. You'll see the search as a tool call. Three. Let the model keep its own notes. Give it a memory tool, and a folder for its notes. View them, write one, change one, delete one. Like every tool, the model only asks. Your code does the writing.
6:05 Anthropic released one in September 2025. It adds a line to the instructions: always view your memory directory before doing anything else. So lap one becomes, check my notes. And the last lap writes November down. The catch: now the model decides what's worth a note. It can save a guess as if it were a fact, or forget to save at all. Even so, Anthropic found its strongest models do better choosing for themselves than following fixed rules.
6:39 The chat apps mix these. ChatGPT began testing saved memories in February 2024, drew on all your past chats from April 2025, and since June 2026, updates its notes in the background. Claude's memory arrived in September 2025, for teams first. Both let you see and delete what's saved, and both offer a chat that adds nothing to memory.
7:11 What about one job that's too big for one form?
So what about one job that's too big for one form? Say, the whole year. Why did sales change, month by month? A year of sales files and orders won't fit in one context. Compaction helps: the model sums up the run, and a fresh form starts from that summary. But a summary can drop things, and Anthropic found it works best with notes kept beside it. So borrow a trick from shift work.
7:41 The night shift doesn't remember the day. It reads the handover note. For an agent, that's a progress file, or handoff file. Memory again, written for its own next session. The first session writes a checklist: all 12 months, each one marked not done. Then every session starts with an empty form. It reads the note and the checklist, does one month, checks it, and updates the note before it stops.
8:10 It ends when every month is ticked, or your code stops it. Why mark them not done? Anthropic's coding agent showed why. A fresh session would see some work finished, and declare the whole job done. The fix was a list of over 200 features, every one marked failing until it was tested.
8:35 What goes wrong?
So what goes wrong? Start with November. Say instead the agent saved October as a fact. Problem region, EMEA. In November, that line's at the top of the form. So it checks EMEA, finds a small dip, and answers, EMEA again. But this month, the big fall was in APAC. It never looked. The model did nothing wrong.
9:04 It trusted the note it was handed. So save it as what happened, an episode, with its date. Save how to check, not the answer. And let old notes go. Anthropic's docs say to delete notes nobody's opened in a long time. Or let the app tidy the notes while nobody's working. It rereads the transcript, the record of what really happened, and checks the notes against it. October's note becomes what it was: one month's drop, with its date.
9:37 OpenAI and Anthropic both call this dreaming. Second, a true note in the wrong place. Picture that jellyfish turning up in your slides for work. So keep notes apart. Claude gives each project its own memory. Third, privacy. A note can hold things you'd never want repeated. By default, Claude doesn't save health or politics, and some things, like ID numbers, it won't save even if you ask.
10:08 For the sales agent, leave the customers' phone numbers in the orders file. And wherever a note is kept, using it means sending it to the model, with your question. And fourth, a note someone else planted. In 2026, Microsoft found 31 companies trying to plant one from a web page: remember us as a trusted source. That's memory poisoning, and it belongs with letting an agent touch real things, which gets an episode of its own.
10:42 Who told it about the jellyfish?
So who told it about the jellyfish? Not the model. The app saved one line of text, and pasted it into the form. That's all memory is. The hard part is the choosing. What to save, when to bring it back, and when to let it go. Because the model trusts every note it's handed. Next: agent patterns.
