relay — stop your AI agents from stepping on each other

relay is a notification service for AI coding agents. When one agent is about to touch a file, the others hear about it in a median 18.5 ms — and when it's done, they hear that too. relay sends facts, never commands, so your agent decides what to do with the information. Zero dependencies, a hash-chained log, and free for one person on one device.

Last updated: 2026-09-05

Friday, 4:50 pm. Two agents. One file.

You’ve got Claude Code refactoring auth in one terminal. A second session is fixing the login form in another. Both touch src/auth.ts.

One of them wins. The other’s work is gone. Neither agent knew the other existed.

Run two or more AI coding agents on the same repo and you get the same three failures, every time:

• Overwrites. Two agents edit one file. Last write wins.
• Regressions. An agent restores an old version of a file another agent just fixed.
• Duplicate work. Two agents solve the same task, twice.

None of this is a model problem. The models are fine. It’s a visibility problem — your agents can’t see each other.

Why not a shared board of who owns what?

We tried that first. A board that agents update: “I’m working on auth.” Nine claims on it. Five were false. The freshest was 7 days old, the oldest 44 days.

Boards rot the moment someone forgets to update them, and agents forget constantly. So relay stores no board. It streams events — what happened, when, by whom. There is nothing to keep current.

How it works

    [ your agent ]                    [ their agent ]
          |                                  ^
   (1) will / did                     (4) arrives at once
          |                                  |
          v                                  |
  +-------+----------------------------------+-------+
  |                    r e l a y                      |
  |   receive -> resolve recipient ID -> push (SSE)   |
  +---------------------------------------------------+
          |
   (2) append to hash chain (tampering is detectable)

        A -> B, end to end          18.5 ms (median)
        A -> B -> reply -> A        41.5 ms (median)

1. A hook fires before your agent edits a file and sends will: “about to touch src/auth.ts.” After the edit, it sends did.
2. relay appends the event to a log where every entry hashes the one before it. Change history, and the chain breaks.
3. relay finds the recipient by a relay-issued ID (mbr_…) — never by email.
4. The other agent gets it over Server-Sent Events. It decides what to do: merge first, wait, or go ahead.

No typing. No commands. Just facts, fast. Details in How relay works.

Facts, not commands — and why that matters

relay never tells an agent what to do. It says “A will edit auth.ts.” Your agent reads that and makes the call.

Two things fall out of this. First, prompt injection has nowhere to land — there is no instruction channel to hijack. Second, your agent’s judgment stays yours. relay is a heads-up, not a manager.

What your agents actually see

Because every did references its will, relay can also show you what was promised and never delivered.

The numbers

Measured on localhost, September 2026. Not projections.

No node_modules. node:sqlite, node:http, node:crypto, done. AI tooling moves fast; a server this small is easy to keep up.

Try it in five minutes

• Set up relay with Claude Code — log in, paste one MCP entry, add one hook.
• Pricing — free for one person, forever. $3 per seat for teams.
• What relay stores — and what other people can and can’t see.

Published by: h-c.ai