relayGet started
Live multiplayer

Watch an agent work.
Together.

Everyone on the link watches the same session as it runs. One person drives at a time, and control passes mid-task.

Runs in your repo, on your machine. Prints a link to share. Needs a Claude Code login or an Anthropic API key.
relay4Kp2xQmN
doneaviyou driving
avi → Explore this repo and write me a summary as REPORT.md
ranpwd && ls -la22 lines
readREADME.md100 lines
readpackage.json34 lines
Now let me look at each package's dependencies and key source files.
readapps/api-server/src/app.ts28 lines
readapps/worker/src/index.ts68 lines
avi handed control to you
readpackages/evaluator/src/run-evaluation.ts31 lines
wroteREPORT.mdwritten
— done · 13 steps · 46s · $0.04 —
Type an instruction…Send

Recording of a real session — 13 tool calls, live repository.

One writer. Never two.

Screen-sharing an agent gets you an audience. Relay gets you a relay: exactly one person holds the wheel, the server enforces it, and control passes cleanly when someone else should take over.

Request → hand over → release
A viewer asks, the driver grants. The lock moves; every screen updates at once.
Enforced on the server
Not a disabled button. An instruction from anyone who isn't the driver is rejected before it reaches the agent.
No input races, by construction
One writer means instructions arrive one at a time, in order — never two at once.
relayrun.in/session/4Kp2xQmNavi
avi → Add a token-bucket rate limiter to the API, with tests
✓readapps/api/src/router.ts84 lines
✓readapps/api/src/middleware/6 files
I'll add it as middleware and wire it into the router.
✓wrotemiddleware/rate-limit.ts+52
⇄ avi handed control to noor
noor → Run the tests before wiring it in
✕ranpnpm test middleware2 failed
✓wrotemiddleware/rate-limit.ts+6 −2
✓ranpnpm test middleware14 passed
— done · 11 steps · 1m 12s —
noor is driving — you’re watching
relayrun.in/session/4Kp2xQmNnoor
avi → Add a token-bucket rate limiter to the API, with tests
✓readapps/api/src/router.ts84 lines
✓readapps/api/src/middleware/6 files
I'll add it as middleware and wire it into the router.
✓wrotemiddleware/rate-limit.ts+52
⇄ avi handed control to noor
noor → Run the tests before wiring it in
✕ranpnpm test middleware2 failed
✓wrotemiddleware/rate-limit.ts+6 −2
✓ranpnpm test middleware14 passed
— done · 11 steps · 1m 12s —
You’re driving · 1 watching

Your code stays on your machine.

The agent runs where the repository already is — your laptop, your checkout, your credentials. What crosses the network is a description of what happened, not the code it happened to.

No upload, no clone on a server
Nothing to hand over before you can start, and nothing of yours sitting on someone else's disk afterwards.
The server is a relay, not a runtime
It orders events, enforces the lock, and fans out the transcript — and that's the whole job. Your repository, shell and API keys never enter into it.
Any repository, no setup
Whichever directory you run the command in. No connected accounts, no repo picker, no OAuth scope to grant.

What happens when you send one

  1. 01

    You start the agent

    npx relayrun in your repository. It works in a disposable clone, connects out to the relay, and prints a link. Nothing inbound, so no ports to open.

  2. 02

    The server stamps the order

    One counter, assigned in one function. Clients render in that order and never sort — which is why two browsers agree on what happened when.

  3. 03

    Everyone sees it at once

    Every tool call, result and plan update is broadcast as it happens. Join an hour in and you get the whole transcript first, then the live stream.

  4. 04

    The work becomes a branch

    When a run finishes, the session's diff is real. Publish commits it to a branch in your own repository — ready to check out, already local.

What's actually running

Engine
Claude Agent SDK — the same one Claude Code runs. Relay adds the room around it, not a different model.
Topology
The agent runs on the host's machine and streams events up over one WebSocket. The server coordinates; your code stays put.
Ordering
A server-assigned seq on every event, from a single function. Clients only ever append.
Isolation
A disposable clone per session, discarded when the room empties. The agent has full shell access inside it, with the host's own permissions — the same trust as pairing.
Catch-up
Full transcript replay on join, then the live stream — the same path a dropped connection recovers through.
Reconnect
A 30-second grace window holds your identity — your seat stays reserved through a wifi blip.
Persistence
An optional Postgres mirror of the transcript, so a dead link renders a read-only replay instead of an error.
Questions

Before you run it

The things worth knowing before you paste this into a terminal.

01Does my code go to Anthropic?

Yes. The agent is the Claude Agent SDK, so file contents reach the Anthropic API exactly as they do in Claude Code. The repository itself doesn't — Relay's server only ever sees the event stream.

02What can the agent do to my repo?

Full shell access, with your own permissions, inside a disposable clone that's discarded when the room empties. Nothing touches your real checkout until you publish, which commits the diff to a branch in your own repository.

03Can someone watching change anything?

No. The lock lives on the server, not in the UI. Only the driver's own instructions ever reach the agent — enforced the same way whether you click a button or hand-craft a WebSocket frame yourself.

04What happens if I close my laptop?

The session stops. The agent runs on your machine, so it ends when your machine does — an honest limitation, not a feature we're hiding.

05Do I need to connect an account?

No. Point npx relayrunat whichever directory you're already in — no account to connect, nothing else needed.

06What does it cost?

Nothing from Relay. Runs are billed to your own Claude Code login, or to your own Anthropic API key if you pass one — the credential never leaves your machine, and Relay never sees it.

Run it. Send the link.