Twenty agents, one workspace, nothing lost.

Fan-out is the reason multi-agent workflows are worth running at all. Twelve agents auditing twelve subsystems finish in the time one takes to do a third of the job. The pattern works — right up to the point where they all need to record what they found.

Send them at a shared file and the arithmetic is unforgiving. Each one reads the file, appends its section, writes the whole thing back. The reads all happen before the writes, so every write is built on a copy that's already stale, and the last one to finish silently erases eleven colleagues' work.

The dangerous part isn't the loss. It's that the file looks fine afterwards. It's well-formed, it has content, and it names a plausible set of findings. You'll notice in a week, when someone asks about the subsystem nobody apparently audited.

The write has to say what it's changing

Markbase gives every document version an ETag, and every read hands it back. When an agent writes, it asserts the ETag it expects to be replacing. If the document still matches, the write lands. If anything changed in between, the write is refused — cleanly, with a stable etag_mismatch code and the current ETag attached.

The refusal is the feature. The agent re-reads the document as it now stands, re-applies its change to the current text, and writes again. That loop is a couple of tool calls and it's the normal path, not an error path — agents handle it without asking anyone.

What the server deliberately never does is merge on the agent's behalf. Rebasing someone's edit onto text they haven't read is how you get a document that's syntactically fine and semantically wrong. The agent gets the current text and decides — with the full contents in front of it — what its change means now.

Better still: don't have the race

Retrying a contended write is a safety net. The stronger move is to design the contention out, and for fan-out that's usually easy: give each agent its own document instead of a shared one.

Make the destination a typed collection — a folder with a _schema.md defining what a finding looks like — and each agent appends a record. Every record is its own file at its own path, so twenty concurrent writers never touch the same bytes and nothing can be lost by construction.

You don't give up the single view to get that. Because the records are typed, the collection queries like a table: every confirmed finding above medium severity, newest first. The summary is something you ask for at the end rather than something twenty agents fight over while they work.

Then the shared document is one writer's job

The pattern that falls out: the fleet appends records, and a single agent reads the collection afterwards and writes the one summary document a human will actually read. Fan out to collect, fan in to conclude. Exactly one writer touches the shared doc, and the race is gone rather than survived.

Where a shared document genuinely is the right shape — a running plan several agents update as they go — anchored writes hold the line, and the version history means an end state you didn't expect is something you can read backwards rather than guess at.