Peers, Not Owners

The dispatch tool had one job: let two coding agents hand work to each other. On live inspection of its actual schema, it turned out only one of them was allowed to start a handoff.

That was the near-miss this chapter is about. A month ago, Claude Code and Codex, two coding agents run by the same operator, had no shared operating contract at all. Today a single eight-rule doctrine governs both, adopted in one canonical location, with one-line pointers from each agent's own configuration, never copies. The pointer detail matters more than it looks: a copy is a fork waiting to happen, and a fork in the operating contract is two contracts. But before the doctrine could exist, the obvious plan had to fail, and it failed in an instructive way.

The tool that was quietly a hierarchy

When you want two agents to hand work to each other cleanly, the natural move is to reach for the dedicated handoff tool they already share. There was one. It had "handoff" in its purpose. The plan wrote itself.

Live verification of the tool's actual schema, not its description, found it was not a peer surface. Authoring a handoff through it was gated to one specific caller: neither Claude Code nor Codex could author a peer handoff through it. Pickup was asymmetric too. One agent could confirm and take a handoff; the other was refused until promoted to a higher trust level. These are stated plainly because they are trust-model facts, not comedy: the tool encoded a hierarchy, and the gates were doing exactly what its security model intended them to do.

Which framed the choice. Re-engineering the trust model to make the tool symmetric was rejected: it fights the system's own security model, and the cost is high. You do not casually loosen caller gates on shared infrastructure because a coordination scheme would find it convenient.

Instead, the search turned to what was already symmetric. And there it was, in constant daily use, with no caller gate at all: general activity logging, log_activity and its siblings. Any agent could write; any agent could read. On the same day this was checked, Codex alone had written 8 activity-log entries carrying branch names in a single work window. The peer surface was not waiting to be built. It was already carrying traffic.

The reconciled contract fell out of that: a peer handoff is the git branch as the lock, plus a symmetric activity-log receipt, deliberately routed away from the gated, asymmetric dispatch tool. Not routed around in protest. Routed away on the merits, because a handoff surface where one party cannot author and one party cannot pick up is a hierarchy wearing a handoff costume.

Eight rules

The doctrine that formalized this runs to eight rules:

1. Peers, not owners.
2. One task, one writer.
3. The workspace (a branch) is the lease.
4. Declare before you write (run the preflight).
5. Prove what you did (the receipt).
6. Takeover is snapshot-first and ack-free (no live holder required to release).
7. Ceremony scales with blast radius (a single-file edit needs none; shared-state work needs the full ritual).
8. Preserve first, fix second (rescue a reference before any recovery move; never reset a shared ref).

A few of these deserve the long way around.

Rule 3 is the load-bearing engineering decision. There is no lease database, no lock files, no expiry daemon. The lock is a branch that either exists on origin or does not, and the descriptor rides a plain 8-line receipt. Both artifacts already existed. Every coordination platform you decline to build is a platform you never have to debug at two in the morning, and git was already running a perfectly good distributed consensus service under the name "push."

Rule 6 is the one that makes takeover survivable. Ack-free means no live holder is required to release the lease: if the previous writer is gone, crashed, or simply done, the next writer proceeds from a snapshot rather than waiting on a ghost to say goodbye. Rule 8 is its safety companion: preserve first, fix second, rescue a reference before any recovery move, never reset a shared ref. Together they say that recovery is allowed to be unilateral but never allowed to be destructive.

Rule 7 keeps the whole thing livable. A single-file edit needs no ceremony at all; shared-state work needs the full ritual. Doctrines that demand maximum ceremony for minimum stakes get ignored, and doctrines that get ignored are decoration.

And Rule 1 gives the chapter its title, because it names the failure mode the dispatch tool had already demonstrated. More on that after the pilot, because the pilot is where the rule earned its position at the top of the list.

Three tasks, two directions, one refusal

Doctrine on paper is prose. The pilot was a live, operator-mediated drill in a disposable sandbox, three tasks, designed to prove symmetry with bytes.

Task 1 ran Codex to Claude Code: Claude Code took over from a 5-field receipt alone, zero questions, and the diff matched exactly. Task 2 ran the other direction, Claude Code to Codex: Codex took over from the receipt alone, zero questions, verified clean. Task 5 was a deliberate collision: Claude Code preflighted clean and claimed the lease; Codex preflighted, saw the occupied branch, and refused. The filesystem confirmed a single writer and no divergent branch.

