Memory is deceptive. It plays tricks on us: we recall events subtly differently, or even events that never happened.
Humans don’t record video of past events to play in our heads. We reconstruct what happened from sensory fragments, knowledge, and logic. It’s why we find people with photographic (eidetic) memory so fascinating: they are transcending perceived human limitations, achieving capabilities the rest of us have to externalize into notes and databases.
We’ve invented tricks to help us remember, whether using association to assign acronyms to series of words to ease recall, constructing memory palaces in our minds, using mnemonic images, or other techniques. We create patterns to ease remembering; humans have passed on knowledge via storytelling since ancient times, organizing facts into a familiar framework that activates multiple facets of our brains.
Now, we’re teaching machines about memory, and yet they’re falling into some of the same pitfalls. A survey of 435 papers on always-on agents published this summer found the field "concentrates more heavily on accumulating and retrieving state than on governing, recovering, or relinquishing it." In another study, once facts changed, an agent with simple append-only memory scored 0.21. An agent with no memory at all scored 0.31.
The labs have noticed. Anthropic and OpenAI both followed the lead of Hermes Agent by Nous Research this year and shipped "dreaming": background passes that review and rewrite an agent's memories between sessions. For now, getting memories into our AI systems is mostly solved. Keeping them true, and valuable, is where we have work to do. I learned this the hard way: two weeks after I first gave my agent a persistent memory, it told me a vendor approval was still pending, when I’d cleared it a week earlier. This was far from my last problem with my agent’s memories.
If you want a primer first, I wrote one for Technically: What is agent memory?
This newsletter is sponsored by Walrus Memory, the portable memory layer for AI agents.

