You’ve probably felt that drop in your stomach when your AI agent confidently does exactly the wrong thing. You ask it why it made that decision, and you get a shrug wrapped in API tokens. It hallucinated a fact, forgot a constraint, or invented a user preference out of thin air.
We’ve been told this is a complexity problem. The models aren’t smart enough yet, so we need to pump them with more data, better RAG pipelines, and infinitely complex vector databases. But we’re looking at this entirely backward.
A black box isn’t a feature; it’s an unpatched liability.
The industry is obsessed with making agents smarter, but the actual bottleneck has nothing to do with intelligence. It has to do with memory. Specifically, how agents remember, revise, and forget. Right now, we’re hiding that process inside opaque model states and high-dimensional vector embeddings. You can’t read a vector embedding. You can’t edit a hidden state. When the agent goes off the rails, you can’t open the hood and fix it. You just hit regenerate and pray.
Cal Paterson recently pointed out a brutally simple alternative: treat agent memory as a file format. Just use Markdown.
It sounds almost insulting, doesn’t it? You’re building a cutting-edge autonomous agent, and the suggestion is to give it the digital equivalent of a sticky note. But the more intelligent and autonomous agents get, the more mundane their memory substrate needs to be.
The smarter the agent, the dumber its memory needs to be.
If an agent’s memory lives in a static, boring plain-text file, everything changes. The AI’s behavior suddenly becomes auditable. You can open the file. You can read what the agent thinks it knows. You can delete the hallucinations. You can rewrite the bad logic. You can commit it to Git and track exactly when the agent learned a new concept.
Most teams focus on smart retrieval—how to pull the right chunk of data out of a massive vector database. But retrieval isn’t the real problem. The real problem is editorial judgment. What gets written into memory in the first place? What gets revised? And most importantly, what gets deliberately forgotten?
Vector databases are terrible at forgetting. They just pile up context until the agent is drowning in conflicting noise. A file format turns memory into an editorial process. The agent has to decide what is worth writing down, what is no longer relevant, and what needs to be updated. It stops being a vector-search problem and becomes a version-control problem.
Even OpenAI is quietly leaning into this. Their new agent memory spec essentially treats memory as file names. It’s low-fi. It’s static. And it works because it forces clarity.
When you strip away the complexity, you get control. The uneasy feeling of trusting a black-box AI is instantly relieved when its memory becomes something you can open in Notepad, inspect, and correct. You aren’t just relying on the model’s weights; you’re relying on a readable, editable narrative.
If you can’t open your agent’s memory in a text editor, you don’t actually control your agent.
We want AI to feel like persistent cognition, but persistent cognition doesn’t require a magical, invisible brain state. It requires a boring, well-maintained ledger. The magic isn’t in the opacity of the memory; it’s in the transparency.
The next time your agent hallucinates, don’t re-tune your embeddings or tweak your cosine similarity thresholds. Open a text file, delete the lie, and write the truth. That’s how you build trust. That’s how you build software that actually works.
FAQ
Q: Isn't plain text too slow and unstructured for complex AI tasks?
A: No. The bottleneck isn't read speed; it's context accuracy. If an agent reads the wrong hallucinated memory from a vector database, speed doesn't matter. Plain text forces clarity and editorial discipline over volume.
Q: How do I implement this without breaking my current stack?
A: Stop routing all memory through a vector DB. Start writing session summaries to local Markdown files that the agent can read and edit. Treat your agent's memory like a Git repository, not a search index.
Q: So we're just going backwards to flat files instead of advanced databases?
A: Yes. The most advanced cognitive systems on earth rely on messy, editable narratives. We are regressing to flat files because structured databases are too rigid to handle the nuance of evolving context and deliberate forgetting.