At Ampron we run a team of AI agents alongside our people. They handle sales follow-up, finance, production planning, operations and more. Each has a role, tools and responsibilities, much like an executive in a small company.
The most frustrating thing about working with them is also the hardest to explain to anyone who hasn't: they don't remember anything. An agent can do excellent work at ten in the morning and, at eleven, have no idea it ever happened. For us humans that is almost impossible to imagine, so I want to explain how it really works, what the research says in late 2026, and what we are changing as a result.
The model never remembers. It only reads.
A large language model has two kinds of "knowledge".
The first is its training: billions of numbers, fixed when the model was built. This is where its general skill lives: writing, reasoning, knowing what an invoice is. It is the same for every customer, and it does not change while you use it.
The second is its working window, called the context. This is the text placed in front of the model for one run: its instructions, the conversation, the documents and tool results it is working with. The model reads the whole window, produces an answer or an action, and then the window is thrown away.
There is nothing else. No third place where the model quietly files away what it learned about your company. Everything it seems to "remember" was put in front of it, as text, at the start of that run.
Even a normal chat works this way. Each reply is a brand-new run. The software simply sends the entire conversation again, every time, with the new message at the end. When the conversation gets too long, older parts are summarised or dropped, and detail is lost. When the chat is closed, it is gone from the model's view unless something copied the important parts elsewhere.
The best analogy: Memento
If you have seen Christopher Nolan's Memento, you already understand AI agents.
Leonard, the main character, can't form new memories. His skills and general knowledge are intact. Within a single scene he is perfectly capable. But every few minutes his memory resets, and the only thing that tells him who he is and what he is doing are the notes his past self left: Polaroids, scribbles, tattoos.
That is an AI agent exactly. Training intact, nothing new sticks, and everything it knows about its situation comes from notes.
The film's real point is the sharpest lesson for anyone building with agents: Leonard trusts his notes completely, and he has no way of checking them. A wrong note gets acted on with full confidence. An agent reading an outdated fact behaves the same way. It doesn't hesitate. It believes.
"Why not store it in a memory chip instead of text files?"
This was my first engineering instinct, and probably yours too. Surely writing notes to text files and reading them back is primitive?
It turns out the file is not the bottleneck. Reading a text file takes milliseconds. The limit is that a model can only take in new information in two ways: through the context window (reading text) or through changing its trained numbers (retraining). Moving the notes to faster hardware changes neither.
Providers do already keep some things in fast hardware memory. When a model has read a long block of text, its internal representation can be cached, so the next request with the same beginning is faster and cheaper. That speeds up reading. It does not make the model remember or understand anything better.
The real "memory inside the model" route is to keep updating the model's own numbers as it works. Researchers are working hard on this. Google's Nested Learning research and its "Hope" architecture, for example, aim at models that keep learning without overwriting old skills. As of autumn 2026, that work is still described as a proof of concept, and no production model you can buy uses it. There are also good reasons to be cautious even when it arrives: knowledge hidden inside a model can't easily be inspected, corrected or deleted. A wrong fact in a text file can be found and fixed. A wrong fact inside the model is Leonard's Polaroid hidden inside his own head.
So for the foreseeable future, the practical answer is: give the model better notes, organised better, at the right moment.
What the research says in 2026
Agent memory has become one of the busiest research areas in AI. One survey published in October 2026 counted more than 3,000 papers on the subject, over 2,000 of them from this year alone. A few findings stand out, and they match our own experience closely:
- Finding the right note matters far more than how it was written. How memory is retrieved moved accuracy by around 20 points. How it was written moved it by only 3 to 8.
- Things that change belong in structured records, not prose. For questions like "how many open orders do we have?", structured records were almost always right. Searching free-text notes was often badly wrong.
- Old facts must be marked as replaced. When a newer fact explicitly says "this replaces that", stale answers almost disappear. When the system just searches for similar text, it serves outdated information a meaningful share of the time.
- Agents don't reliably go and look. In one study an agent with a full memory store available made zero lookups in over a hundred turns. The software around the agent should hand it the relevant memory, not wait to be asked.
- Summarising loses rules. Long conversations get compressed to save room, and rules are among the first things to disappear.
- Memory can be poisoned. If an agent writes what it reads in an email into its memory, a malicious email can plant a false "fact" that is trusted later. Warnings in the instructions barely help. Structural controls, such as tracking where every memory came from, help a lot.
Separate academic work from April 2026 put the bigger picture well: moving memory out of the model into notes doesn't make the problem disappear. It turns it into a problem of organising and retrieving those notes well.
What our own agents taught us
We assumed our biggest problem was too much text. Our agents' instructions had grown long, and we thought important rules were getting lost in them.
Then our platform agent analysed the mistake logs our agents keep, close to 400 entries, each a short "five whys" of something that went wrong. Over half were memory or continuity failures. But prompt size caused only a handful of them. The real causes, roughly in order:
- Checking the wrong place, and believing it. An agent looked in one system, didn't find something, and reported it as "not there" or "already done".
- Acting on a stale fact. An older record said a question was still open, nothing marked it as resolved, and the agent asked for a decision that had been made weeks earlier.
- A promise that was never recorded. "I'll send that tomorrow" existed only in a message, so nothing reminded anyone.
- A lesson that was written down but didn't come up at the right moment. The agent had a note explaining exactly how to do something, and made the mistake anyway. In its own words: "I didn't re-read it."
Every one of these is Memento. Not forgetting, but trusting the wrong note, or not looking at the right one.
The architecture we are moving to
The answer is not one big notepad. It is a map plus a filing cabinet, organised in layers, where each run reads only what it needs.
1. The map, always loaded and short. Who the agent is, what's on its desk right now (open commitments, due follow-ups, unread messages) and an index of the notes it can open, one line each.
2. Structured records for things that change. Commitments, decisions, orders, and facts with a "valid from" date and a "replaced by" pointer. These are queried for exact answers, not read as prose.
3. Small linked notes, one subject each. A customer, a product, a supplier, a recurring problem. Each note says where its information came from and when it was last checked, and links to related notes. The agent follows links when the task needs them, the way you click through a wiki.
4. The raw archive, searched only. Emails, documents, old conversations. Nobody reads it whole. Useful findings get promoted into a note.
Three mechanisms make the layers work:
- The software pre-loads by task. When an agent wakes up to follow up with a customer, the system identifies that customer and puts the relevant notes in front of it before it starts.
- Lessons appear at the moment of action. Most repeat mistakes happen when the agent is about to use a specific tool: send a message, create a form, generate a document. Right before that action, the two or three lessons filed against that tool are shown to it. Where a lesson is a hard rule, the tool itself refuses the wrong input. Rules enforced by the system beat rules written in instructions.
- Regular housekeeping. A scheduled pass merges duplicate notes, marks outdated ones and keeps the map short, so the filing cabinet doesn't turn back into a pile.
We also apply one simple rule to safety: anything that comes from outside, such as an email, can only ever be recorded as a claim about its sender ("the supplier says delivery takes six weeks"). It never becomes a rule or an instruction. Only people with authority can write those.
And before an agent may say "not found" or "done", it has to state which sources it checked. That one habit alone addresses the largest category of our mistakes.
The takeaway
We cannot give today's models a memory. What we can do is design the paperwork around them: what each run must write down, in what structure, and what the next run is guaranteed to see first.
If you are building with AI agents, my advice is this. Don't ask "how do I make the agent remember?" Ask the question an air traffic controller or a shift supervisor would ask: "What does the next shift need on the desk when it walks in, and how do we make sure the handover log is right?" Better memory for AI agents is not a better brain. It is better records and a better handover.
Sources and further reading:
- State of AI agent memory 2026: what 3,283 papers show (OpenChamber, October 2026)
- When Continual Learning Moves to Memory: A Study of Experience Reuse in LLM Agents (Hu et al., April 2026)
- Google's Nested Learning and the Hope architecture (The Robotics Media, 2026)
- Claude memory tool documentation (Anthropic)
- Zep: A Temporal Knowledge Graph Architecture for Agent Memory (2025)
- A-Mem: Agentic Memory for LLM Agents (NeurIPS 2025)