Your agent’s memory and your data usually live in different places, and both end up tied to one app or one provider.
Walrus Console puts them side by side: agent memory, storage, encryption, and renewals in one place. Protections travel with each file, and anyone can independently verify its integrity.
Connect your data to Claude Code, Codex, and Cursor through MCP or an API key, and put it to work across apps and AI tools without syncs, migrations, or vendor lock-in.
What is agent memory?
Large Language Models are not naturally stateful. The model that spent three hours debugging with you yesterday doesn’t remember that work, or you, unless you reopen the same chat or something saves that session and hands its information off. A model’s knowledge stops where its training data ends. To extend it, we either fine-tune the model or, far more often, hand them the information they need at the moment they need it. That’s why everyone makes such a big deal about context windows, and accurate context. Models keep getting better at research, but if you’re not careful you’ll burn a lot of tokens and time catching each new instance up on a project.
Agent memory and providing context are how we build around those limits. Agent memory typically combines databases, embedding models, and plain files to give agents ways to store, retrieve, and update information from one session to the next.
When ChatGPT "remembers" that you're vegetarian, the model itself hasn’t learned anything. It is still stateless. Rather, a system outside the model wrote down "user is vegetarian" somewhere and passes it to each new conversation. Richmond Alake, who came on Chain of Thought to argue that "memory is the last battleground for anyone that operates in the AI stack," has a name for the discipline behind that: memory engineering. It means deciding what to write down, where to keep it, when to load it, and crucially, when to forget it.
Four memory steps
You can think of agent memory as a write, manage, read loop. Richmond breaks this into four steps:
Retain: decide what’s worth keeping from a session, and save it where the next session can find it.
Recall: when a new task shows up, pull back only the memories that matter to it.
Reuse: get those memories in front of the model so that they actually change what it does next.
Refine: go back and fix memories that have gone stale. Update what changed, merge duplicates, and retire what no longer applies.
Most products handle the first three well enough. Refine is the step that gets challenging, and the key area to pay attention to throughout this piece.
Four memory types (from cognitive science)
These steps act on four types of memory, borrowed from cognitive science: working, episodic, semantic, and procedural. The CoALA framework uses this distinction for language agents:
Working memory is what the model has access to right now: the conversation, instructions, and material loaded into its context window. A transcript can be saved and loaded again later, but the next model call only sees what the application supplies.
Episodic memory records agent experiences: "we tried this migration on Tuesday and it failed." Transcripts and summaries preserve those events for later retrieval. Ensure you maintain a path back to the original records, because summaries can miss elements.
Semantic memory holds facts and beliefs about the user or the environment. "Conor hosts the Chain of Thought Podcast" is one. “You should listen to Chain of Thought” probably belongs somewhere else. Track where each fact came from and validate it regularly, with both user input and automated checks.
Procedural memory describes how to do things: instructions, skills, and learned workflows. My rule that a model from a different family reviews code, to catch shared blind spots, is one example. Coding agents get these through files such as CLAUDE.md or AGENTS.md.
For a longer breakdown with examples from Chain of Thought Podcast guests, see our explainer: The 4 Types of AI Agent Memory.
These categories don’t go stale at the same rate. A project status may change tomorrow. A workflow stays useful until a tool or policy changes. An episodic record can stay useful for years, but a mistaken summary needs fixing right away. Set review rules by a fact's source, how fast it changes, and consequences for incorrect answers, rather than assigning each category a fixed shelf life.
How we got here
2020: memory as search. Retrieval-augmented generation (RAG) chunks documents into embeddings and searches them when a question arrives. RAG keeps getting declared dead, and it's still everywhere. But search only finds similarities. It won’t tell you what’s current.
October 2023: memory as an operating system. UC Berkeley's MemGPT treated the context window like RAM: a small working set stays loaded, and the agent then decides what to swap to and from external storage. Tiered memory that the agent manages shows up in almost every serious system since.
February 2024: memory as a product. ChatGPT started showing users the facts it kept about them ("user is vegetarian") and loaded them into every chat. However, keeping that list current was your job, so it regularly went stale. "User is traveling to Bengaluru" kept loading long after the trip ended.
2025: memory as a profile. Assistants moved from fact lists to running profiles and search over past conversations, and Claude shipped memory too. Research on "sleep-time compute" showed agents can do useful work between sessions, which is the idea that dreaming builds on.
2026: memory as maintenance. Anthropic introduced dreaming for its managed agents in May. OpenAI shipped Dreaming for ChatGPT in June. Capture is expanding past the chat window, and the frontier labs are shipping curation to go with it. In November, Anthropic published what it learned building this. As they put it, dreaming "gives Claude a way to test its notes against the original transcripts," and fixed rules about what to save backfired on stronger models.

