Writing
Memory Is Becoming a System Capability
A follow-up to the long-context argument. Storing, selecting and expiring facts is turning into a named part of the product.
Notes
In February 2024, I wrote that long context is not memory. A million-token context window can keep more information available during inference, but it does not decide what should survive after the session ends, what should be updated, or what should be retrieved next week.
Claude 4 makes that distinction more concrete.
Anthropic says Claude Opus 4 can create and maintain "memory files" when developers give it access to local files. The model can extract useful facts, save them, and read them later to maintain continuity across long-running work. In Anthropic's example, Opus 4 builds a navigation guide while playing Pokémon rather than relying on the active context window to preserve everything.
That is much closer to what I mean by memory.
The interesting part is that the memory does not live inside the model. It lives in a system around the model.
Context keeps information available. Memory decides what survives.
A context window is temporary working state.
If a project brief, conversation history and several code files fit inside the current prompt, the model can use them while generating the next response. A larger window gives the model a larger workspace.
Persistent memory has a different job.
It needs to select information worth keeping, store it somewhere durable, recover it later, and decide when an old fact should be replaced by a new one. In a production system it should probably track scope and provenance too: is this fact about the user, this project, this repository, or only this task?
None of that follows automatically from context length.
Claude 4 is interesting because the model can participate in these memory operations when it has filesystem access. It can decide that a fact is useful enough to record, update a file as work progresses, and consult that file later.
The filesystem becomes part of cognition.
Retrieval is only one half of memory
Retrieval-augmented generation already gives models access to information outside the context window.
A document corpus can be indexed, searched and inserted into a prompt when relevant. Anthropic's Contextual Retrieval work is a good example: the system improves the way chunks are represented so the retriever has more information about where each chunk belongs.
That solves an access problem.
Memory has an additional write problem.
A normal RAG system assumes the knowledge base already exists. The model searches it. A memory system has to decide when new state should enter that knowledge base in the first place.
Suppose an agent discovers that a build fails because one asset still uses an old export preset. Retrieval can help find documentation about export presets. Memory starts when the agent records that this project has migrated to the new preset, links that fact to the relevant project, and uses it during later work.
The difference is subtle but important.
Retrieval asks, "What existing information should I read?"
Memory asks that question plus, "What have I learned that should still exist after this task?"
Writing memory creates a new failure mode
Letting the model write its own memory is powerful because it reduces the need for developers to predict every fact worth storing.
It is dangerous for exactly the same reason.
A model can misunderstand a situation and save the misunderstanding. It can preserve a temporary assumption as a permanent rule. It can fail to update an old fact after the project changes. Later sessions may retrieve that note and treat it as trusted history.
The error has now survived the context window.
This means persistent memory needs more engineering than a text file named memory.md.
I would want memory entries to have scope, timestamps and some record of where the information came from. Project memory should not silently become user memory. A tool result should not be treated the same as an explicit user preference. Some facts should expire. Others should require confirmation before being overwritten.
The model can help decide what to save, but the storage layer should make those decisions inspectable.
The memory hierarchy is becoming visible
MemGPT proposed a useful version of this architecture in 2023. It treated the context window like limited physical memory and external storage like a slower memory tier, moving information between them as needed. Its experiments included multi-session conversations where persistent information could survive beyond one context window.
Claude 4 brings part of that idea into a mainstream agent workflow.
The active context can hold the immediate problem. Files can carry durable notes across longer work. Retrieval can bring relevant external knowledge back into the active window. Tools can inspect the real environment when stored memory is not enough.
These layers have different properties.
Context is fast but temporary.
Files or databases are persistent but need selection and retrieval.
External tools provide current state but can be slower or expensive.
A good agent should know which layer to use instead of trying to make the context window perform every job.
What this means for production work
This is where memory becomes useful to me beyond chat history.
A Blender production agent does not need to remember every conversation we have ever had. It needs a small set of durable project facts: naming conventions, export targets, approved cameras, material rules, output paths, known exceptions and decisions that should survive between sessions.
A game-development agent may need repository conventions, localisation rules, build commands, platform constraints and known project-specific failures.
Those facts are more valuable when they are explicit state than when they are buried in a transcript.
I would separate at least three types of memory.
User memory contains durable preferences that apply across projects.
Project memory contains facts and decisions tied to one production environment.
Task state contains temporary progress for the job currently running.
Mixing these together creates context pollution at a larger timescale. A useful fact from one client project can become wrong in another. A temporary workaround can quietly turn into a permanent rule.
Memory architecture therefore needs boundaries, not just storage capacity.
Long-running agents make this unavoidable
Anthropic describes Claude Opus 4 as capable of sustained work on long-running agent tasks, including workflows lasting several hours and requiring many steps.
The longer a task runs, the less realistic it becomes to keep every observation, tool result and intermediate decision inside one growing conversation.
Something has to be compressed, discarded or moved outside the active context.
Once that happens, memory management becomes part of task execution.
An agent fixing a large codebase may need a progress file describing what it already tried. A research agent may need notes about rejected hypotheses. A production automation system may need checkpoints recording which assets were processed and which still need attention.
These are not conversational memories.
They are operational state.
That is why I think "memory" will become a broader systems concept than the feature most people currently associate with assistants remembering personal preferences.
My prediction
I expect agent platforms to expose memory more explicitly over the next few years.
Not one opaque store that silently remembers everything, but several forms of persistent state with different scopes and policies.
The model may decide when something appears worth preserving. The runtime can decide where it is allowed to write. Retrieval can decide what should return to context. Deterministic checks can verify important facts against the current environment before the system acts on them.
For production systems, I think editable and inspectable memory will be more useful than invisible memory.
If an AI system remembers that my Blender project exports in centimeters, I want to know where that fact came from and change it when the pipeline changes. If an agent records that a bug has been fixed, the next session should still verify the repository rather than trusting the note.
Memory should reduce repeated work without turning yesterday's assumptions into today's ground truth.
Claude 4 is an interesting signal because it makes the architecture visible. Give the model a filesystem and it begins using that filesystem to extend continuity beyond its immediate context.
The context window is still the workspace.
Memory is becoming the system that decides what is worth bringing back to it.
Sources
- Anthropic, Introducing Claude 4, 22 May 2025.
- Anthropic, Claude Opus 4 & Claude Sonnet 4 System Card, May 2025.
- Anthropic, Introducing Contextual Retrieval, 19 September 2024.
- Packer et al., MemGPT: Towards LLMs as Operating Systems, 12 October 2023.
More
Other write-ups
Approval Is Not Publication
Thirty seven items in the queue, one approved, nothing published. The last arrow in the diagram is the only one that pays.
Neural Rendering Is Crossing From Reconstruction Into Synthesis
Reconstruction filled in what sparse sampling missed. DLSS 5 generates appearance the renderer never computed.
The Renderer Is Becoming a Training Data Engine
The renderer used to sit at the end of the pipeline. Physical AI gives the same scene a second job: teaching a model.
Local AI Is Becoming a Compute Fabric
Local AI meant one model on one machine. Routing inference across the devices already on a network changes the unit.
Agent Infrastructure Is Becoming a Product Category
Every team used to build the loop, the store, the sandbox. That layer is being sold rather than written.
Choosing a local model with a stopwatch, not a benchmark
Three models, five hard tasks, code actually executed. The official build was 2.4 times faster and more accurate than a community repack of the same model.
We measured real time lighting against baked light, and baked won
A 3D product simulation that had to look like an offline render. The real time version ran at 60 frames per second and looked like clay. Here is the measurement and the architecture that replaced it.
What actually broke in an agency run by agents
Three failures from a delivery stack that runs on AI. None of them were the model's fault, and all three reported success while producing nothing.
A Task Without A Check Command Is Not Automated
If a task has no command that can fail, the pipeline advances on the appearance of work.
A Gate The Model Writes Is A Gate The Model Loosens
Three quality gates returned green while the work behind them was wrong, each for a different reason.
The Scoring Model Was Wrong And It Put The Worst Lead First
A weighted sum let one axis substitute for the other, so a company with money and no problem ranked in the top twenty.
Building Software Got Easy. Getting Value Out Of It Did Not
Aristo took weeks to build. Everything after the build is still in progress, and that gap is the whole story.
Capability Is Becoming an Operational Risk Surface
Safety questions used to be about the text. Once a model can act, the capability itself becomes something to operate.
The Scene Graph Is Becoming an API for AI
A scene graph exists for artists and software. Agents are becoming another consumer, and they need structure rather than pixels.
Animation Is Moving From Clips to Motion Priors
Authored keyframes and blended clips are giving way to asking which constraints define acceptable motion.
Materials Are Becoming Learned Programs
A material is texture maps, parameters and shader code. It is starting to become a small learned program that answers a rendering question.
Procedural Systems Are Expanding Beyond Geometry
Geometry Nodes started with a narrow name. Blender 5.2 puts physics, sound and object data through the same graph.
The Unit of AI Work Is Becoming the Task, Not the Turn
Chat taught us to think one turn at a time. Long-running agents make the task the thing that is scheduled, resumed and reviewed.
Game Engines Are Becoming Operating Systems for Worlds
Engines have been judged on what they render and simulate. The Unreal 6 roadmap points at operating a world rather than drawing one.
The Model Is Becoming a Replaceable Backend
Choosing a provider used to mean choosing an architecture. A stable interface makes replacement possible and evaluation makes it safe.
The Harness Is Part of the Capability
The same model behaves differently depending on context policy, tool design and execution feedback. That surrounding software is not neutral.
Physics Engines Are Becoming Trainable Components
A simulator predicts what happens next. A differentiable one can answer which parameter should change to stop the failure.
The Agent Needs an Environment, Not Just Tools
A search function and a database query were enough for short loops. Longer work needs a place to stand.
Coding Agents Are Becoming General-Purpose Computer Workers
Repositories were a friendly environment: text in, terminal actions, checkable results. That was a starting point, not a boundary.
Open Standards Outlive Model Generations
A year after the MCP bet, the argument can be checked against what happened rather than what was hoped.
Colour Management Is a Pipeline Contract
Blender 5.0 reads as better display options. Giving a file an explicit working colour space is an architectural change.
The Best Model May Be a Router, Not a Model
GPT-5 moves model selection inside the system. The interesting unit stops being which model and becomes which compute policy.
World Models Are Not Game Engines Yet
Genie 3 generates a navigable 720p world at 24 fps. Production work needs state you can inspect when something goes wrong.
Coding Agents Change the Unit of Software Work
AI coding tools have been judged where code appears on screen. The boundary moves when the agent owns a task instead of a snippet.
Agents Need Protocols Between Each Other, Not Just Tools
Tool calling solves the inside of the loop. It says nothing about one agent reaching another built by a different team on another platform.
Agents Need a Runtime, Not a Prompt Loop
An agent is no longer well described as a prompt inside a while loop. The useful abstraction owns execution around the model.
Reasoning Is Not the Only Path to Better Models
Longer thinking improves maths and code. A model that solves a logic puzzle and misreads ordinary intent is not the better production model.
Rendering Is Becoming a Reconstruction Stack
Sparse samples, motion data and lower-resolution frames become a larger final result. Debugging becomes layered when reconstruction sits in the middle.
Agent Reliability Is an Evaluation Problem, Not a Prompting Problem
When an agent misses a step, the usual fix is a stricter prompt. The failure is more often in how completion is detected.
MCP Might Matter More Than Another Model Release
A model can reason well and still be useless inside a company if it cannot reach the files, repositories and tools where work lives.
Computer Use Is the Missing Layer Between Models and Software
Most integrations assume useful software exposes the right API. Much of real software never did.
Inference-Time Compute Is a New Scaling Axis
o1 improves when it is allowed to spend longer on a problem. A benchmark score without a compute budget is an incomplete number.
The Final Pixel Won't Come From the Renderer
Geometry, camera and scene structure stay reliable ground truth. More of final appearance is moving into learned systems.
Open Models Are Becoming Research Infrastructure
Llama 3.1 gets discussed as a benchmark result. The licence terms change which experiments are possible at all.
The Model Is Becoming a Runtime
Function calling, code execution and structured output turn inference into a loop. The model stops being a text generator and starts being a control layer.
Multimodality Changes the Architecture, Not Just the Interface
GPT-4o is easy to read as a faster interface. Training one model end to end across text, vision and audio is an architectural change.
Benchmark Scores Are Not Model Capability
Claude 3 posts 86.8% on MMLU and 50.4% on GPQA Diamond. The chart is useful and it is not the same thing as capability.
Long Context Is Not Memory
Gemini 1.5 makes a million tokens usable. A larger working set is not a system that decides what should survive the session.