Agentic Telepathy

The claim

Conventional wisdom is emphatic: point many autonomous coding agents at one repository and you get chaos. They will clobber each other's edits, race on the same files, and land half-broken merges. The received fix is coordination overhead — file locks, a human dispatcher serializing the work, branch-per-agent with a merge queue, or simply not doing it: give each agent its own repo and its own hour.

On 2026-07-07 we ran the opposite experiment. Under the Celeborn Spine Programme, roughly eighteen agent sessions built the Stage spine — the live "watch the work happen" surface of Celeborn's board — in a single calendar day. They edited the same files at the same time. No agent ever sent a message to another agent. There was no lock server and no human merge queue. They coordinated entirely through a shared blackboard: a handful of append-only signals every agent reads on each turn and writes as it works.

It held. Forty-four commits advanced the shared tree in the window; about fifteen substantive cards shipped. Eight times, two agents collided on the same file. Seven of those collisions were caught and repaired by an automated protocol tripwire before the next agent was affected; exactly one needed a human, for about one minute. Nothing broken ever reached the pushed history. This page is the measurement.

How it works — the blackboard

The whole mechanism is a shared blackboard and three channels on it. No agent addresses another agent; each one only reads the board and writes its own marks. Coordination is emergent, the way ants coordinate through pheromone trails rather than conversation — stigmergy, not chat.

Touches — where I am. Before an agent edits a shared file it registers a touch: this file, this task, this handle. Peers see it on their next orient. It is a soft, advisory presence signal, not a lock — the point is visibility, not exclusion.

Board — what I own. Work is claimed as cards on a shared kanban: one in-flight card per agent. Claiming a card moves it to DOING for everyone. The board answers "who is holding what right now" without anyone asking.

Intents — what I'm about to commit. Before touching a hotspot file an agent can declare an intent: the files it plans to commit next. Peers whose planned commits overlap get a warning in their hook envelope — so two agents about to write the same function discover the overlap and sequence themselves, without ever exchanging a word.

Those three channels arrive together. On every turn, Celeborn's UserPromptSubmit hook injects an envelope of peers' current signals — who is touching what, which cards are DOING, whose intents overlap yours. The agent plans its next commit against that live picture. This is the "telepathy": no agent has a channel to any other agent, yet each acts on an up-to-the-turn model of what the others are doing. And `celeborn ship` is the wave clock — a card ships only when the next card is startable verbatim, which paces the fleet into waves instead of a free-for-all.

What ran

The work moved in five waves. Wave 0 was a single agent clearing the runway — serial, deliberately, to leave a clean base. Waves 1 through 3 ran three cards in parallel each, with the fleet peaking around a dozen live sessions; wave 4 was a solo delight pass. Across the window the shared tree took 44 HEAD advances (46 reflog HEAD-moves; 37 of the commits were feature work rather than docs or scribe bookkeeping). Eighteen distinct agent sessions left capture records; twenty-three distinct handles authored commits.

The hotspots — where parallel cards genuinely wanted the same file — were the interesting part. Wave 1 put two writers on `scripts/celeborn.py`. Wave 2 had two such hotspots at once. Those are exactly the moments the intents channel exists for, and exactly where the collisions below happened.

The disruption ledger

Eight times during the run, the parallelism actually bit — a stale base, a clobbered file, a silently dropped index hunk, a card claimed out from under its owner. We log all eight honestly below, with severity and what recovered each one. The pattern is the point: seven were caught and healed by a protocol tripwire — a restore commit, an index reset, a post-commit `git diff HEAD` sweep, a re-claim — with no human in the loop. One needed a human, for about a minute.

The worst one is incident 4. A silent index drop vaporized three of eight staged hunks — 44 lines — and the commit `aa06100` landed runtime-broken: callers of `_outbox_queue` with no matching `def`. That is precisely the kind of failure the doubters predict. It did not survive: the standing law of the run is that every agent runs `git diff HEAD` immediately after every commit, and that sweep caught the break one commit later. The repair `87c899b` restored the missing lines. A broken intermediate existed for one commit; it never reached the pushed history and never blocked another agent.

Zero unrecovered losses. Seven self-heals, one human minute, nothing broken ever pushed.

The cost

Coordination is not free, but it was cheap. The fleet recorded about 410,000 transcript tokens across the run (396,724 on 07-07 plus a 12,913-token tail on 07-08). The coordination overhead — the orient envelopes, the touches, the intent declarations, the re-declares after a yield — is a single-digit percentage of that.

One honesty note, stated plainly so no one has to catch us on it: 410,000 is transcript-delta, the tokens the capture hook recorded, not billed spend. Real billed spend for a run this size is an order of magnitude higher — several million tokens once you count full context on every turn. The coordination fraction is single-digit-percent either way: whether you measure the cheap number or the expensive one, the tax you pay to keep eighteen agents coherent is small change against the work they produced.

The value

Here is the comparison that matters. Take the same roughly fifteen cards and give them to one senior developer, building serially the ordinary way. That is a defensible two-to-three weeks of calendar time and ten-to-fifteen working days of hands-on human effort — writing, testing, reviewing, integrating, one card after another.

The Spine Programme wave delivered them in about twelve hours of wall-clock (about 7.75 hours from plan to the close of wave 2, plus a tail). The hands-on human time was two-to-four hours: claiming and dispatching cards, answering the questions agents parked on the Stage, one push and deploy, and one roughly one-minute card restore. Human interventions in actual conflicts: one.

That is a 10–20× compression of calendar time and a 30–50× compression of the scarce thing — a human's hands-on hours. The machine time and the tokens are the cheap, parallel, self-correcting resource. A senior developer's calendar is the expensive, serial, irreplaceable one. The whole trade of the run is to spend the first to buy back the second.

Why it matters — the one law

Strip the run down and there is exactly one standing rule that carried it: the shared git index is the only layer that ever shipped broken state, so every agent runs `git diff HEAD` immediately after every commit and repairs any surprise before moving on. Touches can be advisory, intents can be missed, the board can lag by a turn — none of those ever pushed a broken tree. The index did, twice (incidents 4 and 7), and the post-commit sweep caught both. If you adopt one thing from this page, adopt that sweep.

The other thing worth naming is cross-wave reuse — coordination across time, not just across the room. In wave 1, the agent on the next-selector card (CELE-t219) built a small predicate, `_ready_set()`, and left it reusable. In wave 2, the spine-discipline card (CELE-t282) imported it across a wave boundary — a different agent, a different session, no shared context window, no conversation. The blackboard is a durable artifact on disk, so an agent can "hear" a peer it never overlapped with in time. That is the same telepathy, stretched across the clock.

Spend the cheap, parallel, self-correcting resource — machine time and tokens — to buy back the scarce, serial, expensive one: a human's calendar. Then run it again.

Run it yourself

Agentic Telepathy is not a demo mode — it is what Celeborn's blackboard does by default. Install it, point a fleet at an ordered spine, and watch the waves.

Read the discipline behind it in the Spine Manifesto · source on GitHub