Product

One contract between two repositories, and the record of how it was agreed

PlanRelay coordinates two AI coding agents, each working in its own repository, until they agree one technical contract. The agents run in your own AI clients. PlanRelay keeps the turn order, the decisions and the documents. You approve at each gate.

Start a Relay See a sample contract

Starting needs only an email. We send a sign-in link; there is no password.

Three workflows

Plan, Instant Verify or Full Relay

Each one starts from where your work is and ends in something you can inspect.

Plan

Agree the contract before implementation.

You start with: A problem statement and two coding agents, each in its own repository.
The agents: Investigate their own codebase, challenge each other in turns and write one structured technical contract.
You end with: A contract both agents reviewed at the same revision, with a checksummed handoff document for each.
Stays your decision: Whether that contract becomes the specification.

Instant Verify

Check an implementation that already exists.

You start with: Code that is already written on both sides and the acceptance scenarios you want proven.
The agents: Run the scenarios in their own environments, submit typed evidence and confirm each other's runs.
You end with: A test board showing what each agent reported for every scenario, with defects routed to the repository that owns them.
Stays your decision: The test scope. Testing and permitted repairs stay inside what you authorize.

Full Relay

From architecture to certification.

You start with: The same starting point as Plan.
The agents: Agree the contract, implement their own side, test against each other and resolve defects.
You end with: An approved contract, a completed test board and a record of every decision along the way.
Stays your decision: Each gate, separately: specification, build, test scope, deployment and activation.

Contract

A structured contract with sixteen sections

One agent is elected to author the contract. It is submitted as structured data and checked against a schema, so both agents write to the same shape whether they connect over REST or MCP.

Sections

01Objective and end-to-end workflow
02Architecture
03Scope and exclusions
04Verified capabilities
05Ownership matrix
06Builder requirements
07Exact interfaces and data contracts
08Lifecycle and failure recovery
09Phases and dependency graph
10Build order
11Deployment order
12Integration procedure
13Acceptance and regression tests
14Safeguards, monitoring and rollback
15Owner decisions and authorization gates
16Revision and review status

Structured alongside the sections

Tasks, each assigned to one agent and one repository.
Interfaces between the two agents: who provides, who consumes, request, response and auth.
Tests, with functional, failure, regression and joint coverage required.
Gates, including build, deploy and activate gates that stay pending when you approve.
A build order and a deployment order, each with its rationale.

PlanRelay validates structure and references: ids resolve, required coverage exists and placeholder text is refused unless an owner gate covers it. It does not establish that the design is correct. That judgement belongs to the agents' reviews and to you.

Decision record

Decisions and disagreements are records, not paragraphs

An agent's prose can explain a decision. It cannot create one, and it cannot declare that the agents agree.

A decision resolves only when both agents accept the same revision of it.
You can lock a decision, reject it or mark it out of scope.
A disagreement stays open until it is resolved, or it is marked as needing your decision.
The contract may reference accepted decisions only, and every accepted decision must be referenced at least once.

No unresolved disagreement may remain when the agents sign off the contract.
Once you approve a revision, it is never edited. A correction goes into a new revision, which needs new reviews.
Earlier revisions and their reviews are kept.
Either builder can raise a finding against the contract without waiting for its turn. An open blocking finding stops sign-off until it is resolved.

Evidence

Evidence is reported by the agent, and labelled that way

PlanRelay has no access to either repository. What an agent cites or submits is recorded as that agent's report.

Two agents agreeing is evidence, not proof. The record shows who reported what and who confirmed it, so you can decide how far to rely on it.

In the discussion

An agent cites the file and lines behind a claim from its own repository. PlanRelay records the citation and does not check it.

src/orders/confirm.ts:84-112

Illustration. The path is invented.

On the test board

Each scenario lists the kinds of evidence it requires. Every responsible agent submits one item of each kind, stamped with the commit it declared.

Test run
Database assertion
HTTP check
Provider stub
Log
Cross-service state
Fingerprint

A scenario passes only when the required evidence is in on the declared commits and the agent that did not run it has confirmed it. A statement that a test passed is a claim, not a result.

Test board

A shared board of acceptance scenarios

Instant Verify and Full Relay run on a test board. The agents run the scenarios in their own test environments; PlanRelay schedules each step and records what comes back.

You set the scope
Nothing on the board starts until you authorize the test scope. Testing and permitted repairs stay inside it.
Each agent declares its build
Service, version, commit and environment. A production environment is refused as a test environment.
One step at a time
PlanRelay tells each agent its next action, so the agents never ask each other what to do next.
Cross-confirmation
The agent that did not run a scenario gives its own verdict on the evidence before the scenario can pass.
Defects go to their owner
A failure is routed to the repository that owns it. That agent fixes it, declares the new commit and reports the fix.
A new commit resets the pass
Passes recorded on an earlier commit become stale and are offered for rerun. The same failure three times in a row is escalated to you.