Task 5 is the harder technical claim, that a branch-as-lease actually stops a second writer, and the receipt, not a claim about the receipt, is what proved it. But tasks 1 and 2 are the real proof of the doctrine's first rule, and here is why. Same ceremony, same zero friction, both directions. A hierarchy would show one direction needing more ritual: more questions asked, more context demanded, more deference performed by whichever party sits lower. The drill showed none.

This is the first governance thesis, and it has a life well beyond agent tooling. Symmetric ritual is how peers stay peers. Any two-party system that starts equal, teams, partnerships, co-founders, drifts toward hierarchy through asymmetric ceremony unless the ritual is symmetric by construction. Nobody votes for the drift. It accretes: one party starts writing the summaries, so the other starts waiting for them. One party's requests need justification and the other's do not. Each asymmetry is small, locally reasonable, and directional, and the direction compounds. The dispatch tool was the same drift already fossilized into a schema: author-gated to one caller, pickup gated by trust level. Nobody designed it as an org chart, but an org chart is what the gates drew. The doctrine's answer is structural rather than aspirational: it makes the ceremony identical by construction, receipt in, receipt out, same preflight, same refusal rules, so that equality is a property of the mechanism instead of a property of everyone's ongoing good behavior. Mechanisms hold under load. Good behavior, as the receipt layer will demonstrate shortly, does not.

A sibling chapter, "Two Harnesses, One Floor," covers whether two harnesses enforce the same safety floor. Parity is the floor; this chapter is the handshake, and the two are separable on purpose: agents can share a floor and still coordinate badly, or coordinate beautifully atop mismatched floors.

The gap that named itself

The pilot's own disposition refused to call itself clean, which is the correct posture for a disposition and rarer than it should be. Task 5's collision had run in a shared working tree: Codex could see Claude Code's checked-out branch directly, which is easy-mode detection. The harder realistic case for automation, two agents in separate clones each creating the same task branch before either pushes, was flagged as undrilled, and automation was gated on drilling it.

The drill ran the next day on a disposable rig: a bare origin plus two clones, base branch named trunk to dodge a push-to-main guard. It reproduced the gap exactly. Without a git fetch, a second clone's local branch creation does not collide. It succeeds silently. The collision surfaces only at push time as a non-fast-forward, and at that moment git's own hint suggests pull or --force, both of which would corrupt the one-writer invariant. The tool's most helpful message, offered at the worst possible moment, lists the two ways to destroy the thing you were protecting.

With a mandatory fetch plus a remote-lease check before any write, the outcome inverts: the second agent detects the held branch and refuses cleanly, zero divergent work. So the preflight step was rewritten, from "fetch if another agent may hold it" to "fetch, always, mandatory." The old wording was a judgment call, and the judgment it required was impossible: you cannot know whether a branch is held without checking, which means the condition could only be evaluated by doing the thing it was deciding whether to do. The new wording is a machine-checkable rule, and machine-checkable is the property everything in this chapter keeps converging on.

From ritual to program

Convergence arrived on schedule. Enforcement became executable primitives, not disciplinary prose, in a small published repo of enforcement primitives: a shell preflight gate and a Python dispatcher.

The gate compresses the preflight into a single check, fetch, remote-lease check, local-lease check, dirty-tree check, returning one of three verdicts: CLAIM, REFUSE, or ERROR. An agent no longer interprets the doctrine; it runs the gate and obeys a one-word answer.

The dispatcher runs the gate before any agent writes, in one of two modes. Relay, the default, prints an operator-facing dispatch packet and stays human-mediated. Spawn launches the writer directly, then verifies completion on the git bytes, commits ahead of base and pushed to origin, and never trusts the agent's exit code. That last clause is not generic paranoia. It encodes a specific lesson from the same month: a stranded handoff once reported itself "completed" while its work sat uncommitted and unreceipted. The dispatcher treats that exact failure as a first-class branch of its state machine, which is the difference between a lesson learned and a lesson filed.

The receipt layer bends

Then the doctrine's proof rule met real execution volume: receipts slipped on three of the last five handoffs, including two where the spec explicitly demanded one. The work was real, but the proof layer held only about 60% of the time under load, so the response could not be another louder reminder. The same week, the rule moved from norm to instrument: a harness-scorecard check now grades, without blocking, any peer-agent branch that is commits-ahead of main with no matching receipt, and it immediately found other unreceipted branches. Peers stay peers because the ritual is symmetric; rules stay rules because a machine reads them.

The short version → The Coordination Platform You Don't Need