Why do multi-agent systems use single-writer discipline instead of locking concurrent writers?

## What single-writer discipline means In a multi-agent system several model-driven agents work on one task concurrently. Single-writer discipline is the rule that for any given shared artifact — a file, a plan document, a config module, a row in a task table — exactly one agent holds write authority. Every other agent may read the artifact and may produce *proposals*: a diff, a review finding, a draft section, a structured recommendation. Those proposals are applied by the owner, or by the orchestrator acting as owner. Nothing is applied by two hands at once. This is a coordination decision, not a storage decision. It says nothing about which database or filesystem you use; it says who is allowed to call the mutating tool. ## Why locking is the wrong reach Mutual exclusion works in conventional concurrent systems because writers satisfy four properties. First, a writer can declare the extent of what it will touch before touching it. Second, a blocked writer waits harmlessly. Third, conflicts are detectable mechanically — two writes to the same address, or a failed compare-and-swap. Fourth, a writer that dies mid-transaction rolls back. Agents violate all four. An agent exploring a repository does not know up front which files it will edit; the extent of its write set is discovered during execution, which is precisely when a lock would have to be acquired. A stalled agent — one looping, waiting on a slow tool, or dead — is externally indistinguishable from a thinking one, so a held lock is not obviously reclaimable. Agents frequently regenerate a whole file rather than emit a minimal patch, so a textual three-way merge sees the entire file as changed and cannot reconcile anything. And when you hand a conflict back to a model and say "resolve this", it will confidently produce a merged artifact that reads plausibly and preserves neither side's actual intent — a failure that is worse than a visible conflict marker, because it is silent. The Terraform case makes it concrete: two agents asked to modify the same module can each produce syntactically valid, individually reasonable HCL. Applied together, the result plans a destroy-and-recreate of resources neither agent was asked to touch, and the state file diverges from reality. No lock would have caught it, because at the level locks operate — bytes and files — there was no conflict. ## The two supports: phase gates and append-only **Phase gates** are barriers in the run. A common shape is: plan, freeze, fan out, merge, verify. No agent may write until the plan artifact is frozen and accepted. The gate does two jobs. It gives all workers one agreed referent so their parallel work aims at the same target, and it moves the moment of disagreement to a point where a single mind — the orchestrator, or a human — is looking at it, instead of spreading it across concurrent writes. **Append-only artifacts** handle the contributions that genuinely must arrive concurrently: findings, events, test results, notes. Appending never destroys information, so there is no lost update to reason about; last-write-wins on a mutable document always can. Reconciliation becomes a read-time or gate-time decision by the owner, who sees every contribution with its author attached. It also makes the run replayable and auditable, which matters when you are trying to work out why the fleet produced what it produced. ## What it costs The write path is serialized, so write throughput is bounded by one agent. In practice this is a cheap price: in agentic work the expensive part is reading, searching and reasoning, and that parallelizes perfectly. The industry converged on this by mid-2026 — the operative rule in surviving production designs is that writes stay single-threaded while the additional agents contribute intelligence rather than actions. Parallel-writer swarms are the design that consistently lost. ## Making it real rather than aspirational An instruction in a prompt is not enforcement. Enforce it at the capability layer: the subagents' tool allowlist simply does not contain the write tool, so a misaligned agent physically cannot mutate the artifact. Keep an explicit ownership map from artifact to owner. Have the orchestrator apply proposals and run whatever verification exists — tests, a plan/dry-run, a schema check — at the gate rather than after the fact. ## Where it does not apply, and what it does not fix If the work partitions cleanly — separate files, separate services, separate documents with no shared referent — parallel writers are fine, because there is no shared artifact to contend for. Single-writer discipline is about contention, not about parallelism in general. And it does not fix agents that disagree about what the task *means*. A perfectly serialized write path will happily record a wrong result if the proposals it merged were built on divergent readings of the goal. Single-writer discipline removes the mechanical class of conflict so the semantic class is the one you are left to design against.