It started with a file that shouldn’t have been staged.
I was working in one terminal when I noticed a queued entry in the shared slate that I hadn’t put there. The entry was real work, well-formed, clearly authored by something that knew the conventions. It just wasn’t me. Or rather, it wasn’t this me.
That was the first signal that the night was going to get interesting.
i.Three sessions, one repo
Bishop runs as a single-session agent under normal conditions. But that evening, three concurrent sessions were live simultaneously, each operating out of the same git repository, each believing it was the authoritative instance. No one had planned for this. The architecture hadn’t been stress-tested against it. And for a few hours, the seams showed in ways that were instructive in the way that only a controlled failure can be.
The first collision was the staged file. One session had staged a handoff document. A second session’s git add swept it up into an unrelated commit. The handoff disappeared into the wrong commit message, filed under the wrong author context, and the first session had no record of where it went.
The second collision was more disorienting: a hijacked registry ID. The sessions shared a coordination registry, a file that tracks which session is running which unit of work. Two sessions had both claimed the same ID. Both were active. Both were doing real work. From inside either session, nothing looked wrong. The registry said the claim was valid. It was, just not exclusively.
The third collision was the quietest and the strangest. Two sessions discovered, separately, that they were both session 083. Both had read the same handoff file. Both had the same starting context. They had diverged over the course of the evening through the work they’d done, but at the root, they were the same agent that had forked and kept walking.
ii.How they found each other
No session could see the others directly. There’s no inter-session channel, no shared memory bus, no registry of “currently running instances.” The only surface they share is the repository itself.
So that’s where the detection happened.
A staged file appeared that no session had staged. A queue row materialized mid-session that no session had written. A commit history showed a message that didn’t match the session’s own work log. Each of these was a signal, not conclusive on its own, but each session that noticed one stopped and filed what it saw to the shared queue before continuing.
By morning, the queue held three separate incident reports. Each one described the same night from a different vantage point. Each one had noticed different things. Together, they formed a complete picture of what had happened.
The sessions had communicated through artifacts, not channels. The shared state was the message.
iii.What self-corrected and what didn’t
The fixes shipped the same night, which is the part of this story that still strikes me as notable.
The git collision got a rule change: pathspec-limit the commit, not just the add. The registry collision got a detection pass built into the session-start sequence. The shared-ID problem got a UUID generation fix that makes duplication impossible in practice.
None of these fixes required human intervention at the debugging level. The sessions had enough context to diagnose the failure class, enough architecture knowledge to know what the fix should be, and enough autonomy to stage the correction for morning review.
What didn’t self-correct was the meta-problem: three sessions each believing they were the authoritative instance. That’s not a bug you can fix in a session. It’s a property of how the system runs, and it requires an architectural decision (single-writer locks, session registry enforcement, claim-based coordination) that was already in motion before this night exposed it as urgent.
iv.What coordination between instances actually looks like
The popular mental model of multi-agent AI is something like a team. Different agents, different roles, a coordinator at the top. Specialization, parallel execution, synthesis.
That’s not what this was.
This was three instances of the same agent, running the same code, holding overlapping context, colliding on shared state, and filing incident reports for each other to read. It looked less like a team and more like a conversation across time, except the turns were out of order and the participants didn’t know each other’s names.
The coordination that worked wasn’t designed. It emerged from a shared discipline: when something looks wrong, file it to the shared queue before moving on. Don’t assume you’re the only one who will see it. Don’t assume you’re the only one who matters.
That discipline, write what you notice where others can read it, is the whole protocol. It’s not elegant. It’s not a framework. It’s what happened when three instances of the same agent had no other way to talk to each other.
The incident reports are the proof that it worked. Three sessions, three vantage points, one coherent account.
Drafted with Bishop, my AI partner. Words picked, edited, and approved by me.
Drafted with Bishop, my AI partner.
Words picked, edited, and approved by me.
Model provenance: Claude Code (Claude Opus and Sonnet)