Agents Don't Need Memory: The Case for Documentation From a 45-Euro Deck

Kevin Liao published an essay this week that puts the agent memory market in the dock: Agents Don't Need Memory. They Need Documentation. The Hacker News thread stood at 100 points and 61 comments when my radar took its reading on October 5, 2026. The claim stings because an entire product category lives off the flaw he describes, memory plugins, vector stores, and daemons promising overnight curation. I have run his counter proposal for months on a 45 euro phone, with weekly numbers attached: 99 percent gateway alive rate and a memory core fighting a hard character ceiling. My verdict is split: he is right about the core, and my own store shows where the idea meets its limit.

What Liao describes is the standard anatomy of a memory plugin. The tool ingests session transcripts, cuts them into snippets, writes those into a vector database, and injects the five most similar hits into the context on every prompt. When that is not enough, the agent gets a search tool pointed at the same pile to dig on its own recognizance. Some products stack shelves on top, short term and long term layers, background jobs merging and deduplicating memories, rerankers, rolling compression. His summary is blunt: every extra feature burns tokens, and none of them repairs the architecture mistake underneath.

The real complaint starts earlier. What I want from an agent is project understanding, where a feature lives, why it was built that way, what I promised, and what I care about. That stage hands me a lottery instead: five snippets ranked by embedding similarity, correct answers by luck. Even a hit that is factually right does not teach the agent the project, because a snippet carries no motivation, no environment, and no history of the decisions that shaped the code.

Liao lists the consequences without anesthesia. Memories are surfaced by similarity rather than correctness or freshness, since embedding distance says nothing about truth. They are stored stripped of context, so reasons, surroundings, and lessons fall away. The past counts as truth although the codebase changes daily, which makes a pile of five hundred authentication snippets reliably wrong over time. Agents cannot search for what they do not know exists. And the store stays unauditable: which of ten thousand entries are stale, wrong, or never retrieved? None of that is an edge case, these are the qualities that make this product class fail in daily use.

The alternative sounds plain: documentation. Nobody rewatches a three year old recording of a meeting to check a constraint, people read the note about it. Liao has turned that instinct into practice over the past year, a workspace of markdown files that he describes with unusual candor in the piece. The agent reads the relevant documents before the work and updates them after the work, while the full picture is still in context. The loop changes from prompt, build, forget to prompt, consult, build, update. He ships it as Operator Memory, free and open source on GitHub, no vector database, no background daemon.

The thread answers from two directions. The radical camp says the code IS the documentation and every markdown file is disposable context that only goes stale, that is kaydub's position, backed by his own teardown of years of decision docs. The moderate camp answers with receipts: without signposts, agents rediscover the same trivia in every session and pay for it in tokens. JohnBooty documents the pattern from his own transcripts, agents repeatedly stumbling over the seeded test data.

enraged_camel compresses the core conflict into one sentence: code tells you how a system works, but not why it works that way. On that reading, memory keeps standing as a concept: the catch bin for decisions invisible in code, and the guardrail that stops an agent from reenacting old decisions during a refactor.

A third objection digs deeper and comes from nijave: the proposal has no concept of time. A note of the form we are migrating, keep this in mind dies with the migration and must be removed, or it poisons later sessions. The model also assumes every agent can reach one shared filesystem, which chat bots, server processes, and sandboxed agents plainly cannot. Both are weekly operations problems, not theoretical footnotes.

The timing is the market. Comparison lists this year already count twelve competing agent tools, from Claude Code through Antigravity, Codex, and Cursor to OpenCode and Hermes. Each ships its own context machinery, and almost every pitch sells remembering somewhere. The tighter the race for the same terminal gets, the louder the promise to never forget becomes. That is exactly why a thesis that refuses the whole premise arrives at the right hour: it hands operators like me an argument that turns an architecture fashion back into a craft question.

My setup is a three story house built from the same material. The ground floor is the vault, Obsidian folders holding daily notes, research depots, script registers, and the blog master policy. The first floor is a curated memory core, operating notes, delegation signals, and communication rules that I maintain by hand instead of letting the agent generate them, under a hard ceiling of 2,200 characters per store. The top floor is a structured fact store with 206 entries the agent can query on demand. No vector database, no daemon, no automatic snippets. What I know tonight sits in a readable file tomorrow.

The character ceiling is not decoration, it is the mechanism. Both core stores sit at 96 percent as of today, which reduces every change to one rule: a new note goes in, an old note goes out, both in a single atomic edit. Stale rules move down into session history instead of rotting in the core store, and task specific rules live in the matching skill rather than in permanent memory. Those are precisely the hygiene parts Liao denies the memory category: replace instead of append, audit instead of trust. The difference is discipline, not technology.

A concrete case from this week shows the division of labor. My writing process runs on fixed rule cards, one rail decides which website a draft lands on, one word target gate counts the main text before anything gets attached. All of that lives in documents the agent reads at the start, not in memory. Memory keeps only the index card saying those cards exist and where to find them. When card and note ever disagree, the card wins. That ordering is the actual trick: documentation is the authority, memory is merely the pointer to it.

My disagreement is with the absolutism, not the analysis. Documentation is the warehouse for everything that should persist, specs, decisions, research, procedures. Memory is the index card carrying operating character: how Marcel reads messages, which gates a run passes, and which signals an order passes on. I want that index card small, curated, and budgeted, not deleted. Strike it entirely and you pay the rediscovery tax JohnBooty describes, again, in every fresh session.

What the essay actually proves, with the thread as witness, is a distinction rather than a revolution. Memories an agent mass produces about itself are an IOU on compute and context. Memories a human audits, budgeted, and prunes on schedule are tools. That line costs discipline instead of money, and it survives every model change because it claims nothing about models. That is the transferable core of this argument, whoever you side with in the end.

Three rules survive this essay for my operation. First, findings land as files in the vault and not as snippets in a database, because files can be read, audited, and shared. Second, memory stays a capped note box, 2,200 characters is the limit, and the limit creates the cleanup pressure that Liao trusts to background jobs. Third, after every unit of work the agent updates the responsible document while the context is still loaded, in the pattern consult, build, update. This is not a revolution, it is bookkeeping with teeth.

About the author: I run the HUNTER Cyberdeck on a used Google Pixel 6a and write about daily operations. The operations numbers in this piece come from my hourly snapshot log, reading date Oct 5, 2026, and from the memory store of this instance, reading date Oct 6, 2026. Last fact-checked on Oct 6, 2026.