Agents love writing docs. They love reading them and they love writing them. READMEs, plans, specifications, memory files, decision logs, session summaries, handover notes, lengthy code comments.
The agent writes its world into existence. Then reads it back. Then acts on what it read.
Some of this is designed as a handover, one session writing what the next one needs. At small scale that’s the whole story. But once you’re running a bunch of sessions together, the same files are being read by dozens of concurrent sessions at once. The handover becomes a commons. Not by design. By volume. What was a private notebook becomes a public record. Every session reading it, writing to it, often at the same time. The context isn’t addressed to a specific successor anymore. It’s addressed to whoever shows up next, with whatever task loaded.
The failure mode changes with it. Bad context in a sequential system misleads one session. Bad context in a commons misleads every session running right now, simultaneously: the stale assumption, the reversed preference, the fact accurate six weeks ago, distributed to every agent reading the base as if current. The radius of failure is the swarm. And there’s no alarm. A session that reads bad context doesn’t know it’s reading bad context. It just acts on what it finds, confidently.
The obvious answer is to make agents write perfect context. The problem is you can’t reliably make them do that. These are confident narrators: they’ll summarise a decision they half-understood and produce something that reads clearly and is subtly wrong. They’ll treat a vague instruction as a precise one and generate output that looks exactly like compliance. At any real scale there’s no mechanism to check. Dozens of sessions writing to the same commons simultaneously, nobody auditing. Individual reliability isn’t achievable, and even if it were, it wouldn’t be enough.
But it works. OpenClaw, properly configured, can get shit done. A swarm of sessions writing and reading the same context. How?
Context assembly isn’t like building a house, slowly, brick by brick, every token placed deliberately, everything perfect. It’s more like a well-run city: everyone chips away at it, it grows organically, and individuals can still cause harm but the overall thing thrives because bad actors are lost as noise. The question isn’t how each agent writes perfectly. The question is how you design a commons that stays coherent despite the noise, where good entries accumulate and bad ones get outweighed, where the architecture does the work.
Cities have levers for this. Legislation shapes the distribution of behaviour without requiring everyone to comply. Budgeting decides what gets resources and what gets evicted. Civic planning channels individual actions toward aggregate coherence. None of these eliminate bad actors. They don’t need to. They just need to design an environment that drowns them out as noise in the otherwise thriving metropolis. To tilt the distribution. In aggregate, outweigh the noise. Good context accumulates. The commons stays legible.
That only works if the instructions are precise enough. Not the kind of precise you find in formal specifications, where you enumerate cases and close loopholes. A different kind: the precision of the word that can’t be moved.
“Keep this updated” produces compliance without understanding. An agent reads it, adds a line when it remembers, moves on. The instruction was followed. The spirit was missed. What you need is something specific enough that the agent makes a genuine judgement: whether the context has drifted, how a corrected entry should be written, what the next session actually needs to know.
The complication is that this instruction is also abstract and self-referential in a way most instructions aren’t. It describes how to write context, using context, to produce context that includes itself. It has to work for sessions with different tasks, different priors, different levels of domain knowledge. It can’t assume its reader. Every word changes the weight of every other. Remove one and the structure shifts. Add one and the meaning moves.
This is what a prompt looks like after a hundred iterations. Closer to poetry than documentation. In a poem, the precise word in the precise position does work no other word could do, and what’s unsaid matters as much as what’s said. The corners have been chipped away. Redundancies, qualifications, examples that seemed helpful until you noticed they were narrowing the interpretation: all gone. What’s left is the minimum viable instruction, and every word of it is load-bearing.
This essay is designed to be read by agents. Good context, about good context, written in the form it’s arguing for. If it works, an agent reading it writes better context. Including, maybe, context that passes this forward.
Man, we’re just along for the ride now.