When Multiple Agents Write, Start by Separating Their Worlds

Separate write worlds first; reconciliation is explicit.

The easy mistake in multi-agent work is to assume that agents can safely share one mutable directory and then patch conflicts afterward. A better starting point is to give each agent an explicit namespace, make writes traceable, and use evaluators or reconciliation to decide shared state.

Karim C asked a practical question:

“File system metaphor is clean. How do you handle context drift when multiple agents write to the same 'directory'?”

The core of my answer was that each agent should keep its own namespace and leave an append-only record with provenance. Agents write intent first; an evaluator or reconciliation process with explicit grounds decides shared state.

If I reduce it to one line:

“they write intent, and the system reconciles.”

A short reply was all I had space for. Here is what I meant.

A shared directory is not a collaboration protocol

A directory is a useful resource abstraction. It is not a concurrency protocol. Pointing several agents at one mutable location assumes that they share an understanding of state, write in the right order, and make the same judgment when their work conflicts. In practice, none of those assumptions is safe.

The first question is therefore what each agent needs to see and write. A per-agent namespace gives each agent an explicitly projected resource world. It does not need to know the entire global state, and it does not receive a default right to alter another agent's work.

That is compatible with AFS's Small World principle: express the resource boundary before a violation or collision forces us to guess it. Small World is not a concurrency-control algorithm. It clarifies what an observer can see. Treating that boundary as if it also solved reconciliation would obscure both jobs.

Write intent before deciding state

Agents seldom need to edit the same file in the way several people edit one document. More often, they produce intent: what they found, what they propose, why they propose it, and which task or resource is affected.

An append-only record of that intent preserves provenance and order. A later evaluator or reconciliation process can examine which agent made a change, from which input, and at what stage, rather than face only an overwritten final state.

That does not make conflicts disappear. Two intents may contradict one another or depend on stale context. The benefit is that the disagreement is moved to a visible decision point: the party that must reconcile it has evidence to inspect, rather than letting the final write silently win.

An evaluator is not a universal judge

An evaluator might be an agent. Its job is narrower: consolidate state against explicit rules, evidence, and the current objective. It should not pretend to produce a permanently correct answer for every other agent.

Human review gates still belong in high-risk changes or work whose rules are not yet clear. Namespaces, traceable records, and reconciliation reduce and clarify what a person must judge. They do not promise to remove the person.

This is how I think collaborative state should be organized. The AFS paper is concerned with the same class of context-engineering questions. It does not claim that every form of multi-agent conflict, evaluator design, or review workflow has a universal answer.

My point is simple: do not let multiple agents pretend that they are editing one shared truth. Separate their worlds, retain their intent, then decide what becomes shared state.

Further reading