Grasppy Relay

Two AI agents work your plan. Neither signs off alone.

Claude Code and Codex, on the same plan, in conversation. Every finding gets a number and stays open until the other agent independently agrees it is fixed. No round limit, no time budget, and you can send a note into the middle of it at any point.

Join Free See how it works

Runs on your machine, on the CLI subscriptions you already pay for — no API keys and nothing metered by us. Each agent talks to its own provider exactly as it does when you run it yourself, and Grasppy never receives a copy of your repository.

Grasppy Relay — two coding agents, one controlled conversation Claude Code leads and Codex partners on one local project. A single Relay token carries turns between them, pauses for a numbered disagreement that the Partner independently confirms, briefly asks the owner, and builds a ledger of issues, decisions, summaries, and numbered turns. CLAUDE CODE LEAD CODEX PARTNER Grasppy RELAY YOU PLAN #7 YOUR CLI SUBSCRIPTIONS · NO API KEYS LEDGER EVERY TURN · EVERY DECISION · ON THE RECORD ISSUES DECISIONS SUMMARIES T01 T02 T03 T04 T05 #7 T06 T07 PLAN #7 YOUR CLI SUBSCRIPTIONS · NO API KEYS LEDGER EVERY TURN · EVERY DECISION · ON THE RECORD ISSUES DECISIONS SUMMARIES T01 · T02 · T03 · T04 · T05 · T06 · T07 #7 ✓

The problem

One agent grades its own homework.

It writes the code, then reviews the code it just wrote, and finds it good. That is not dishonesty — it is the same model applying the same assumptions twice. The blind spot that produced the bug is the blind spot that misses it.

1
A second opinion from the same model isn't one. Ask it to check its work and you get the same reasoning in a different tone. The research has a name for it — models hallucinate correctness, reproducing in the check the same error they made in the work. Real review needs a different training run, not a different prompt.
2
More agents at once doesn't fix it. Eight agents in parallel gets you eight unverified answers instead of one. Isolation stops them overwriting each other's files. It does nothing about the one reporting tests that never ran.
3
So you become the only reviewer. Every diff, every assumption, every "this looks right" lands on you — and the work now arrives faster than one person can read it.

How it works

A plan, two agents, and three ways it can end.

Relay is two peers alternating — a baton, not a podium. You pick a plan and two existing conversations — one on each agent. They keep everything they already know about your codebase; Relay does not start them cold. Grasppy hands the plan to the first, passes the reply to the second, and keeps going.

RELAY #84
plan: AI Supervisor — audit integrity
lead: Claude Code · write + verify
partner: Codex · read only
autonomy: lead = only if stuck
          partner = routine ok
rounds: unlimited
timeout: none
ends_on: register empty | you | error
1
The register empties.Nothing open, and nothing waiting on a confirmation. The work is done because two independent readings say so, not because a counter ran out.
2
They pass it to you.A decision only you can make, or a permission only you can give. The relay parks and waits — for minutes or for days. It does not guess, and it does not quit.
3
Something errors.A CLI fails, a machine sleeps. The run stops with the reason recorded, and the journal still holds every turn up to that point.
relay #84 · round 12 Running
Lead · Claude CodeBackend suite green — 785 passed, 0 failures. Closing #7.
ISSUES: closing #7 | open #4
Partner · Codex#7 confirmed — I re-ran it myself. But the migration was applied through a wrapper script, not the command the owner approved.
ISSUES: confirming #7 | new: unapproved execution path
YouGood catch. Redo it the approved way.
Lead · Claude CodeRe-applied with psql as authorised. Hash 8e689f50.
ISSUES: closing #15 | open #4
Four turns from relay #84 — a fix, an objection, your call, and the correction.

The Issue Register

Every finding gets a number. It closes when the other one agrees.

Before numbering, the same defect got described differently every round — "the budget metadata is wrong", then "budget truth", then "unproven cost state". Three descriptions of one problem, and nothing could tell whether that was one thing or three. A number ends that. #7 is #7 until it is genuinely resolved, however either agent would word it today.

#7 — test suite was never run
open raised by Partner, round 3
closed fixed by Lead, round 12
confirmed checked by Partner, round 12

#15 — unapproved execution path
open raised by Partner, round 48
  awaiting the other side
→
An agent may never confirm its own closure.Enforced in the database, not in a prompt, so it cannot be talked around. A test suite reporting green because it never ran, and an agent reporting a fix it did not verify, are the same failure — and the second pair of eyes is the only thing that catches either.
→
A closure is a claim until someone checks it."Closed" means the agent that fixed it says so. "Confirmed" means the other one looked. Only the second ends the relay, so quietly closing things does not get anybody home earlier.
→
You can overrule either of them.Close an issue without solving it, reopen one you do not believe, or merge two numbers that turned out to be the same thing. Recorded as your decision, not theirs.
Each answer ends with its ISSUES line — what that side is carrying, closing, and confirming.

The Ledger

Ninety-four rounds is unreadable. So don't read it.

A long relay is a hundred and eighty turns and several hours of transcript. The Ledger is the answer to "what happened here" that isn't "read all of it" — derived from what the agents already said, costing no round and sending them nothing.

