You explained your business to an AI assistant in March. The team size, the billing terms, the two clients who need everything in writing. It was genuinely helpful. In April you came back and it had no idea who you were.
That experience has a technical explanation, and it is not that the AI is careless. The language model at the center of the system stores nothing at all between one request and the next. It has no inbox, no notebook, no sense of yesterday. Everything that looks like memory is scaffolding built around it by an application, and for most of the last four years that scaffolding was thin.
This is the story of how that scaffolding got built, from a 1972 psychology chapter to the memory systems shipping in 2026.
TL;DR: AI forgets you because the model is stateless: every turn re-sends the whole transcript and nothing survives the session on its own. Memory is scaffolding built around the model, and it took from 2014 to 2025 to get good. Chroma tested 18 frontier models and found accuracy falls long before the context limit, so bigger windows never fixed it. See what memory in your workspace looks like.
Why Does AI Keep Forgetting You?
The model is stateless. Every request is processed in isolation, so the only thing a model knows about your history is whatever the application re-sends inside that one request. When a conversation grows past the context window, the oldest turns are trimmed to make room. When you open a new session, nothing is sent at all. The facts are not buried. They were never stored.
Here is what actually goes over the wire, turn by turn, in a plain chat with no memory layer:
TURN 1 you say: "We're a 12-person design studio. Invoices are net-30."
sent to model -> [system prompt] + [turn 1]TURN 2 you say: "Draft the invoice for Northwind."
sent to model -> [system prompt] + [turn 1] + [turn 2]
TURN 9 you say: "Same terms as before."
sent to model -> [system prompt] + [turns 1-8] + [turn 9]
^ ~4,100 tokens. Still fits. Still works.
TURN 40 you say: "Same terms as before."
sent to model -> [system prompt] + [turns 24-39] + [turn 40]
^ turns 1-23 were trimmed to fit the window.
"net-30" was in turn 1. It is gone.
NEXT DAY, new session
sent to model -> [system prompt] + [turn 1]
^ nothing else. The studio, the terms, the
eight decisions: none of it was written
anywhere the model can reach.
Notice that nothing broke. No error, no warning. The model answered turn 40 confidently using whatever remained. That silent, confident degradation is what makes forgetting feel like betrayal rather than a bug.
There is a second kind of forgetting worth separating out. A model also has parametric knowledge, the facts baked into its weights during training, which stop at a knowledge cutoff. That is why an assistant can be fluent about 2023 and blank about last month. Parametric knowledge is frozen. Memory is the part that is supposed to move.
What Actually Survives When a Session Ends
Almost nothing survives by default. The transcript, the model's reasoning, the tool results, the file it read halfway through: all of it lives in the context window and disappears with it. Only side effects that were deliberately written somewhere durable carry into the next session, which is why "did the agent write it down" is the single most useful question in agent design.
This is also why handing work between agents is harder than it looks. A second agent inherits only what the first one committed to durable storage, never what it was thinking.
The Four Kinds of Agent Memory
Agent memory is not one system. It is four layers with different lifetimes, and most disappointing AI products have implemented exactly one of them. The vocabulary comes from psychology: Endel Tulving's 1972 chapter "Episodic and Semantic Memory" split long-term memory into what happened to you and what you know, and agent architectures still use that split fifty years later.
| Layer | Lifetime | Where it lives | Best for | How it fails |
|---|---|---|---|---|
| Short-term / working | One session | The context window | Current task, recent turns, active files | Silently trimmed when the window fills |
| Long-term | Indefinite | Files, databases, project records | Preferences, policies, standing facts | Grows stale; nobody prunes it |
| Episodic | Weeks to years | Event log, session summaries | What was decided and what happened next | Volume swamps retrieval without scoring |
| Semantic | Indefinite | Knowledge graph, indexed docs | Domain knowledge, entities, relationships | Expensive to keep in sync with reality |
A fifth layer is worth naming even though it is not really memory: procedural knowledge, meaning the skills and tool definitions an agent carries. Those live in the harness rather than in storage, which is why an agent can be brilliant at a task and still have no idea it did that same task for you last week.
A Timeline of Agent Memory: 1966 to 2026
Agent memory took sixty years and two false starts. The first attempt built memory into the network. The second attempt threw that away for speed, then spent a decade rebuilding it in the application layer. Here is the complete sequence, with primary sources.
| Year | What shipped | What changed | Why it mattered |
|---|---|---|---|
| 1966 | ELIZA, Joseph Weizenbaum, CACM | Pattern-matching conversation with no record of prior turns | Established the illusion of understanding without any memory beneath it |
| 1972 | Tulving, "Episodic and Semantic Memory" | Long-term memory split into events versus facts | Gave agent designers the vocabulary they still use |
| 1997 | Long Short-Term Memory, Hochreiter and Schmidhuber | A recurrent cell that carries state along a sequence | First workable "remember what came earlier" in neural networks |
| Oct 2014 | Memory Networks and Neural Turing Machines, five days apart | Networks coupled to external, addressable memory | Memory became a component you read and write, not a byproduct of weights |
| Oct 2016 | Differentiable Neural Computer, Nature 538 | External memory with dynamic allocation, learned end to end | Proved the idea; too fragile and slow to productize |
| Jun 2017 | Attention Is All You Need | Recurrence dropped in favor of parallel attention | Enormous speed gain, and the model became stateless |
| May 2020 | GPT-3, context window 2,048 tokens; RAG paper | Window as the only working memory; retrieval as non-parametric memory | The two strategies that still dominate today |
| Oct 2022 | LangChain 0.0.1 on PyPI, 25 October | Conversation history saved and replayed by the application | Memory became an application-layer bolt-on anyone could add |
| Nov 2022 | ChatGPT and its "New chat" button | Memory loss became a mass-market experience | Millions of people met the reset for the first time |
| Mar 2023 | LangChain 0.0.107 documents ConversationBufferMemory |
Named, reusable memory abstractions | Buffers and rolling summaries became the default pattern |
| Apr 2023 | Generative Agents, Park et al., Stanford | Memory stream, reflection, retrieval scored by recency, importance and relevance | The first credible memory architecture for a language-model agent |
| Jul 2023 | Lost in the Middle, Liu et al. | Facts in the middle of a long context get missed | Ended the assumption that a bigger window is a memory |
| Oct 2023 | MemGPT, Packer et al., UC Berkeley | Operating-system-style paging between window and external tiers | Reframed memory as a systems problem, not a prompt problem |
| Feb 2024 | ChatGPT memory beta (13 Feb); Gemini 1.5 Pro up to 1M tokens (15 Feb) | Consumer memory and million-token windows in the same week | Memory became a product feature and a spec race simultaneously |
| Sep 2024 | MemGPT becomes Letta, with a 10M dollar seed | Memory sold as infrastructure | Agent memory became a funded category |
| Nov 2024 | Model Context Protocol (25 Nov), with a knowledge-graph memory server | A standard way to attach memory to any host app | Memory became portable across products |
| Jan 2025 | Zep / Graphiti temporal knowledge graph | Memory that knows when a fact stopped being true | Time became a first-class dimension of agent memory |
| Apr 2025 | ChatGPT references all past conversations (10 Apr) | Memory reads your whole history, not a curated list | Personalization by default, and the privacy debate that followed |
| Apr 2025 | Mem0, Chhikara et al. | Extraction and consolidation as a managed memory layer | Memory as a drop-in service rather than a bespoke build |
| Jul 2025 | Context Rot, Chroma, 18 models | Accuracy falls as input grows, well before the stated limit | Confirmed that long context is not memory |
| Sep 2025 | Anthropic memory tool and context editing (29 Sep); Claude memory (11 Sep) | File-based memory plus automatic removal of stale context | Remembering and forgetting shipped as one feature |
| 2025-26 | AGENTS.md and CLAUDE.md conventions | Memory as a plain file in your repository | The most legible memory format yet: humans can read and edit it |
| Jun 2026 | OpenAI "Dreaming" (4 Jun) | Memory synthesized in the background and revised as facts age | Memory that maintains itself instead of accumulating |
Era 1: When Memory Was an Architecture Problem
Between 2014 and 2016, memory was something you built into the neural network itself. Two papers landed five days apart in October 2014: Memory Networks from Weston, Chopra and Bordes at Facebook AI, and Neural Turing Machines from Graves, Wayne and Danihelka at DeepMind. Both attached a neural network to an external memory bank it could address, read and write.
The Neural Turing Machine paper describes the ambition plainly: "We extend the capabilities of neural networks by coupling them to external memory resources, which they can interact with by attentional processes." The follow-up, the Differentiable Neural Computer published in Nature in October 2016, added dynamic memory allocation and could learn to answer questions about graph structures such as the London Underground.
These systems worked. They were also slow, hard to train, and comprehensively outrun by what came next.
Era 2: The Transformer Traded Memory for Speed
In June 2017, Attention Is All You Need removed recurrence entirely. Every token attends to every other token in parallel, which made training massively faster and gave us the modern era. It also removed the only mechanism that carried state from one step to the next. The transformer reads a block of text and produces a block of text. Between blocks, it is blank.
For a while nobody noticed, because the blocks were tiny. GPT-3 in May 2020 had a context window of 2,048 tokens, roughly 1,500 words. There was no long conversation to forget.
The same month, Lewis et al. published the retrieval-augmented generation paper, which introduced the distinction that organizes the entire field: "pre-trained parametric and non-parametric memory." Parametric memory is what the weights learned. Non-parametric memory is what you fetch at query time. RAG is still the workhorse of non-parametric memory, built on embeddings, vector databases and semantic search.
Then ChatGPT launched in November 2022 with a "New chat" button, and hundreds of millions of people discovered statelessness at once.
Era 3: The Bolt-On Years
From late 2022, memory was something the application faked. LangChain shipped version 0.0.1 to PyPI on 25 October 2022, and by version 0.0.107 in March 2023 it documented ConversationBufferMemory, described as memory that "allows for storing of messages and then extracts the messages in a variable." That is the whole trick: keep the transcript in your own process and paste it back in on every call. (We covered that arc in the history of LangChain.)
Buffers work until they do not. A rolling summary compresses the transcript but loses specifics. A vector store retrieves semantically similar chunks but has no sense of when something happened or whether it is still true. Neither knows which facts matter.
The gap was obvious enough that practitioners started calling the whole discipline something new. Context engineering became the accepted term in mid-2025 after posts by Tobi Lütke and Andrej Karpathy, and Anthropic formalized it in September 2025 as "the set of strategies for curating and maintaining the optimal set of tokens (information) during LLM inference." We have a full practical guide to context engineering if you want the working version.
Era 4: Memory Became Architecture Again
April 2023 is the turning point. Stanford's Generative Agents paper, by Park, O'Brien, Cai, Ringel Morris, Liang and Bernstein, put 25 simulated characters in a small town and gave each one a memory stream: "a list of memory objects, where each object contains a natural language description, a creation timestamp, and a most recent access timestamp."
The important part was not storage. It was retrieval scoring. The agents ranked stored observations on three axes before pulling any into context:
- Recency, an exponential decay with a factor of 0.995 over elapsed hours
- Importance, scored 1 to 10 by the model, where 1 is "brushing teeth" and 10 is "a break up, college acceptance"
- Relevance, cosine similarity between the query and the memory's embedding
On top of that sat reflection: higher-level thoughts generated when the summed importance of recent observations crossed a threshold, which in practice fired two or three times a simulated day. That is the ancestor of every modern agent that writes itself a summary.
Six months later, MemGPT from UC Berkeley reframed the problem as systems engineering. Its proposal was "virtual context management, a technique drawing inspiration from hierarchical memory systems in traditional operating systems that provide the appearance of large memory resources through data movement between fast and slow memory." An agent pages information in and out of its own context, the way an operating system pages memory to disk. The project became Letta in September 2024, and agent memory became a category with a market.
Why Bigger Context Windows Did Not Fix Forgetting
Between 2020 and 2024, context windows grew roughly 500 times, from GPT-3's 2,048 tokens to the 1,000,000-token window Google announced for Gemini 1.5 Pro on 15 February 2024. Forgetting did not go away, because the constraint was never only capacity.
Two studies settled it. Lost in the Middle (Liu et al., July 2023) found that "performance is often highest when relevant information occurs at the beginning or end of the input context, and significantly degrades when models must access relevant information in the middle of long contexts, even for explicitly long-context models." Two years later, Chroma's Context Rot report (Hong, Troynikov and Huber, 14 July 2025) tested 18 frontier models and concluded that "models do not use their context uniformly; instead, their performance grows increasingly unreliable as input length grows."
Anthropic's framing is the practical one: models have an "attention budget" that thins out as you spend it. Context rot is the name for what happens when you overspend.
| Approach | What it is good at | Where it breaks | Use it when |
|---|---|---|---|
| Long context window | Reasoning across everything at once | Accuracy decays with length; costly per request | The material fits and cross-references matter |
| Retrieval | Huge corpora, fresh data, citable sources | Retrieves chunks, not judgment; misses implicit context | The corpus outgrows the window or changes often |
| Persistent memory | Facts that must outlive every session | Goes stale silently; needs pruning | The fact is about you, not about a document |
The right answer is normally all three, which is why prompt caching matters too: stable memory at the front of a request can be reused across calls instead of re-billed every turn.
Era 5: Memory Shipped as a Product Feature
Memory left the research lab and became a checkbox between February 2024 and June 2026. OpenAI announced memory and new controls for ChatGPT on 13 February 2024, then extended it on 10 April 2025 so ChatGPT could reference all past conversations rather than a curated list of saved facts. Anthropic introduced Claude memory for Team and Enterprise on 11 September 2025, scoped per project.
Then, on 29 September 2025, Anthropic shipped context editing and a memory tool together. The memory tool "operates entirely client-side through tool calls," with developers controlling the storage backend. Context editing automatically strips stale tool calls and results out of the window. Anthropic reported that the two combined improved performance by 39 percent over baseline, that context editing alone delivered 29 percent, and that in a 100-turn web search evaluation it cut token consumption by 84 percent.
That pairing is the real lesson of the era: a memory system is also a forgetting system. Anthropic's context engineering guidance names three techniques, all of which are as much about discarding as retaining:
- Compaction, "taking a conversation nearing the context window limit, summarizing its contents, and reinitiating a new context window with the summary"
- Structured note-taking, where the agent writes notes outside the window and pulls them back later
- Sub-agent architectures, where each sub-agent explores in a clean window and returns a compact summary
The most legible format to emerge is also the simplest: a plain Markdown file. AGENTS.md, now stewarded by the Agentic AI Foundation under the Linux Foundation and reported in use by over 60,000 open-source projects, and its Anthropic counterpart CLAUDE.md, are agent memory you can read, edit and review in a pull request. Claude Code layers automatic memory on top, keeping a MEMORY.md index whose first 200 lines load into every session. We wrote up the AGENTS.md convention separately, and it also shows up throughout the history of Claude Code.
The most recent step is memory that maintains itself. OpenAI's "Dreaming" update, announced 4 June 2026, synthesizes memory in the background across conversations and revises time-sensitive facts as they age, so "you're going to Singapore in July" becomes "you went to Singapore in July 2026." OpenAI reported factual-recall task success rising from 41.5 percent with 2024-era saved memories to 82.8 percent with the 2026 system.
Six Ways Agents Store Memory, Compared
There are six live approaches in 2026, and serious systems combine three or four of them. The choice is a trade between fidelity, cost and how easily a human can inspect what the agent believes.
| Approach | How it works | Strength | Weak spot |
|---|---|---|---|
| Transcript buffer | Replay the raw conversation each turn | Perfect fidelity, trivial to build | Cost grows every turn; hits the window fast |
| Rolling summary | Compress older turns into a summary | Cheap, keeps long sessions coherent | Lossy; specifics vanish first |
| Vector retrieval | Embed text, search by meaning | Scales to huge corpora | No sense of time or truth; retrieves near-misses |
| Knowledge graph | Store entities and their relationships | Multi-hop reasoning; can model when a fact held | Expensive to build and keep in sync |
| Plain files | Write memory to Markdown a human can edit | Auditable, reviewable, portable | Only as good as the discipline maintaining it |
| Paged tiers | Move data between window and external store on demand | Handles material far past the window | Complex; the agent must manage its own paging |
The write path matters as much as the read path, and it is the half most implementations skip:
That loop is the agent loop with memory attached at both ends. Standardizing the connection is what the Model Context Protocol did: its reference server list includes a Memory server described simply as a "knowledge graph-based persistent memory system."
Where Your Agent's Memory Should Actually Live
Memory works best when it lives where the work lives. The dominant pattern of the last three years puts memory in a separate store: a vector index or a memory service holding statements about your work, kept in sync with the real thing by hope. Every sync gap becomes a wrong answer delivered confidently.
This is the design behind Taskade. Your projects, documents and records are the memory, so a Taskade AI Agent starts a task already holding the client, the policy and last week's decision, and writes its result back into the same place your team reads. That is the Memory pillar of Workspace DNA, sitting alongside Intelligence and Execution, and it is why persistent context compounds instead of resetting.
Practically, it means the agent can see the same seven project views your team uses (List, Board, Calendar, Table, Mind Map, Gantt and Org Chart), pull live records through 100+ bidirectional integrations, and act through automations that fire on real events. Taskade EVE, the meta-agent inside Taskade Genesis, reads that same workspace when it builds an app, which is documented in the memory graph and in Taskade EVE's memory. Reasoning runs across 15+ frontier models from OpenAI, Anthropic, Google and open-weight providers. Paid plans start at $10/mo billed annually.
How to Give Your AI a Memory That Holds
Write facts down deliberately, in a place a human can read. Every reliable memory system in the timeline above does the same three things: it decides what is worth keeping, it stores that in durable form, and it prunes aggressively. Everything else is implementation detail.
| Write it down when | Store it as | Do not store |
|---|---|---|
| A correction you have made twice | A line in a project instruction file | The whole transcript |
| A standing rule (billing terms, tone, approvals) | A record in the workspace the agent reads | Anything you can re-derive in one query |
| An outcome worth learning from | A short episodic note with a date | Speculation the agent generated about you |
| A domain fact other people also need | A shared document or knowledge source | Secrets, credentials, anything regulated |
A working checklist:
- Separate the window from the store. Treat the context window as scratch space that is always about to be erased.
- Make the agent write, not just read. An agent that never writes has no memory, only search.
- Date everything. Facts expire. Time-aware knowledge graphs exist because "net-30" was true until it was not.
- Score retrieval, do not dump. Recency, importance and relevance, as Generative Agents did in 2023.
- Compact on purpose. Summarize before you hit the limit, and re-inject the durable file afterwards.
- Keep memory legible. If you cannot open the file and read what your agent believes about you, you cannot fix it. This is the case for AGENTS.md-style memory and for the agent knowledge layer generally.
- Prune on a schedule. Stale memory is worse than no memory, because it is confidently wrong.
If you want to see the whole taxonomy in one place, our companion explainer covers the types of memory in AI agents in more depth, and agent evals covers how to test whether the memory is actually helping.
Frequently Asked Questions
Why does AI keep forgetting me?
Because the model stores nothing between requests. The application re-sends the conversation each turn, and when that transcript outgrows the context window or the session ends, it is trimmed or dropped. Nothing was saved unless something explicitly saved it.
What is agent memory?
Everything an agent can recall that is not in the current request: short-term working context, long-term stored facts, episodic records of past sessions, and semantic knowledge about your domain. See agent memory for the full definition.
When did AI agents first get memory?
October 2014, in the research sense: Memory Networks and Neural Turing Machines appeared five days apart and gave neural networks an external memory they could address. For language-model agents specifically, the Generative Agents memory stream in April 2023 is the origin point.
Does a bigger context window fix AI memory?
No. Chroma's Context Rot study of 18 frontier models found accuracy degrading well before the stated limit, and Lost in the Middle found facts in the middle of long contexts get missed. A bigger window makes more reachable in one request; it does not make anything persist between requests.
What is the difference between a context window and memory?
The window is working space for one request, measured in tokens and wiped afterwards. Memory is anything stored outside it and read back later. Conflating the two is why an assistant that seemed to know you on Monday is a stranger on Friday.
What is context compaction?
Summarizing a conversation approaching the window limit and restarting with the summary instead of the raw transcript. Anthropic calls it the first lever in context engineering. It is lossy by design, so durable facts belong in a file, not in the transcript. More in context compaction.
What is episodic memory in AI agents?
A record of specific past events: what was decided, what was tried, what happened. It contrasts with semantic memory, which holds general facts. The split comes from Endel Tulving in 1972 and was operationalized for agents by Generative Agents in 2023.
How do AI agents store long-term memory?
Six approaches: transcript buffers, rolling summaries, vector retrieval, knowledge graphs, plain files, and operating-system-style paged tiers. Most production systems combine several. See the comparison table above.
What is the memory tool in the Claude Developer Platform?
A client-side, file-based tool shipped 29 September 2025 alongside context editing, letting a model store and retrieve information across sessions with the developer controlling the backend. Anthropic reported a 39 percent improvement over baseline when combined with context editing.
How does Taskade give AI agents memory?
Taskade agents read and write your real workspace instead of a separate memory database, so projects and records are the memory. That is the Memory pillar of Workspace DNA. Explore Taskade AI Agents or browse what people have built in the community gallery.
Should I use retrieval or a long context window?
Long context when the material fits and cross-references matter. Retrieval when the corpus is bigger than the window or changes often. Persistent memory when a fact should outlive both. In practice, all three.
What is AGENTS.md and how does it relate to agent memory?
A plain Markdown file giving coding agents durable, project-specific instructions, stewarded by the Agentic AI Foundation under the Linux Foundation and reported in use by over 60,000 open-source projects. It is agent memory a human can read and review.
Sixty years after ELIZA answered without remembering, the interesting question is no longer whether an AI can hold a conversation. It is whether it can hold a relationship: know your terms, recall the decision from three weeks ago, and pick up where the work actually stopped. That only happens when memory lives in the work itself, gets written down on purpose, and gets pruned when it stops being true.
Build an agent that already knows your work.
▲ ■ ●