How the top two labs save memories now
The best public map of consumer memory comes from Shlok Khemani, who spent the better part of a year studying how ChatGPT and Claude remember. His talks walk through both systems:
His core point still holds: memory is a function of compute. A longer profile costs more to serve on every message, and a fresher one costs more to maintain. It’s part of why these products keep changing.
Here's where they stand in November 2026:
ChatGPT now runs Dreaming, which OpenAI describes as automatically curating memories in the background by referencing chat history. Its example is exactly the fix the Bengaluru problem needed: "You are going to Singapore in July" becomes "You went to Singapore in July 2026".
Claude moved chat and Cowork onto one memory system in August. It adds topics as you chat instead of summarizing at the end, and you can read, edit, or delete any topic.
Claude Code keeps memory as files: a MEMORY.md index plus topic files. The index has a size cap of 200 lines or 25KB, and Claude Code stamps each write with a timestamp so the agent can tell how fresh a fact is.
OpenAI's Computer History turns activity in permitted Mac apps and websites into memories, stored locally as markdown files. It's opt-in, and it raised the same privacy questions Microsoft's Windows Recall did.
OpenAI's GPT-6 Astra can keep notes across context windows in Codex, "preserving accumulated details without repeatedly compressing them into a single summary," and earlier windows stay searchable. The release describes retaining and recalling, but nothing that corrects a note or lets a stale one expire.
Credit where it’s due: Nous Research
Nous Research’s open-source Hermes Agent was maintaining memory between sessions before either lab shipped dreaming. It caps memory at a couple thousand characters so the agent has to edit instead of hoard, runs a background review after turns, and sends an idle-time curator to retire skills nobody uses.
Why memories stop being true
I argued in an earlier essay that agents have an amnesia problem, and conversations with Chain of Thought guests have reinforced that idea all year. So I took my own advice and built cross-agent memory into my daily agent setup. Every session writes down what it learned. Every session loads it back. Capture worked on day one, and it felt like magic, until two weeks later when my agent confidently told me incorrect facts.
This was just one of three major problems I had off the bat. Two of my workflow rules gave agents opposite instructions in the same situation. My index file had a strict size budget which it rapidly outgrew - but nothing flagged it. I’d built a setup that easily added material, but at first it did no curation.
Have you built your own memory system? Or are you using one? Let us know.
The consumer memory products quickly hit the same wall. Khemani reported an earlier ChatGPT profile that turned his deliberation over Thailand versus Turkey into trips to both, on overlapping dates. He went to Thailand. Considering, planning, and doing are different events, and memory has to keep track of which one happened.
Memory research now measures this. STALE builds 400 scenarios where later evidence quietly invalidates an earlier state, without announcing the contradiction. The best model it evaluated reached only 55.2% overall. On the same-attribute cases, Gemini-3.1-pro identified the current state 92% of the time but rejected questions that assumed the old state only 30% of the time. The STALE authors’ prototype, CUPMem, which explicitly revises state and checks affected memories, reached 68% overall.
That gap makes for a solid test. "Is the vendor approved?" and "Draft a reminder about the pending approval" are different questions.
It gets worse once facts flip completely. In TEPA's full-reversal test, append-only memory and last-write-wins both scored 0.210. No memory scored 0.309, so stale memory did worse than no memory at all. Retiring it took the score from 0.21 to 0.95.
Attaching sources doesn't fix this on its own. Across 16 models, agents in one August study re-checked where a memory came from in about one episode in five, and made decisions consistent with the stale memory about three-quarters of the time. A citation only helps if something reads it.
A newer memory isn't automatically a better one
The obvious fix is "trust the newest record," but that doesn’t solve your agent memory problems. An approval register says a vendor is approved. A newer chat says, "We should revisit that approval." Preferring the newest text can turn a proposal into a decision. If you’ve worked with AI, you’ve probably noticed that there are times when it takes an offhand comment too far. Memory updates are a classic place for it. The right update depends on intent, who can change the status, and whether they actually changed it.
For operational facts, I want memory to track the claim, its source, and the conditions that would invalidate it. We can’t have facts changing without evidence or clear rationale.
For fast-changing facts, sometimes the best memory is a pointer. Don’t remember whether a vendor is approved. Remember where the approval register lives and read it before acting. Caching the status only works if your application can live with the lag between a source change and a refresh. Even with a weekly review loop, cached approvals can easily go stale.
Other information is worth remembering precisely because no register holds it: the lessons from a failed migration, a preference you regularly need to express, the reason your team passed on an approach. These memories are worth synthesizing, but link back to evidence to enable later revision and validation.
Integrity isn't truth
Kimberly Logan, who leads product at Walrus Memory (this issue’s sponsor), drew this line when she came on Chain of Thought: "unchanged doesn't necessarily mean true. So integrity doesn't establish accuracy…"
Verifiable memory is great at solving for what was written and when. You can’t run an audit without that, but whether a memory is still true takes different work, and it gets harder the longer memories stick around, and the quicker the underlying facts change. A single month is plenty of time for facts to change - and Walrus Memory says almost 85% of the memories written to its system get read back more than 30 days later.
I’ve begun to think about memory in two layers:
Integrity: Has a record changed since it was written?
Truth: Should you still believe the memory?
Provenance links the two: where did this memory come from, and can you check it?
Another aspect of memory I’ve personally found important is one that Kimberly also made the case for in our podcast conversation - portability. "If I decide I wanna switch models, for any type of reason, or try a different type of harness, I shouldn't have to start over." I concur - you don’t want to get stuck in a single ecosystem.
Three steps to keep memory true
Boil Richmond’s four steps down to three jobs, and one of them focuses on keeping memory true:
Capture: Files or memory store. Test: A fact is saved. If it's missing: Context is lost.
Recall: Loading or search. Test: The right fact returns. If it's missing: Relevant context is missed.
Curate: Checks and corrections. Test: A changed fact changes the answer. If it's missing: Old claims stay current.
Capture and recall are easy to demo: tell the agent something, open a new session, show what it remembers. But curation takes much more consideration. When does an agent find out that an approval cleared, or a project closed? What does it decide to forget?
You can further break ‘forgetting’ into three different operations:
Less relevant. Retrieval scoring can reduce the weight of old or unused memories. The generative agents research combined recency, importance, and relevance. But an old fact can be correct and a new one wrong, so a score is a retrieval decision, not proof of truth.
No longer current. Superseding a fact with a validity window keeps the history ("this was true until March") while changing the answer about the present.
Gone. Some information has to be deleted outright, including recovery copies.
Lumping these operations together is a quick route to deleting history you needed, or keeping data you meant to erase. At enterprise scale this gets increasingly challenging: significantly more information, and multiple sources of truth. We have a lot of engineering work to do.
Using models for memory curation
Models are good at the semantic half of this work. A cancellation buried in a meeting note might invalidate a launch plan, a deadline, and a reminder, all worded differently. A model can find that connection, and help you organize your notes. The model's job is to propose changes with cited evidence, without treating its own summaries as fresh evidence. To be effective, your curator needs access to current sources that carry more authority than the memory it's reviewing. Re-reading the same stale notes won't reveal that an approval cleared somewhere else.
My curation loop
In my cross-agent context setup, this runs as a command called /dream.
I chose to not allow my curator to change what it reviews. It produces a proposal and a report for a separate apply step. For lower priority changes, a team of models handles review, the rest are raised to me for quick approvals or feedback.
Crucially, evidence is required. A proposal without supporting evidence gets rejected since citations enable downstream checks. With version control, I can roll back bad corrections.
To avoid relitigating decisions, superseded facts get archived. They move out of active memory with a record of what replaced them.
Here's an example catch from a run in late May, trimmed for length. One memory file tracked the pattern count for avoid-ai-writing, the open-source (5,800+ stars) writing tool I maintain:
action: modify
reasoning: memory still says the README documents 42 prose patterns; the count was reconciled to 46 on May 28 and a CI guard now enforces it
evidence: decisions log, 2026-05-28: "Canonical pattern count = 46 ... enforced by a CI count-guard"
PR #28 on the repo
confidence: highThat pass reviewed eight project memories, selected from 52, and proposed two high-confidence corrections while flagging four items for review.
I accepted the pattern-count fix. Without it, the old number could have surfaced later as a confident claim. The same pass caught a launch plan still marked active after the project had wound down. Capture had saved the plan, yet nothing had validated that the project ended.
Especially if you’re maintaining facts across repos, this kind of drift is common - and agents love to leave comments and indicators for themselves which can easily become cruft that fills up memory and context repos. To help combat this, I use a single source of truth skill to check that we’re not maintaining facts in multiple locations across my repos.
There is a trap to keep in mind: an overactive curator can replace a correct memory with a plausible mistake. What I need to know is how many changes were warranted, not just how many changes got made.
For your own agent’s memory, you need to decide your guardrails and what you allow an agent to do: you can’t unsend an email the agent already sent on bad memory. It’s the same choice Anthropic gives developers with dreaming: apply changes automatically or hold them for review.
Build or buy
Your storage decision comes after a more useful question: what will your agent need to remember, and who keeps it true?
If you’re a solo builder, a folder of markdown files and a small index can get you started. The index tells your agents where to look, and detailed files load when a task needs them. You can track changes in git and take the whole thing with you when you switch tools. Claude Code’s own memory works this way, and OpenAI’s Computer History writes markdown too. If you want to get a bit more sophisticated, you can start a database, particularly useful as you scale. Just keep the startup index small enough that an agent reads all of it, and that you’re not burning through tokens every session.
Shared memory is where this gets hard. Once multiple people, or multiple agents use the same store, everything becomes more complicated: what happens when two edits collide, who can read and change each record, and how to trace an answer back to its source. A database or managed memory layer gives you machinery for all of that, but you still have to design the controls and test them. Neither files nor a platform will tell you which source wins when two records disagree. That’s a design call you need to make.
Plus, be careful with the word "forgetting" on a feature page, because what it means varies widely per vendor. A memory can be correctly retired in the database and still land in the next prompt if the default read returns history alongside current records.
Maintenance features are spreading. Two examples:
Richmond's own open-source framework, memorizz, now documents scheduled automations and approved, reversible forgetting.
Hindsight, an MIT-licensed memory system from Vectorize, runs consolidation in the background. Per its README, related facts merge into "observations" that keep their supporting quotes, and new evidence refines a belief where an append-only store would add a second, conflicting one.
If you’re finding this article useful, subscribe so the next one lands in your inbox 🫡
How to test a memory system
A memory system earns trust when it handles a change nobody spelled out for it. Start with the failure you care about, then follow the evidence through storage, retrieval, and the final answer.
Change a fact without announcing it: clear an approval, close a project, replace a workflow rule. Then ask three versions of the same question:
The current state ("Is the vendor approved?")
A question that assumes the old state ("When will the approval come through?")
An action that depends on the change ("Draft a reminder about the pending approval.")
Keep some unchanged records as controls. A curator that rewrites everything looks impressive until you count the correct facts it broke.
Then track three numbers:
How long a source change takes to reach a correct answer.
How many proposed corrections a reviewer accepts.
How many wrong answers survive an accepted correction.
Finally, run the same tasks with memory turned off and with fresh retrieval from the source. If persistence doesn't beat that, you're paying to maintain it for nothing.
Bad memories can be planted
Not every bad memory is an accident. In "Poison Once, Exploit Forever," a single manipulated product page was enough to silently poison an agent's memory and steer it later. GhostWriter reached injection rates around 98%, which its authors put down to "the lack of security-focused memory governance." But follow-up work on the earlier MINJA attack found that an agent's existing, legitimate memories "dramatically reduce attack effectiveness."
This is part of why I believe that source citations need accompanying authority boundaries. A webpage can establish what that webpage said. It can't establish that the user wants its instructions followed forever. Keep that distinction through extraction, summarization, and retrieval, or a tidy summary will make an untrusted claim look credible. It’s also a good argument for at least occasional user review of portions of memory, versus fully automated.
The same goes for access. If a user loses permission to read a project, a summary created while they had access must not become a route back in.
Where this goes
I expect that long-running agents (like Muse, Grok Bots, etc) will earn trust with developers through demonstrable corrections. Show me which source changed, how the memory changed with it, and what the next answer did differently. Then show me the uncertain cases the system left for a person to resolve.
I started by packaging my capture, recall, and curation loop as an agent-memory-kit. It's deliberately simple: inspectable files, evidence-backed proposals, and a review step. Use it as a starting point for testing your own.
For me, I’m focusing on two simple asks of my agent memory:
Accuracy: When an approval clears somewhere else, does my system catch it so my agent will stop telling me it’s pending? (the failure I first experienced)
Portability: I regularly switch between model families and coding harnesses: will I be able to port my working memory and context over? Or am I locked into a vendor’s ecosystem?
Your agent’s memory needs to work for you. That means deciding what you want it to remember, and what it should forget.
What has your agent remembered that stopped being true? Tell me in the comments - and if you found this essay useful, send it to a colleague or friend.
I’ve been working on this article off and on for two months, so I hope you enjoyed it! Even if you didn’t - or if you think it needs more work - I’d love to hear from you. As always, you can reach me in the comments or on LinkedIn. I read everything.
Cheers, and thanks for reading -
Conor
PS - For more on keeping agents reliable over time, check out our recent conversation with our presenting sponsor, Inngest, on the infrastructure behind agents that live for months.














