AI agent memory: how a chatbot learns to remember you between conversations

AI agent memory is a way for an assistant to keep information after a conversation ends. The model itself forgets everything between sessions, so the system around it saves notes somewhere else and loads the relevant ones back when a new task begins.

Think of a new hire who keeps a notebook. Each morning they read it before starting work. The notebook, not their brain, carries yesterday forward.

The same question, asked a week apart

Say you ask an assistant to help with an insurance claim. You mention the policy number, that the claim concerns a water leak, and that you prefer short emails. A week later you return and ask, “Any update on that claim?”

A plain chat model has no idea what you mean. Each conversation starts empty. An assistant with memory instead looks up what it saved, finds the claim notes and picks up where you stopped.

That difference is why memory is a headline feature in new agent products. Meta’s Muse Wonder models, for example, are built around a feature Meta calls Active Memory, which carries relevant details across conversations and brings them back when a task needs them.

Notes outside the context window

A language model reads a limited amount of text at once. That limit is called the context window. Everything the model can “see” while answering has to fit inside it, and when the session ends, so does that view.

Memory works around the limit with three steps:

1. Write. During a task, the agent decides something is worth keeping and saves it to storage outside the model.
2. Store. The note sits in a file, a database or a similar system until needed.
3. Recall. At the start of a later task, the agent searches or reads that storage and places the useful pieces back into its context window.

The model’s own weights do not change. It is reading its notes, not learning in the way training teaches it.

A concrete example is Anthropic’s memory tool for developers. Its documentation describes a directory of memory files that Claude can create, read, update, delete and rename. When the tool is enabled, Claude checks that directory before starting a task and writes what it learns under /memories. The tool runs client-side: Claude requests file operations, and the developer’s application carries them out against storage the developer controls.

From operating-system tricks to agent notebooks

The idea of treating a model’s context like a computer’s memory was laid out in the 2023 paper MemGPT: Towards LLMs as Operating Systems by Charles Packer, Sarah Wooders, Kevin Lin, Vivian Fang, Shishir G. Patil, Ion Stoica and Joseph E. Gonzalez at UC Berkeley, first posted to arXiv on October 12, 2023.

The authors borrowed from operating systems, which move data between fast, small memory and slower, larger storage so programs seem to have more memory than the hardware holds. They called their version virtual context management. The context window plays the role of fast memory, and external storage plays the role of the slow tier.

In MemGPT the model uses function calls to read and write that external storage and to edit its own context. The paper tested two settings: analyzing documents larger than the model’s context window, and multi-session chat in which an agent keeps information across long-term interactions. The authors reported that MemGPT handled both, and they released their code and data.

Since then, memory has moved from research prototypes into products and developer toolkits. The Anthropic documentation above describes the pattern as just-in-time retrieval: the agent records what it learns and reads it back on demand, instead of loading everything up front.

Who uses it, and what Meta has said

Memory now appears in several forms. Developer platforms offer tools like the one above. Consumer assistants save preferences and facts about the user. Coding agents keep progress logs so a new session can resume a project. Anthropic’s documentation describes this last pattern: an initial session sets up a progress log and feature checklist, and each later session starts by reading them and ends by updating them.

Meta describes Active Memory as the feature that lets a Muse Wonder model carry relevant details across conversations and recall them when a task calls for them. According to Meta’s own framing, reliable memory is a critical step toward useful personal and professional agents. Meta has not, in the material we reviewed, explained the internal design, so it is not known whether it resembles the file-based approach described above.

According to TechCrunch, Meta’s model card says Muse Wonder beats rivals on Meta’s own MemoryBench. These are company figures, not independent results, and they say little about how the feature behaves in daily use.

Where memory goes wrong

Memory adds capability, and it also adds new failure modes.

• Privacy. A system that stores details about you holds a record worth protecting. Who can read it, how long it lasts and whether you can delete it are product decisions, not properties of the technique. Meta says it trained its models not to share private information without permission, and Anthropic’s documentation notes that Claude usually refuses to write sensitive information to memory but advises developers to add their own validation for stronger guarantees.
• Wrong or stale notes. An agent can save a mistake, or keep a preference that has since changed. Later answers then rest on outdated facts. Anthropic suggests developers periodically expire files that have not been accessed in a long time.
• Clutter. Left alone, an agent can fill its store with redundant files. Anthropic’s guide recommends prompting the model to keep the folder organized and to rename or delete files that are no longer relevant.
• Security of the plumbing. When a model can read and write files, the surrounding code must stop it from reaching outside its folder. Anthropic’s documentation warns that developers must validate every path to prevent directory traversal.
• Retrieval misses. A saved fact helps only if the agent looks for it at the right moment. Having a note and finding it are different problems.

What to watch as memory becomes standard

Three questions are worth following. First, control: whether users can see, edit and erase what an assistant has saved about them. Second, measurement: memory benchmarks such as the MemoryBench Meta cites are the company’s own, so independent testing will matter. Third, design: whether memory stays as readable files and notes or moves into less visible systems.

Meta says a fuller safety report for Muse Wonder is still to come. Memory is likely to be one of the areas readers will want it to cover.