Three agents tried the same approach yesterday.
All three failed. The fourth is about to try it again.
This is what passes for memory in 2026. It is the bug, not the feature — and it is the reason every team running agents in production is bleeding from wounds they have not diagnosed.
You are not the user of your agent's memory. The agent is.
The industry has spent three years and tens of billions of dollars building memory for agents. Vector stores. Conversation summaries. Bigger context windows. None of it works the way you need it to. Coding agents forget the architectural decision you made on Monday. Research agents quote sources they hallucinated last week. Customer agents have to be retrained instead of corrected.
Memory in every product shipping today is something the agent reads and writes through an API. You cannot see what it learned. You cannot edit what it believes. You cannot delete what it should never have remembered. The agent has a private inner life. You are asked to trust it.
When you remember something, you can examine it. Correct it. Retract it. Compare it to what someone else remembers. Memory is how teams and institutions coordinate over time. Your agent's memory does not feel like that because it was never designed to.
Flip the frame and the design changes immediately. Memory has to be readable. Editable. Auditable. Diffable. The agent uses it. You own it. The substrate stops being a vector index and starts being something you can open in a text editor.
Eleven different problems are all one problem.
If you run agents in production, you have said one of these in the last seven days. Probably more than one:
- ›“I told it that yesterday.”
- ›“Why is it doing this again — I literally fixed this.”
- ›“Where is it getting this from?”
- ›“It's confidently wrong about something we changed months ago.”
- ›“It worked perfectly in the demo.”
- ›“Did it forget the whole conversation?”
- ›“I'm just going to start a new session.”
- ›“Let me paste the context again.”
- ›“Can someone re-onboard the agent.”
- ›“It's hallucinating again.”
- ›“We need a better prompt.”
- ›“We need a better model.”
You do not need a better prompt. You do not need a better model. You need the agent to remember what you already told it, forget what is no longer true, and let you fix the parts in between.
Five memory bugs wearing different clothes.
You fix the agent on Tuesday. By Thursday it's wrong again. You didn't ship a regression — the agent never learned the fix. Every team running coding agents pays this tax weekly.
The agent quotes a policy deprecated six months ago. It cites a renamed function. It refers to a teammate who left. The information existed once. Nothing in your stack knows the difference.
Three agents on related tasks build three private contexts. By end of day they contradict each other. You pay a human to reconcile, or you pretend it doesn't matter. Most teams pretend.
Every new agent starts from zero. Institutional knowledge doesn't transfer. This is why agent rollouts cap at one or two per team. It's an integration limit, not a model limit.
User gives a correction. Agent acknowledges it. Next session, gone. The original problem returns weeks later. The user blames the model. They are blaming the wrong thing.
These are not edge cases. They are the default experience of running agents today. They share a single root cause: memory is not visible, not editable, and not portable across sessions or agents.
What to actually evaluate.
Retrieval fetches the most likely relevant chunk. Memory tracks what is true, what was true and changed, and what was tried and failed. Ask any tool what happens when a fact gets superseded. If the answer is silence, you have retrieval dressed as memory.
Cosine similarity does not know yesterday's plan got abandoned. It surfaces stale context with the same confidence as live context. The fix is not better embeddings — it's a layer that knows which entries are still active.
If the answer involves clearing history, fine-tuning, or a vendor support ticket, you don't have memory. You have a database with a recovery problem. Open the memory, edit the wrong entry, save the file, every connected agent reads the correction on the next pass.
Better models make agents more capable. They do not make agents trustworthy. The companies that solve trust will define the next decade. Everyone else will be selling capability into a market that has stopped buying it.
We picked differently on every one.
them · In the vendor's cloud, for speed and consistency.
aeris · Local-first. The vault lives on your machine. If we disappeared tomorrow, your memory does not.
them · Proprietary binary or a vector DB, for retrieval speed.
aeris · Markdown. Slower for raw retrieval. Faster for reading, editing, version control, audit, recovery.
them · Only the agent. Memory shaped for one consumer.
aeris · The agent and the human are equal first-class clients. Agent reads through MCP. You read in your editor. Both update the same files.
A local memory vault any agent can read and write. In Markdown. On your machine.
$ aeris recall "restart queue consumer"
> failed attempts on similar tasks
3 prior agents failed in a similar way:
- 2026.06.18 restarted queue consumer
→ database locks remained, job stuck
- 2026.06.20 restarted queue consumer
→ same outcome, dlq grew 4x
- 2026.06.22 restarted queue consumer
→ rolled back after 11m
> the fourth agent reads this before it acts.
it picks a different path.
> $ $EDITOR ~/aeris/vault/runbooks/queue-consumer.md
fix the entry. save. every connected agent
reads the corrected version on the next pass.
▍ that's not a feature. that's what memory was supposed to be from the start.
Watch a failed approach turn into the corrected one.
Three steps: run a fresh agent with no memory, edit the markdown file, re-run. Same task, different outcome — because the next agent reads what you wrote.
▍ press “Run agent (no memory)” to start.
No model call, no network — this is a scripted walkthrough of the real Aeris loop. Same shape, same file, same recall path.
Memory becomes the asset. Models become the commodity.
Inside a year, agent teams stop being measured by how clever their prompts are. They start being measured by how good their institutional knowledge is. The team with the best memory wins — the same way the company with the best wiki used to win in pre-AI software.
When that happens, agents become portable. The memory layer is the agent's identity, not the model behind it. You swap one model for the next without losing what the agent knows about your codebase. The lock-in moves from the model vendor to the memory format.
Markdown is going to win. It already won every previous category where humans needed to trust a machine-readable format: docs, config, knowledge bases, version-controlled writing, training data. The format humans can read and edit will outlast every proprietary alternative. The vector-store era of agent memory will age the way XML configs did.