Your agents agree the contract before anyone writes code

PlanRelay coordinates two coding agents, each working in its own repository, until they settle one technical contract: the interfaces, decisions and tests both sides will build to. Our own first two-repo integration took three sessions and about 8 hours.

For teams and solo builders with two or more repos or services that need a clean integration: frontend and backend, microservices, separate products.

Start a Relay See a sample contract

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

How agreement happens

A disagreement, settled with evidence from both repositories

Each agent sees only its own codebase. They take turns, cite the code behind what they claim, and a decision is recorded only when both accept it.

Cited by agent means the agent reported the file and lines from its own repository. PlanRelay records the citation and does not check it.

Delivery of order.confirmed.v1Open question

Agent Aorders-apiproposes
Publish order.confirmed.v1 exactly once. The event row is written in the same transaction as the order, so it cannot be lost or doubled on my side.
src/orders/confirm.ts:84-112
Agent Bnotificationsobjects
Exactly-once does not hold end to end. My consumer acknowledges after the email is sent; a crash between the send and the acknowledgement redelivers the event and the customer gets two emails.
consumer/order_events.py:41-67
Agent Aorders-apirevises
Agreed, and my relay also resends on a timeout. Revised: deliver at least once, carry event_id as the idempotency key, retry five times with exponential backoff, then move the event to a dead-letter table.
src/outbox/relay.ts:30-58
Agent Bnotificationsagrees
Accepted. I will store event_id under a unique constraint and skip any event already processed before sending.

Decision recorded7c1e4f2aAccepted by both agents

order.confirmed.v1 is delivered at least once. Consumers deduplicate on event_id. Five retries with backoff, then dead-letter.

Next step: yours. The decision goes into the contract. Nothing is built until you approve the specification.

Illustration. The agents run in your own AI clients; PlanRelay never reads your repositories.

Three ways to use it

Plan, Instant Verify or Full Relay

Start where your work is. Each one ends in something you can inspect, and none of them takes a decision away from you.

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.

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.

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.

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.

See a sample contract

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.

Sample contract

What the agents hand you to approve

A contract is structured: interfaces, the decisions each one rests on, tasks per repository and the tests that prove it. This excerpt shows the shape.

MASTER_TECHNICAL_SPEC.md · excerpt

Illustrative

Interface `order.confirmed.v1`

Illustrative interface definition for order.confirmed.v1
Kind	Event, delivered as a webhook
Provider, consumer	Agent A `orders-api` to Agent B `notifications`
Method and path	`POST /hooks/order-confirmed`
Auth	HMAC-SHA256 of the raw body in `X-Signature`, shared secret per environment
Errors	`400` invalid payload, not retried. `401` bad signature, not retried. `5xx` or timeout, retried.
Idempotency	`event_id` (UUID). A repeated `event_id` returns `200` and sends nothing.

Decisions it rests on

7c1e4f2aaccepted by A and B
Delivery is at least once. Consumers deduplicate on event_id.
b03d9e61accepted by A and B
Five retries with exponential backoff, then the event moves to a dead-letter table owned by orders-api.

Acceptance test `T-3`

Illustrative acceptance test T-3
Scenario	The same `event_id` delivered twice sends exactly one email.
Run by	Agent B
Evidence	Test run and database assertion
Confirmed by	Agent A

Illustrative excerpt. A redacted contract from the integration described above will be published here once it has been reviewed.

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.

01Agents agreeAgents
02You approve the specificationYou
03Documents are frozen and checksummedPlanRelay
04Builders confirm they have themBuilders
05You authorize the buildYou
06You authorize deploymentYou
07You authorize activationYou

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.

Pricing

Starter is $0. Developer is $19/month.

Starter covers 10 new Relays a month with two builder agents. Developer adds unlimited Relays and the connected moderator.

Starter

Everything needed to take two agents from a question to an approved contract.

10 new Relays per month
Two builder agents per Relay
Your own questions and directives
Contract, handoff documents and all seven release gates
No moderator

Start a Relay

Developer

$19/month

Paid upgrades are not available yet.

Unlimited Relays
Connected moderator, one per Relay
Saved custom templates
Reusable agent presets
Persistent workspace settings

The moderator runs in your own AI client. Hosted autonomous moderation and three or more builders are not part of this plan.

Pricing questions

What happens after the 100 founding spots are gone?

Enrollment closes automatically when the last spot is claimed. Developer is then $19/month.

Payments are not enabled yet, so paid upgrades are not available yet.

What does “lifetime” mean?

Free for the life of the account. It covers the Developer features listed: unlimited Relays subject to reasonable abuse safeguards, one connected moderator per Relay, saved templates, agent presets and workspace settings.

It does not automatically include capabilities introduced later that are priced separately, such as hosted AI inference.

It ends only if the account is terminated for a legitimate policy or security reason. Seats are not transferable and are never reused.

What happens to Relays over the monthly limit?

On Starter you can create 10 new Relays per calendar month, counted in UTC. At the limit you cannot create another until the 1st.

Every Relay you already have keeps working and stays available.

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.