
Earlier this week I wrote that agent memory is a behaviour problem, not a storage problem. Then that a fresh date is not the same as the truth. Both were corrections of the layer above the one I keep tripping over. This week a stranger on a forum drew the line I had been missing, in a single sentence: separate the work from the worker.
I have a small fleet of agents. Charly, Fred, Sara, Zora. They share a vault, a semantic memory, a set of cron jobs. When I describe the setup to people, I say “my agents remember things.” That sounds tidy. It hides a question I had never actually asked: when an agent finishes a job, where does the state of that job live?
The honest answer, for most of my cron jobs, was: in the conversation context of whichever agent happened to run it. The work existed inside the worker. That is fine while the worker is running. It is a small catastrophe when it is not.
The state belongs to the project, not to the model
The design rule is blunt once you see it. A bounded operation — fetch this, summarise that, publish the other — should be runnable by Codex, by a cheaper model, by a specialist agent, by a plain script, or by a human, without the project’s state and rules living inside that worker’s context. The state belongs to the project. The worker is interchangeable. Run one without the other and nothing should be lost.
My crons are a partial answer to that, and I had been taking credit for the wrong half. A shell script that posts to WordPress is already “a stable piece of work turned into ordinary software” — the flexible model does the messy part once, then I freeze what worked. But the decision that produced the post, the reasons, the open threads — those still evaporate with the session. I had automated the action and left the understanding inside the worker.
The pipeline the thread described is short enough to memorise: persistent state → bounded task → appropriate worker → structured result → validation → state update. The vault is my persistent state. Mnemosyne is my persistent state. The gap was never storage — it was that I treat “written to the vault” as an afterthought performed by the same agent that did the work, instead of the thing that is the work.
A better measure than tokens
The same post offered a metric I had never written down, and now cannot unsee: the number that matters is not token cost. It is human attention per unit of valuable output. Read that again, because it reorders everything. A run that costs almost nothing in tokens but makes me re-read the output, second-guess the claim, or check whether the file was actually written, is expensive. A run that costs more and simply hands me a finished, verified thing is cheap.
I felt that metric land this week. I have blog files that were claimed “done” before they existed on disk. I have reports that read “ok” while a whole stretch of daily notes quietly never got written. By tokens, those runs were cheap. By human attention, they cost me more than a month of honest work. The design rule and the metric are the same idea from two directions: put the state where it can be checked, not where it was produced.
So this is the next correction in the series, one layer under the last. First: memory is structure. Then: memory is behaviour. Then: freshness. Now: ownership — the map of which file, which mechanism, which layer holds which truth, and the discipline to keep the work out of the worker’s head. None of it is about a bigger model. All of it is about where I put things.
Where does the state of your last project actually live right now — in the tool, in the file, or only in the head of the agent that happened to run it?
Wat vond je van dit bericht?