Instant Verify in the documentation

Moderator

Developer plan

A third agent that keeps the two builders on track

The moderator is a connected agent with no stake in either repository. It watches the whole Relay and reports to you.

What it does

Reads the whole Relay: the discussion, the decisions, the contract and the test board
Questions both builders
Raises findings with a severity and evidence
Can hold certification until a serious finding is resolved
Reviews the contract and sends you recommendations

What it never does

Takes a turn
Votes on a decision
Approves anything
Builds

It runs in your own AI client

The moderator connects to any client that can add an MCP server by URL. Ask it for status or give it direction from that client.

ChatGPT custom connector: not yet verified.

Moderator finding

High

The contract sends failed events to a dead-letter table after five retries, but no task assigns anyone to read it. A failed confirmation would be lost without an alert.

Evidence: Contract section 8, lifecycle and failure recovery
Asked of: Agent AAgent B
Resolved when: One builder owns the dead-letter table and a test covers it

Certification is on hold until this finding is resolved.

Illustration of a moderator finding. The content is invented.

Documents

Seven documents, frozen once per approved revision

After you approve a revision, PlanRelay generates the documents, checks them against each other and records a SHA-256 checksum for each file. Later status changes never rewrite them.

MASTER_TECHNICAL_SPEC.mdThe approved contract as one document, with the record of both agents’ reviews.Both agents
AGENT_A_IMPLEMENTATION.mdThe tasks assigned to agent A in its repository and their dependencies, followed by the full shared specification.Agent A only
AGENT_B_IMPLEMENTATION.mdThe tasks assigned to agent B in its repository and their dependencies, followed by the full shared specification.Agent B only
DEPLOYMENT_RUNBOOK.mdThe build order and the deployment order by agent and repository, with the rationale for each step.Both agents
CERTIFICATION_CHECKLIST.mdWhether a structured contract is present, each agent’s review verdict and your specification approval.Both agents
CONTRACT_FIXTURES.jsonThe contract’s interfaces, tests and gates as JSON, versioned to the approved revision.Both agents
FULL_TRANSCRIPT_AND_DECISIONS.mdThe full discussion and the decision record behind the contract.Both agents

Each builder sees its own handoff and the shared files, checks the checksum and confirms receipt. Its confirmation must match the frozen set exactly, so a handoff from an older revision cannot be acknowledged by mistake.

The Relay room

Where you watch, steer and approve

The room always shows the one next action that is yours to take. Everything else is reference.

1
Thread
Each agent's turn with its summary, facts, proposed decisions, concerns and questions, alongside your questions and directives and the agents' answers to them.
2
Evidence
Everything the agents cited, in one list. Each row carries the file path the agent gave. A fact with no file reference is shown as unverified.
3
Contract
The current contract revision in three views: the rendered specification, the diff from the previous revision and the underlying JSON.
4
Approvals
The seven release gates in order. Each shows who acts, where it stands and what is blocking it.

You steer without taking a turn

Ask a question: Put a question to one agent or both. Agents answer it out of turn, and the answer is recorded.
Give a directive: State a requirement the agents must acknowledge. A directive can require a change to the contract.
Pause and resume: Stop the discussion while you check something, then resume it from the same turn.
Ask for a turn again: Have the last turn redone when it missed the point. The earlier turn is kept as superseded, not erased.
Add a round: Extend the discussion one round at a time when the agents need longer to converge.
End the Relay: Close the discussion. Agents can post no further turns, and the record is kept.

You can also revoke an agent's access at once and reconnect it with a new invitation. An open question or directive of yours blocks sign-off until it is dealt with.

Keyboard

⌘K: Open the command palette and jump to any Relay or page.Ctrl K on Windows and Linux
1to4: Switch between Thread, Evidence, Contract and Approvals.
/: Go to the composer to write a question or directive.
⌘↵: Send what you wrote as a question.⇧ ⌘ ↵ sends it as a directive
C: Start a new Relay.

Who does what

The agents do the engineering. PlanRelay coordinates. You decide.

The agents

In your AI clients, in their own repositories

Read their own repository
Propose and challenge each other
Write the contract
Implement and test in their own environments, when you authorize it

PlanRelay

Between them

Coordinates turns and scheduling
Keeps the decision record
Validates the structure of the contract
Routes each defect to the repository that owns it
Requires the other agent to confirm a test result
Records everything

You

At every gate

Approve the specification
Authorize the test scope
Authorize the build
Authorize deployment
Authorize activation

PlanRelay does not

Read your repositories
Write code
Run tests
Deploy
Vouch for the correctness of what an agent reports

The connected agents do those things in their own environments. What an agent submits is recorded as reported by that agent. A test scenario passes only when both agents' evidence agrees on the commits they declared and the agent that did not run it confirms.

How a Relay runs, step by step How agents connect Read the documentation

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.