Markdown Isn't Memory. Memory Isn't Direction.
There are two ways people try to give their AI tools context today, and both are wrong in the same way.
The first is a stored-memory platform — Mem0, Zep, Letta, LangMem. You talk, it extracts, it embeds, it stashes the result in a database. Next session, it searches that database and staples whatever comes back onto your prompt.
The second is a file you maintain by hand — CLAUDE.md, .cursorrules, a docs/context.md you keep meaning to update. You write down what the AI should know, and every session, the tool loads the whole thing.
One is automated and one is manual. One uses vectors and one uses bullet points. They look like opposite approaches to the same problem. They aren’t. They’re the same approach wearing two costumes — and the approach is the problem.
Both of them are static memory. Both treat “give the AI context” as “store facts, then hand them back.” And handing a model a pile of remembered facts is not the same thing as directing the model to do the work. Recall is not intelligence. It never was.
The stored-memory version of the mistake
Give the memory platforms their due. The engineering is real and the funding is real. Mem0 grew its API calls from 35 million to 186 million in two quarters and has over 100,000 developers on the platform. Zep published research on its temporal knowledge graph and open-sourced the underlying library. Letta spun out of Berkeley with the MemGPT paper behind it. LangMem ships a clean three-type memory model straight from LangChain. These are not amateurs.
But look at what every one of them actually does when a request arrives: it searches a store for things related to your request, and returns them. Mem0 pulls back roughly 1,764 tokens of semantically similar memory per conversation. Zep traverses its graph. LangMem consolidates episodes. Different mechanisms, identical shape — similarity in, related-stuff out.
Related is not the same as needed.
A code review and a brainstorm can look semantically identical to a vector search and require completely different context. Similarity retrieval can’t tell them apart, because it never asked what the request was before it went looking. It matched, it returned, it padded your prompt, and it left the hard part — figuring out what any of that means for the task at hand — to the model, at runtime, in the most expensive part of your stack.
That’s the ceiling on the entire category. We’ve made the argument at length before: store-and-retrieve is a filing cabinet, and a filing cabinet doesn’t get smarter no matter how much you put in it. But at least the filing cabinet is trying to stay current. The hand-maintained file isn’t even doing that.
The markdown version is worse
A CLAUDE.md file feels like the responsible, in-your-control alternative. No third-party extraction pipeline, no cloud database, no vendor. Just you, writing down what your AI should know, in plain text you can read and edit. What could be more honest than that?
Here’s what. That file has four failure modes baked in, and you can’t patch any of them by writing a better file.
It drifts. The moment you write a line in a context file, it starts aging. You refactored the auth module last week; the file still describes the old one. You changed your deploy process in March; the file still swears by the February version. The code moved and the file didn’t, because nothing forced it to. Static context doesn’t decay gracefully — it decays silently, and you don’t find out until the model confidently does the wrong thing based on it.
It lies. This is drift’s consequence, and it’s the dangerous one. A stale context file doesn’t announce that it’s stale. It presents three-week-old assumptions with exactly the same authority as today’s truth. The model can’t tell the difference — it has no way to know that line 40 was accurate when you wrote it and became false on Tuesday. So it trusts all of it equally, and now your “source of truth” is confidently feeding the model fiction. A file that lies with a straight face is worse than no file at all, because it costs you the time to write it and the time to debug what it broke.
It dumps. Your context file has no idea what you’re about to ask. So it hands over everything, every time. Your entire coding-standards section loads whether you’re fixing a typo or designing a system. Your deployment runbook loads when you’re writing a unit test. It’s the opposite of just-in-time — it’s just-in-case, all of it, every turn, whether the task needs one line of it or none. Every irrelevant line is context the model has to read, weigh, and reason around before it can get to your actual question.
It’s yours to maintain, forever. The file never updates itself. Every convention you add, every decision you make, every thing that changes — you have to go back and hand-edit the file, or it rots. You’ve volunteered to be a human ETL pipeline for your own context, in perpetuity, for a document that will still be wrong the moment you look away. The stored-memory platforms at least automated the writing. The markdown approach automates nothing and hands you the bill.
Automated-but-blind or manual-but-rotting. Those are your two options if context means “a snapshot you store and reload.” Neither one is direction. Both are just different ways to be confidently out of date.
Direction is the opposite of a snapshot
The fix isn’t a better store or a better-maintained file. It’s to stop treating context as a thing you keep and start treating it as a thing you produce, per request.
That’s what Anneal does. Memory remembers; Anneal directs — and the difference is the whole product. Before the model runs, Anneal reads the incoming request for what it actually is: what kind of work this is, how much effort it deserves, which of your tools and standards it touches. Then it engineers the context for that request, on the fly — assembling exactly what this turn needs, fresh, instead of reloading a frozen file or dumping back everything that happened to match.
Follow that through against the four failure modes, and every one of them inverts:
- It can’t drift, because nothing is stored to go stale — the context is built from your current state at the moment you ask, not from a snapshot of last month.
- It can’t lie about being current, because it isn’t reciting a saved document; it’s reading what’s true now and delivering that.
- It can’t dump, because it decided what the request needed before it assembled anything — a typo fix gets a typo fix’s context, not your entire rulebook.
- You don’t maintain it, because there’s no static artifact to maintain. The system does the classifying and delivering; you do your work.
And it enforces, which a file can never do. A CLAUDE.md line that says “always run the linter” is a wish — it sits there hoping the model reads it and complies. Direction makes your standards part of the loop the request runs through, checked before the work ships, not stapled to the top of a prompt and forgotten by turn three.
There’s a compounding piece too, and it’s the part no static approach can touch: when Anneal reads a request wrong, that becomes a signal, and the next one lands closer. Your context file has no such loop — it is exactly as smart on its thousandth load as its first, and it gets that way only if you keep editing it. Direction gets sharper on its own, because it’s learning the shape of how you actually work instead of accumulating a bigger pile to reload. (Under the hood, Anneal runs on grāmatr’s intelligence layer — but that’s plumbing you never have to think about.)
The tell
Here’s the question that sorts the whole field. When you send a request, does your setup decide what this specific request needs — before it goes looking for anything?
A vector store doesn’t. It matches first and thinks never. A markdown file doesn’t. It was written weeks ago and loads the same regardless. Both answer your question the same way they’d answer any other, because to both of them every request looks identical: an excuse to hand back what they already had lying around.
Stored memory and hand-maintained context are not two problems. They’re one bet — that the past, frozen and reloaded, is good enough to run the present on. It isn’t, and the tax compounds every turn, across every session, in every tool you touch: Claude Code, Codex, Gemini, the assistant in your editor.
Markdown isn’t memory. Memory isn’t direction. And direction — context engineered per request, current by construction, enforcing your standards, getting sharper every time — is the only one of the three that was ever going to make your AI better.
Stop maintaining the file. Stop growing the store. Start directing the model.