A question that sounds settled but isn't
Ask how an AI agent “remembers” and you'll usually hear one answer: memory tools. The agent calls remember() and recall(), often backed by a vector DB behind an MCP server — mem0, Letta, Zep, the memory feature in your favorite assistant. It feels like the obvious, modern way to do it.
But that's only half the field. An enormous fraction of production memory works the opposite way: the agent has no idea memory exists. The orchestration layer silently edits what goes into the context window — summarizing old turns, sliding a window over history, retrieving relevant chunks and pasting them in. RAG is this. Conversation summarization is this. The auto-compaction in long coding sessions is this. The model just receives a curated message list and never knows the curation happened.
The two paradigms
Managed memory (implicit): the host decides what the model sees.
Agentic memory (explicit): the model decides what to store and recall, via tools.
These aren't two implementations of the same thing. They put the decision authority in different places, and that difference cascades into cost, reliability, and what you're actually measuring when you benchmark an agent.
Where they actually diverge
Who holds the decision
Managed memory is a property of the harness. A config like {type: "summary"} fully specifies the behavior; it runs identically regardless of which model sits behind it. Agentic memory is a property of the model's behavior — it only works if the model actually chooses to call the tools at the right moments. The capability is the same; whether it gets used is not.
What it costs
Managed memory is nearly free at inference — a summarization call here, a retrieval lookup there, all host-side. Agentic memory spends turns: every remember and recall is a tool-call round-trip the model pays for in latency and tokens. Sometimes that's worth it; sometimes the model burns three turns storing things it never needed.
How it fails
Managed memory fails silently and uniformly: if your summarizer drops a key fact, every request loses it the same way — predictable, debuggable. Agentic memory fails per-trajectory: a strong model curates beautifully; a weaker one forgets to write the thing it later needs. The failure mode is entangled with model skill.
There is no universally correct choice here, and that's exactly the point. The right paradigm depends on the task, the model, and how you weigh cost against reliability.
So don't choose — evolve it
AutoAW evolves multi-agent workflows with Genetic Programming. Every architectural decision we'd otherwise make by hand — topology, delegation pattern, which agent holds which tool — is encoded as a gene and subjected to selection pressure against a benchmark. Memory is just another one of those decisions.
Each agent in a gene already carried a memory slot with four managed strategies:
stateless— full history, no curationbuffer— sliding window of the last N exchangessummary— an LLM-compressed running summaryvector— ephemeral semantic retrieval over dropped turns
Adding the agentic paradigm turned out to be almost anticlimactic. We added a fifth value to that same slot — agentic — wired so that when an agent carries it, the runner injects remember and recall tools into that agent's tool set and serves the calls from an in-run note store. The mutation operator that already flips agents between the four managed strategies now reaches the fifth for free.
The choice between “the host remembers” and “the agent remembers” is no longer ours to make up front. It's a single enum on a gene, and the population discovers which value wins on a given benchmark — alongside everything else it's tuning.
Why evolution is the right judge
You could try to settle this with intuition or a one-off A/B test. But memory doesn't live in isolation — its value depends on the topology around it. A sliding-window buffer that's fatal for a single long conversation might be ideal for a fan-out of short, independent specialist calls. Agentic recall might pay for itself on a multi-step retail task with many entities to track, and be pure overhead on a one-shot classification.
Because fitness in AutoAW is a weighted blend of quality, cost, and latency, the loop weighs the paradigms honestly. Agentic memory's extra tool-call turns show up as real latency and token cost in the fitness score. If those turns don't buy enough quality, selection culls them — no hand-wringing required. If they do, the gene rises. The trade-off we'd normally argue about in a design doc gets measured.
the task is cost-sensitive, the model is small or unreliable at tool use, or the relevant context is predictable enough that a fixed compaction rule captures it.
the task spans many entities and decisions, the model is a capable tool-user, and selective recall beats summarizing-everything — worth its turns in quality.
Making the invisible visible
One quiet advantage of treating memory as a first-class trait is observability. For every evaluated row, AutoAW now records a per-row memory snapshot: for managed strategies, how many rounds were compacted and the running summary that replaced them; for agentic memory, how many times the agent reached for the tools and exactly what it chose to store.
That last part is the interesting one. Managed memory shows you what the host did. Agentic memory shows you what the model believed was worth remembering — a small window into its strategy. Seeing both side by side, across a population, is how you build intuition for which paradigm a task actually wants.
The broader bet
We keep returning to the same conviction: the interesting questions in agent design are rarely “which option is best” — they're “which option is best here.” Memory tools versus managed context isn't a debate to win once. It's a knob, and different tasks want it set differently. The job of an architecture-search system is to find that setting, not to enshrine a default.
Managed and agentic memory now compete inside the same evolutionary loop, graded by the same fitness function, on the same benchmarks. Whichever one wins, it won because it earned it — and we got to watch.
Have a take?
Tell us where your task distribution falls on the managed-vs-agentic line.