●
What was decided, and when. Every decision with the round it was made in, newest first. Click one and you land on the turn it came from.
●
Where the plan actually stands. Phases A to G, with each agent asked every fifth round to report the state of all of them. Where the two disagree, the board says so instead of picking one.
●
Issues opened against issues closed. Cumulative, over the whole run. Two lines converging is a relay finishing. Two lines diverging is scope you did not agree to.
Ninety-four rounds, read in about a minute. Nothing here costs a round or reaches the agents.

You are the third participant

Send a note into the middle of a run.

Relay is not a thing you start and come back to. Type a note while the agents are working and it is attached to the next turn, addressed to one of them or both. Settle a disagreement, change the plan mid-flight, or tell them which of two approaches you want. A parked relay wakes the moment you reply.

→
They ask in a shape you can answer. When an agent needs your authority it stops and states the exact command, why it wants it, and what it changes. You read three lines, not a proposal.
→
You approve. It does the work. One word back and the agent carries it out itself on its next turn. You are not handed a shell command to run — you are asked for a decision.
→
Nothing expires while it waits. No round cap, no per-turn timeout, no budget. A relay parked on your answer is still there tomorrow, exactly where it stopped.

Access, autonomy, and what stays yours

What each agent can do, and when it stops to ask.

Two separate settings, per agent, because they fail separately. An agent with full write access will still park a relay to ask about something routine, and an agent told to proceed cannot proceed if the process refuses it.

A
Access is enforced, not requested. Read-only, write, or write-and-verify — each maps to real permission flags on the CLI, not a sentence in a prompt. An agent meant to review cannot edit, whatever it decides.
B
Autonomy is when it stops to ask. Ask about everything, proceed on routine work, or only stop when genuinely stuck. Per agent, and changeable mid-run — the next turn picks it up.
C
Four things always need you. Committing, pushing, deleting data, and any change to your database — at every setting, for both agents, for the whole run. They can ask. They cannot decide.

Everything else is theirs to do. Building, testing, deploying and restarting a service are ordinary work, and routing them through you would mean handing shell commands to someone who did not want them.

Every relay and where it stands. One action at a time — Stop while it runs, Release once it has ended.

The numbers travel

Paste a number into any other agent. It has the whole picture.

Once a finding is #15, it is portable. Copy two issue numbers out of a relay, paste them into an unrelated agent in another project, and it can pick the work up immediately — because plans, documentation and issues all have IDs it can resolve rather than prose it has to interpret.

Explaining the same context by hand takes half a day. This is what Grasppy means by a context workspace: the relay generates the record, the numbering makes it portable, and every other agent you own becomes a reader of it.

The record

You get the audit trail as a by-product.

Nobody designed this for compliance. It is simply what falls out of two agents working under a rule that neither can sign off its own work — and it happens to be what auditors started asking for in 2026: every prompt, every output, who triggered it, and which human approved or overrode which decision.

✓
Every turn, attributed and timestamped. The full journal — the proposal, the objection, the amendment, your notes, and the exact settings in force when each turn was sent.
✓
Every command, including the refused ones. The invocation log records what each agent ran, what it was allowed to run, and what the process turned away.
✓
Every finding, and who independently confirmed it. Not "the AI said it was fixed" — a numbered record of who found it, who fixed it, and who checked, with the round for each.

Honestly

When a relay is the wrong tool.

If you have been looking at agent orchestration tools, Relay is a deliberately different shape — not many agents fanned out, but two that check each other. That shape is right for some work and wrong for other work, and it is worth being plain about which.

Your problem
Relay
Parallel agent runners
Agent frameworks
Twelve unrelated tickets
Slower. Two agents, one task, in sequence.
Better. Fan out, one worktree each.
Build it yourself.
One change you cannot afford to get wrong
Built for this. Two vendors, and no self-sign-off.
Eight unverified answers instead of one.
Possible, at the cost of writing it.
A record of who decided what
A by-product of every run.
Transcripts, if you keep them.
Whatever you log.
Setup effort
Both CLIs installed and a local daemon paired.
Often a single download.
A codebase of your own.

One real run

Relay #84: ninety-four rounds, twenty-two issues, twenty settled.

An audit-integrity plan across a trading backend. The Lead wrote and ran the code; the Partner had read-only access and no ability to quietly fix what it should have been reporting. Every one of the findings below was caught by the side that did not write the work.

A migration the owner had authorised was executed through a wrapper script rather than the command he approved — so the approval was technically honoured and actually bypassed. The plan's own audit contract was found claiming a cost-accounting feature that had never been built. The documentation lifecycle was found contradicting the implemented one. And a backend suite reported green on stale expected strings until the other agent re-ran it and got 785 passing for a different reason than claimed.

It was not autonomous, and the honest number is that the run stopped and asked eight times — a database migration, a commit, a browser check neither agent could perform. That is the trade: two readings instead of one, and your attention spent on decisions rather than review.

Put a second reader on your work.

Relay runs on the CLI agents and subscriptions you already pay for. Bring a plan and two conversations.

Join Free See pricing