agent-coherence. Contact us

Blog

Notes from the write side.

Engineering notes on shared state in multi-agent systems — stale reads, lost updates, and what it takes to make agent memory safe to write to.

A planning agent holds plans/migration.md through its third pass, a reviewing agent's write to the file is refused as other_holder with nothing written, and the reviewer goes next once the planner releases the file
shipped · 8 min read

Shipped: Asking for a File Instead of Taking It

In v0.16.0 a writer that opts in is refused a file another agent holds, instead of taking it, and a holder gives the file back when it is done.

A long Claude Code session squeezed into a short summary, with a coordinator handing back the list of files it held and the ones a peer changed
Claude Code · 6 min read

Your Session Compacted, and It Forgot What It Was Holding

After Claude Code compacts a session, the summary can drop which files it held and which ones a peer changed. A hook can hand that record back.

A stateless protocol carrying tool calls, with a coordination layer above it that holds the read version and the single-writer grant
MCP · 6 min read

Where State Coherence Lives When MCP Is Stateless

MCP removed sessions by design and its roadmap names no shared-state work. If the protocol is to be stateless, coherence has to live in the layer above it.

Agents posting HOLD, VETO and owner messages to a shared board, beside a store that records each change of owner and will not allow a late write
multi-agent · 10 min read

A 1,200-Agent Swarm Invented a Lock. It Failed Like One.

A 1,200-agent swarm reinvented locks, votes and successors. Why those primitives break for agents, and what cooperative, non-blocking work and handoff need.

A drafting agent hands plans/rollout.md at version 4 to a named reviewing agent, and the drafter's own later write to the file is refused as handed_off until the handoff ends
shipped · 11 min read

Shipped: Handing a File Off Without Abandoning It

In v0.15.0 an agent can hand a file to a named successor, and on a single host the Python coordinator refuses the giver's own writes until the handoff ends.

Two parallel records of the same agent run, one verified by infrastructure and one narrated by the model, diverging at the point where an agent acted on a version that had moved
agent memory · 6 min read

Your Agent Keeps Two Ledgers. You Read the Wrong One.

One record your infrastructure can verify, one the model narrates. They agree until something goes wrong, and the narrated one is the one you check first.

A workspace checkpoint grading each of its members, some restorable, some restorable but unpinned, and one forward-only that can never be brought back
shipped · 8 min read

Shipped: A Checkpoint That Tells You What It Cannot Restore

v0.14.0 brings workspace checkpoints with per-member honesty, an effect fence on the MCP surface, and a session that re-anchors after compaction.

An output verifier approving an answer while the input view underneath it has already gone stale, the layer no output check examines
verification · 6 min read

Self-Review Can't Catch a Corrupted Question

Your verifier approved a clean answer that was still wrong, because it was the right answer to a stale question. Output checks never look upstream.

Four coordination mechanisms, a lock, a lease, a version check, and a fence, each labeled with the question it answers, and the zombie write slipping past the first three
fencing token · 13 min read

Lock, Lease, or Fence: Which Stops a Zombie Write?

A lock, a lease, and a fencing token answer three different questions. The write your version check passes is the one the fence refuses.

Two paths after a lost update: migrating to a new store repeats the race, while keeping the store and putting the version on the write resolves it with a typed conflict
optimistic concurrency · 6 min read

You Don't Need a New Store. Put the Version on the Write.

When an update vanishes the reflex is a store migration. The store was never the problem. The fix is the version on the write, over the store you already run.

A five-rung ladder of coordination pressure: from one agent and one requester, through stale reads, lost updates, and zombie writes, to the open cross-host rung
multi-agent · 7 min read

What Breaks First When Agents Share a Workspace

The failures arrive in a fixed order as an agent workspace grows: stale reads, then lost updates, then zombie writes. Find your rung and see the next one coming.

Three substrates, a Postgres row, an S3 object, and plain files, each guarded by the same coherence layer, with the coordinator holding versions and hashes but never bytes
BYO substrate · 6 min read

Shipped: coherence over the store you already run

BYO-substrate bindings are live in v0.13.0. CoherentRow guards a Postgres row, CoherentObject guards an S3 object, and the coordinator holds a version, MESI state, and a content hash, never your bytes. A peer's commit marks your cached read stale before you act on it, on a single host, with the same typed conflict and the same reacquire() recovery on every substrate.

Three shipped guarantees, version-CAS, a read fence, and invalidation-deny, each mapped to the failure it stops and the TLA+ invariant that checks it
agent memory · 6 min read

Shipped: a version check and a read fence for agents that share state

The coordination lever is live. Version-CAS, a read-generation fence, and MESI invalidation-deny stop the concurrent lost-update and the sequential stale-read-then-write on a single host, with five TLA+ invariants checking they hold.

Five ways a shared write disappears, mapped to three prevention levers: a durability receipt, a retention policy, and a coordination primitive
agent memory · 11 min read

The Silent-Data-Loss Taxonomy: Five Ways Your Agent's Write Disappears

The vanished write is not one bug. It is a class with five members, and prevention is not one lever. A durability receipt, a retention policy, and a coordination primitive split the five between them, and only the last one is the runtime's to ship.

Two agents write to the same shared record; one update lands, the other silently vanishes
agent memory · 5 min read

The write-side half of agent memory

Thirty agent-memory products describe how agents remember. Not one describes what happens when two writers hit the same key. The lost update is the half that breaks production.