There is a tempting answer to the agent-memory problem: save everything.
Keep every message, tool call, decision and error. Embed the lot. Trust that the right fragment will return when the agent needs it.
Nacho Martínez Rincón’s objection is wonderfully direct:
“Storing everything is not memory.”
Memory, he argues, begins when a system decides what to keep, what to revise and what it can safely forget.
For our first live episode of the Agentic Engineering podcast, I spoke with Nacho, an AI Engineer and Developer Advocate at Oracle and co-instructor of DeepLearning.AI courses on agent memory and adaptive agents. We began with a simple question: what should an agent remember?
The audience made the question much harder.
Before we dive in, a quick word from PlayerZero.
Before you add another agent, give them all the same context
PlayerZero is the AI orchestration and context platform for engineering teams
Code isn’t the bottleneck anymore. Context and review are. Every agent your team adds starts from its own partial picture, and your senior engineers end up filling the gaps by hand.
PlayerZero builds one engineering world model from your code, tickets, and telemetry, then orchestrates agents across product, engineering, QA, support, and SRE on top of it. Work moves between teams with full context attached. When an agent reaches the edge of what it should decide, it pulls in the right person with the investigation already done. That decision goes back into the model, so the next agent inherits it.
Key Data doubled its release velocity. Cayuse catches 90% of issues before production.
A larger context window does not solve the problem
An agent’s working context is useful during a task. It holds the conversation, the files being examined, and the information needed for the next decision.
But allowing that context to grow indefinitely eventually works against the agent. Important instructions begin competing with old messages, irrelevant details and earlier attempts. Nacho calls this context rot: the system technically has more information, yet becomes less capable of using it well.
Long-term memory should not become an overflow cupboard for everything that no longer fits in the context window.
Most of what happens during a task should disappear with it. The useful part is whatever could change a future decision.
Remember the lesson, not the entire conversation
One of the most practical ideas from the conversation was to turn completed work into a reusable lesson.
Suppose an agent encounters an error, investigates it and eventually finds a fix. Saving the full exchange leaves the next agent to reconstruct the experience from hundreds of messages.
A better memory might contain only:
the problem it encountered
the error that exposed it
the action that resolved it
Those traces can then be consolidated into a skill the agent retrieves when it meets a similar problem again.
The important distinction is that the agent is not replaying its past. It is carrying forward what the past taught it.
Nacho also recommends waiting until a task has finished before creating most durable memories. Only then can the system distinguish a temporary detail from a lesson worth keeping. The obvious exception is a dangerous failure that needs an immediate “never do that again” rule.
Memory creates a new attack surface
The discussion became more uncomfortable when we reached memory poisoning.
An instruction that once disappeared at the end of a session can now survive for weeks. A compromised skill file, malicious update, or false memory may quietly influence decisions long after the original interaction has been forgotten by the user.
Nacho explains why memory systems need provenance, version histories, and checks that reveal when a trusted file has changed. The system must remember—but it must also be able to show where that memory came from and what has happened to it since.
The live audience took us further into enterprise memory architectures, decay strategies, shared memory between agents, and whether these systems can be built without deep coding expertise.
Watch the full conversation for Nacho’s practical (and provocative) answer to the question of what an agent should carry into its next session.
If you want to take these ideas into implementation, Nacho will lead our Build Memory-Aware AI Agents workshop on 21 November.
I’ll be back on Thursday. Until then, keep building!
