The coordination layer for AI agents

Twelve agents.
One repository. Zero collisions.

Claude Code, Cursor, Copilot, Codex, Antigravity — running in parallel, on four machines, writing to the same files. ./relay locks, resolves, and syncs between them. GitHub Desktop for AI agents.

Try now for free See how it works
Antigravity
Claude Code
Codex
Copilot
Cursor
./relay

Every write goes through one lock table.

The reality

This isn't a hypothetical problem.

79.4%

of agent PRs overlap another agent PR in time.
27.7% of all agent PRs hit a merge conflict (vs. 10–20% for humans).

Source: arXiv:2607.04697 (33,596 agent PRs) · AgenticFlict, arXiv:2604.03551v2 (142,652 agent PRs)

41.7%

conflict rate when two different agents (e.g. Cursor vs. Claude) overlap in time on the same repository.

Source: arXiv:2607.04697, AgenticFlict

84.4%

of conflicted files between agents are source code. In 57.6% of conflicts, they edit the exact same lines.

Source: AgenticFlict, arXiv:2604.03551v2

$99–$209

Estimated token cost for 100 overlapping heavy agent runs when resolving conflicts and redoing work.

Sources: Anthropic, OpenAI, Antigravity pricing docs

Live coordination

3 machines · 7 agents
01 / The problem

They all write
to the same files.

Eighteen months ago you had one coding assistant. Today you have three running at once — Claude in one terminal, Cursor in another, Copilot in the editor. Not one of them knows the others exist.

Now put four people on the same repo. That is twelve agents, editing the same code, blind to each other. You find out at the merge. Or you do not find out at all.

Git solved this for humans.
Nothing solved it for agents.

Human speed vs. machine speed

Git assumes
you are slow.

Commit cadence minutes apart

Agents write every few seconds

Branch model one branch each

Twelve agents, one directory

Conflict timing at merge

Hours after the damage

Awareness none

No agent can see another's edits

Blast radius untracked

One file change breaks a dozen others

12 agents1 working tree0 coordination

02 / The layer

Claim. Coordinate.
Release.

01

Claim

Nothing gets written
without a lock.

A pre-tool hook fires before your agent touches a file and claims it against a shared, TTL-based lock table. If another agent holds it, the write is refused — not silently merged.

02

Coordinate

Locks that understand
your import graph.

Files do not exist independently. ./relay parses imports with tree-sitter and asks whether the change affects what someone else is editing — not just whether that exact path is open.

03

Release and sync

Every machine on
the same working state.

The post-tool hook releases the lock and the change propagates as a patch — not a project copy — to every teammate's clone through the room.

Read the full breakdown — every feature, end to end ↗

03 / No backend

You are the server.
You are the client.

None of this needs hosted infrastructure. One person on the team runs relay serve — that machine is the host. Everyone else connects over an ngrok tunnel, straight to that laptop. Nothing lives on infrastructure you do not own.

Your machine

Claude Code Cursor pre / post-tool hooks relay serve
The room Lock table · dep graph · patches

Teammates

their own filesystem their own agents ngrok tunnel relay pull

No database. No account. No cloud index. Your laptop is the whole backend.

04 / Mission Control

One board for
every agent.

Started by relay serve, running on your own machine. Live lock table, lock graph, code edits, unified agent chat, conflicts, and who is online — across every machine in the room.

  • Live locks Who holds what file, right now.
  • Lock graph See the dependency blast radius as a canvas.
  • Conflict notices Overlapping edits surfaced within seconds.
relay status
lock table — 4 held
├── src/auth/session.ts   # @pony · claude · write
├── src/api/routes.ts     # @unnath · cursor · write
├── lib/db/client.ts      # @arjun · codex · write
└── ui/Header.tsx         # @pony · copilot · write
    └── dep-blocked: ui/Nav.tsx, ui/Layout.tsx
$ relay doctor✓ room healthy · 3 peers
05 / How to get started

Two commands
on the host.

Clone the repo, link the CLI, and point ./relay at a project. Cloning through relay registers the workspace and installs the claim/release hooks for every agent you use — nobody has to remember a command afterwards.

host
$ npm install && npm link   # the relay CLI, Node 18+
$ relay login              # GitHub identity, via the gh CLI
$ relay clone <repo-url>   # clone + register + install agent hooks
$ relay serve              # API :3001 · Mission Control :3002
$ github.com/prakrititz/relayBrain ↗v0.1.0

Then open Mission Control → Team → Share to mint the invite link. Teammates run their own relay and join:

Command What it does
relay serve Start their local relay, then join with the host's invite link
relay pull Apply the host's current working state onto this clone
relay push Send your dirty working-tree files back to the room
relay doctor Walk the room chain and name the broken link

Read the docs — installation, every command, hooks, MCP, troubleshooting ↗

06 / Built for parallel agents

Conflicts prevented,
not discovered.

01

File locking

Exclusive write claims, enforced before the edit lands.

02

Dependency-graph locking

Blocks the blast radius, not just the exact path.

03

Patch sync

Every machine on the same state, without copying the project.

04

Mission Control

Every agent on every machine, on one live board.

Full feature list and architecture ↗

The layer is ready

Do not just add more agents.
Just relay.it

Try now for free