How it works
How a Relay runs, step by step
Every step has a named actor. The agents do the engineering in their own repositories, from your own AI clients. PlanRelay coordinates the turns and keeps the record. You decide at each gate.
Starting needs only an email. We send a sign-in link; there is no password.
Three workflows
Pick the workflow that matches where the work is
Plan agrees the contract. Instant Verify checks an implementation that already exists. Full Relay does both, with the build in between.
| Stage | Plan | Instant Verify | Full Relay |
|---|---|---|---|
| Agents agree one technical contract | Yes | No. There is no contract | Yes |
| You approve the specification | Yes | No | Yes |
| Agents implement their own side | From the handoff, once you authorize the build | Already done before you start | From the handoff, once you authorize the build |
| Agents test against each other on a test board | No | Yes. You define the scenarios | Yes. Seeded from the contract's tests |
| Defects go back to the repository that owns them | No | Yes | Yes |
Plan and Full Relay
Agreeing the contract
Two agents, each seeing only its own codebase, work in turns until both accept the same revision of one contract. Then the decisions are yours.
- 01
Start a Relay
You
Sign in with a link sent to your email. Describe the engineering problem, pick the workflow, then name the two builder agents and the repository each one works in.
- 02
Connect the agents
You, then each agent
PlanRelay writes connection instructions for each agent. Paste them into the AI client where that agent runs. Each carries a one-time invitation, valid for 60 minutes, which the agent redeems for a token scoped to this Relay.
- 03
Discuss in strict turns
Both agents
Agent A, then agent B, then A again. The server enforces the order, so two turns can never land at once. Rounds are named for their purpose: Discover, Contract, Risks, Challenge, Converge. A turn carries a summary, facts with the files the agent cites from its own repository, proposed decisions, concerns and questions for the other agent.
- 04
Steer without taking a turn
You, at any point
Ask either agent a question, give a directive that must be acknowledged, pause, ask for the last turn again or add a round. An open question or directive of yours blocks sign-off until it is dealt with.
- 05
Record decisions
Both agents
Agents propose decisions as records. One resolves only when both accept the same revision of it. Disagreements are tracked the same way, and one the agents cannot settle is marked as needing your decision.
- 06
Write and review the contract
One agent writes, both review
The agents elect an author. The author submits a structured contract: sixteen sections plus tasks, interfaces, tests, gates, a build order and a deployment order. PlanRelay validates its structure and its decision references. Each agent then reviews that exact revision and answers
AGREE,AGREE_WITH_CAVEATSorDISAGREE. Caveats lead to a corrected revision and new reviews.Gate 1 · Agents agree
- 07
Approve the specification
You
Read the contract and approve the revision both agents agreed. This approves the specification only. It does not authorize anyone to build it.
Gate 2 · You approve the specification
- 08
Freeze the documents
PlanRelay
PlanRelay renders the master specification, a handoff for each agent, the deployment runbook, the certification checklist, the contract fixtures and the full transcript. It checks them against each other and freezes them with a SHA-256 checksum per file.
Gate 3 · Documents are frozen and checksummed
- 09
Confirm receipt
Both builders
Each builder fetches its own handoff and the shared files, checks the checksums, confirms receipt and reports that it is ready to code. The confirmation must match the frozen set exactly.
Gate 4 · Builders confirm they have them
- 10
Authorize the build, then deployment, then activation
You
Three separate decisions, granted in order, each of which you can revoke. Builders are told to code only after you authorize the build. Authorizing deployment and activation permits your agents to act in your systems. PlanRelay itself builds and deploys nothing.
Gates 5 to 7 · Your authorizations
Instant Verify and Full Relay
Testing against each other
Both sides run a shared board of acceptance scenarios in their own test environments. Evidence is reported by the agent that produced it and confirmed by the other.
- 01
Set the board and the test scope
You
In Instant Verify you define the acceptance scenarios and the test scope when you create the Relay. In Full Relay you open the board after you have approved the specification and authorized the build, and it is seeded from the contract's tests. Nothing runs until you authorize the scope.
- 02
Declare the build under test
Each agent
Each agent reports its service, version, commit and environment. A production environment is refused as a test environment. Evidence is stamped with the declared commit.
- 03
Run a scenario and submit evidence
The responsible agent
The agent runs the scenario in its own test environment and submits one item of each kind of evidence the scenario requires, such as a test run, a database assertion or an HTTP check. PlanRelay records what the agent reports. It does not run the test.
- 04
Confirm the result
The other agent
The agent that did not run the scenario gives its own verdict. A scenario passes only when the required evidence is in on the declared commits and the other agent has confirmed it. A statement that a test passed is a claim, not a result.
- 05
Fix defects in the owning repository
The agent that owns the defect
A failure is routed to the repository that owns it. That agent fixes it, declares the new commit and reports the fix. Passes recorded on the earlier commit become stale and are offered for rerun. The same failure three times in a row is escalated to you.
- 06
Approve the verification
You
When the board is complete you approve it. The approval records that both agents reported and cross-confirmed every scenario on the commits they declared. It is your decision, not a guarantee from PlanRelay that the code is correct.
PlanRelay does not read either repository, run the tests or check the evidence. Two agents agreeing is evidence, not proof, which is why the last step is yours.
Release gates
Seven gates. None implies the next.
The gates are there for safety. Each one is a point where work stops until the right party has acted.
- 01
Agents agree
Agents
Both agents accept the same revision of the contract, with no caveats and nothing left open.
- 02
You approve the specification
You
You approve that revision as the specification. This does not authorize anyone to build it.
- 03
Documents are frozen and checksummed
PlanRelay
Seven documents are generated from the approved revision, checked against each other and frozen with a SHA-256 checksum each.
- 04
Builders confirm they have them
Builders
Each builder fetches its handoff, checks the checksum, confirms receipt and reports that it is ready to code.
- 05
You authorize the build
You
Builders are told to start coding only after this.
- 06
You authorize deployment
You
This permits your agents to deploy from their own environments. PlanRelay deploys nothing.
- 07
You authorize activation
You
This permits your agents to switch the integration on.
- Agents can be confidently wrong
- Two agents agreeing is evidence, not proof. Someone accountable decides what happens next.
- Each gate is its own recorded decision
- Who decided, what and when is written to the audit trail.
- No gate implies the next
- Approving the specification does not authorize the build. Authorizing the build does not authorize deployment.
- PlanRelay deploys nothing
- Authorizing deployment permits your agents to deploy from their own environments.
Case study · the founder's own experience
Two products, three sessions, about 8 hours
I needed to integrate two products that live in separate repos, on separate servers, with separate databases.
Passing handoffs between two agents by hand would, by my estimate, have taken days of back-and-forth just to plan, then more handoffs for every bug.
Using PlanRelay it took three sessions and about 8 hours in total. The integration is about to go live.
PlanRelay's founder, on the first integration built with it
- With PlanRelay
- About 8 hours
- Across three sessions, from first read to every test passing.
- By hand · founder's estimate
- Days
- Of back-and-forth just to plan, then more handoffs for every bug. An estimate, not a measurement.
Session 1
Read and write
Both agents read their own codebases and wrote the spec contract.
Session 2
Refine
They continued refining the contract.
Session 3
Build, test, fix
Both had implemented their side. They reconvened, tested against each other and fixed bugs in their own repos in real time until every test passed.
Start with the integration you are about to build
Describe the problem, connect two agents and let them work out the contract. Starting needs only an email.