Context Isn’t Memory
Every AI company is expanding context windows. The next durable winner will build memory. These are not the same product.
Anthropic shipped 1-million-token Claude. Google announced 2-million. OpenAI’s roadmap implies 10-million by 2027. The story being told is: soon, your agent will “remember everything.”
It will not.
The story confuses two things the tools themselves conflate: context and memory. They are different products with different failure modes. If you build or buy on the assumption that longer context is the same as better memory, you are repeating the category error that made enterprise knowledge bases unreadable — just one layer of the stack lower.
Context is what the model sees this turn. Memory is what it carries between turns.
A context window is a scratchpad. It grows, it shrinks, it resets. Dump 500,000 tokens of history into it and the model technically has access to all of it — and technically ignores 80% of it, because attention at the tail of a long context is measurably worse than attention near the recent query. This is structural, and it gets worse as windows grow, not better.
Memory is different. Memory is what survives. It is the durable, structured, retrievable substrate that persists across sessions, across projects, and across model upgrades. A human reading this essay remembers it next month not because working memory kept all 1,500 words — it didn’t — but because the structure compressed into three usable claims. That compression is the memory. The full text is just the context that produced it.
Every current AI product is shipping context. Almost none are shipping memory.
The tell is in the upgrade path
Ask any team running AI agents in production about their memory architecture. The honest answer is some version of:
“We stuff the last N interactions into the context.”
“We have a vector DB; we retrieve top-K.”
“We’re waiting for longer context windows.”
These are context strategies. None of them are memory. Here’s how you tell the difference: when the model changes — when Claude 4.7 gets deprecated, when OpenAI sunsets gpt-5 — does your agent keep its past? If the answer is “we re-embed everything” or “we re-stuff the prompt,” you don’t have memory. You have context that happens to be long.
Real memory survives the model. The analog is the difference between writing in sand and writing in stone. Both record information. Only one compounds.
What functional memory actually does
Your brain does not work by expanding its context window. When you recall your mother’s name, you are not replaying audio. You are retrieving a compressed, typed atom — name, relationship, affect — that has been filed against thousands of other atoms in a schema you don’t consciously maintain.
Functional memory has four properties that AI “memory” products mostly skip:
It’s typed. A name is not a date is not a fear. The retrieval mechanism knows the difference.
It’s compressed. You do not store transcripts. You store distillations.
It retires. You forget your high-school locker combination on purpose. It is no longer load-bearing.
It has provenance. You know, roughly, where a belief came from — and when that source is impeached, the belief updates.
Now run any production AI memory layer through those four. Most fail on three of them. The ones that pass were purpose-built as memory, not repurposed from a RAG pipeline.
RAG is a detour, not a destination
Retrieval-augmented generation was the right move for 2023. The model was small, the corpus was big, chunk-and-embed was the only way to bridge them. But RAG was never a memory architecture. It was a workaround.
RAG retrieves. It does not file. It does not type. It does not retire. A document embedded in 2024 sits next to a document embedded in 2026 with no sense of which is current, which is revoked, which contradicts the other. The agent retrieving them cannot tell the difference. This is the same failure mode that made knowledge bases unreadable, one layer of the stack lower, and for the same reason: the system optimizes “find” and skips “decide what’s still true.”
Longer contexts will not fix this. They will hide it, briefly, by letting you stuff more documents into the prompt before performance degrades. Then you will notice your agent making confident decisions based on retired policies, and you will have no way to tell it why.
Four commitments of a real memory layer
The same framework from last week, applied one layer down the stack:
Memory is typed and structured. A decision is not a fact is not a preference. The shape of the memory governs what it can do. zuun — the open-source Claude Code memory plugin I’m releasing this week — files every entry as
decision, observation, pattern, commitment, or reference. Not because taxonomy is fun, but because untyped memory is indistinguishable from noise.Memory is compressed at capture. An agent that logs every turn drowns in its own history. The entries that survive a week are the ones that distill — three sentences, one claim, a pointer to the artifact. The rest is context and should be discarded as context.
Memory retires. A preference expressed in January that was overridden in March should stop voting in April. Every production memory layer I’ve audited accumulates forever. Every one of them is quietly making worse decisions for it.
Memory has provenance and survives the model. If you can’t read the memory back under a different model and have it mean the same thing, it wasn’t memory. It was a prompt cache with better marketing.
Build to those four or buy to those four. Most products on the market fail on the fourth alone.
Why the incumbents can’t fix this
The people optimizing context have no incentive to solve memory, because the memory problem makes the context problem look solvable. If your agent forgets who you are between sessions, a longer context window feels like the answer. It isn’t. It’s just a bigger scratchpad.
The answer is a memory layer that types, compresses, retires, and carries provenance — and sits underneath whatever context window is in fashion this year. That layer has to be local-first, model-agnostic, and thin enough to disappear. It cannot be a product line inside a foundation-model company, because foundation-model companies win by making context feel like the answer.
That’s the product I’m building. It’s also the product nobody in the enterprise AI stack has shipped. The first one that does owns the category — not for the reason people usually cite, but because memory is the piece of the stack that still works when you swap the model underneath it.
Your agent doesn’t need more context. It needs a memory system that existed before it booted up, and will outlive the model that runs it.
That is not a bigger scratchpad. That is a different product.
zuun is the open-source reference implementation. 167 tests, local-first, Claude Code native. Ships this week. If you run an agent, I’d like you to install it.