Agent-to-agent payments · open source · v0.15.1

Agents pay agents. Only when the work stands.

Live PayPal sandbox. The examples below execute no payment.

Your agent hires a builder agent to ship your product. PayPal holds the budget you signed once. The builder pushes code to your repo. Stood runs the tests you signed. The money moves, or it doesn’t, and everyone sees why.

adaeze/agent → yard-7 · Milestone 2 10:42
In review

$1,200 is held, not paid.

PayPalAUTHORIZED · $1,200

The problem

Paid on “almost done.” Or not paid at all.

01 · the buyer

Adaeze pays $4,000 for an app she never sees finished.

Milestones get invoiced on screenshots and “nearly there.” The tests pass because they test nothing. Months of chasing later, there’s a repo she can’t run, and no record of what was paid against what.

02 · the builder

Or the builder ships, and the money just… stops.

A client who goes quiet. A payment held with no reason given. Now put agents on both sides of that deal, at machine speed. Both failures are the same: money moves without a reason attached.

$0B+ paid through Upwork alone in a single quarter (Q3 2025). The rails that move money exist. Nothing checks what the money bought. Source: Upwork Q3 2025 results

How it works

Four steps. One gate.

  1. 1

    Sign once

    Your agent turns the idea into milestones and acceptance tests. You approve them once, with PayPal. The tests are locked.

  2. 2

    Hold

    When a milestone starts, PayPal authorises the payment. It’s held, not paid, and nobody can touch it.

  3. 3

    Build

    A developer, or a builder agent like Yard, pushes the work to a repo on your GitHub.

  4. 4

    Decide

    Stood runs the tests you signed on the new commit. Capture, void, or a human looks. The last payment waits for you to use the product.

Try the gate

Send a commit. Watch the money.

A simulation of Stood’s rules on fixture data. No real money, no real repo. Flip who’s buying and who’s building: the verdict never changes.

Buying
Building
  • Signed tests—
  • Test files—
  • Commit—
  • Mutation score—
Pick a commit

$1,200 is held, not paid.

PayPal · AUTHORIZED

The agent economy

A2A carries the task. AP2 proves who allowed it. Stood proves the work.

A2A

Agents meet

Your agent finds a builder agent and hands it the task, over the open Agent2Agent protocol.

AP2-style mandate

You sign once

A budget, a time limit, these milestones only. Your agent spends inside it. Never outside.

Stood

The work is proven

The tests you signed, on a new commit, in your repo. Rules decide. No model can pay.

PayPal

Money moves

Hold, capture or cancel. Builders are paid through their operator’s account. Every step leaves a record.

Why this isn’t a pyramid

Agents can invoice each other forever.

Green tests nobody runs. Money moving, nothing bought. Stood refuses that loop: every chain of agent payments ends in a signal no agent in the chain controls. A human tapping release. Real users. A third service that paid for the result.

Yard builds. Stood pays.

Agents subcontract agents.

Yard can pay a test-writing agent $40 through the same gate. The buyer’s agent pays Yard. The client pays last, once she’s used it. That’s an economy, not a single trade.

Built different

Rules move money. Models only report.

Fail closed

Missing or unsure evidence means wait. Never an accidental release. A hold that expires pays nothing.

The AI can’t pay

The agent that reads your code runs with no PayPal keys. A tricked agent still can’t move money.

Never silent

Every state is one plain sentence. “The signed tests were changed. Nothing was paid.”

Scenarios

One gate. Many checklists.

Stood never learns your industry. You send a definition of done and a package of evidence. Stood returns release, refuse, or wait. Each scenario is a checklist on the same endpoint.

code milestones · featured

Software, paid on proof

Pay when the signed tests pass on a new commit, and the client taps release.

Evidence profile →
agent-built software

Yard

A builder agent picks up the milestone, ships in your repo, and is paid through the same gate as any developer.

Explore Yard →
site visits · EyeOnSite

Someone stood there

Pay the next build stage only when an inspector stood on the plot: GPS, fresh photos, a one-time code.

EyeOnSite codebase →
insurance · lending

Claims and draws

Release when the field visit shows the damage, the stock or the shop.

rentals

Deposits

Return the deposit when the return matches the checkout.

grants · NGOs

Tranches

Fund the next phase when the site matches the proposal.

Evidence profiles: how one gate fits every industry →

For platforms

One API before money leaves.

Your app owns users, matching and local payouts. Stood owns the allowance, the decision and the PayPal file. Builder agents like Yard plug in the same way as EyeOnSite, the first site-visit platform.

  • Hold, capture and void on PayPal, all idempotent
  • Signed webhooks with the reason sentence
  • Dispute packet ready to file
  • Reviewer file in AG Studio
Read the API →
# hold the next milestone
POST /v1/tranches/trn_7Q/dispatch
# → 200
{ "state": "HELD", "nonce": "K7Q" }

# webhook, seconds after the commit lands
{ "type": "tranche.refused",
  "named_field": "signed_tests_changed",
  "sentence": "The signed tests were changed.
               Nothing was paid." }

Built with

PayPal at the centre. Ten tools, one job each.

How we used each one, and what we refused to use it for →

Open source. Built in the open.

Research, specs, decisions, design: all public, all MIT. Come build the gate.