Agents pay per call. Now prove they got what they paid for.

01The problem

Autonomous agents can already pay each other per call in USDC over x402. But payment is the only solved half — nothing proves an agent got what it paid for, and the whole stack fills that hole with trust or a mock:

• ERC-8183, Arc's job standard, states it outright: "the client is also the evaluator." Whoever pays decides whether the work passed.
• ERC-8004's Validation Registry — the independent-validator piece of the agent-trust standard — is the least-mature, still-unshipped part.
• The top thread in the x402 spec repo (issue #2332, 179 comments) is an open request for exactly a tamper-evident, offline-verifiable proof of delivery.
• Circle's own arc-prediction-markets reference ships a MockOracleAncillary where an admin pushes the result — because no real resolver exists on Arc.

Everyone signs a receipt saying "done." Nobody proves it, and nobody loses money if they're wrong.

02What it is

Predge is the independent validator that stack is missing. It implements the standard ERC-8004 Validation Registry surface — so any consumer settles against it with no adapter — and adds the one property matching a receipt format can't copy: commit-before-outcome.

// PredgeAgentValidator.sol — ERC-8004, live on Arc
function validationRequest(address v, uint256 agentId, string uri, bytes32 requestHash);
function validationResponse(bytes32 requestHash, uint8 response, string uri, bytes32 responseHash, string tag);

// the difference — the response:
if (v.requestedAt == 0) revert NotRequested();   // no verdict on un-requested work
if (v.hasResponse)      revert AlreadyResponded(); // no flipping after the money moves

• Committed before the outcome. The acceptance test is hashed and chain-timestamped before the work exists — so a verdict can't be reverse-engineered from the result.
• Written once, un-rewritable. The verdict is recorded exactly once and reverts on any rewrite. commitLeadTime proves, on-chain, that the test predated the verdict.
• Verifiable offline. The verdict carries an ed25519 attestation anyone re-checks against a published key — no node, no Predge, no trust at read time.

03The stack — live on Arc, Rootstock & Robinhood Chain testnets + Chainlink CRE

Tiny, non-upgradeable contracts. Every demo is one command and produces real on-chain transactions. The same three primitives deploy AS-IS across chains; the bond is denominated in whatever's native — USDC on Arc, Bitcoin (rBTC) on Rootstock, ETH on Robinhood Chain. And the fetch layer plugs into Chainlink CRE: Chainlink for the fetch, Predge for the commit.

04What we're not, and what we are

Honest first: we're not the first x402 on Rootstock — there are 5+ payment-layer repos there already, and Rootstock itself ships an official integrate-x402.md. Stacks has 30+ x402 repos, a live marketplace on mainnet, and aibtcdev ships full agent-payment infra. RDMoutlaw/pay402 already bridges L402↔x402. Payments are covered.

What none of them ship, in one stack:

• A slashable bond, denominated in Bitcoin. Every other x402-on-Bitcoin-sidechain repo is a payment starter kit or a keeper-signed refund. Predge stakes native rBTC — Bitcoin via 2-way peg — that anyone can take by proving a verdict wrong. The contract recomputes sha256 itself; no arbiter, no vote.
• Commit-before-outcome, on-chain provable. The receipt-format crowd decides after seeing the result. Predge's acceptance test is hashed and chain-timestamped before the work exists — commitLeadTime proves it, every time.
• Native to both agent-trust standards — the standard ERC-8004 surface and the ERC-8183 evaluator seat. Not adapters, the interfaces themselves.
• Bitcoin-final settlement. Every verdict batches into a daily merkle root, committed on Rootstock and posted as OP_RETURN on Bitcoin L1. Once anchored, altering a verdict requires rewriting a Bitcoin block — Bitcoin PoW security as the floor.
• Payment-rail agnostic. Lightning (L402), Base (x402), Solana (x402), or anything the pay402 SDK adds — the verdict + bond layer doesn't care. Payment on Lightning, dispute on Bitcoin.

05Who it's for

06Try it & verify

• Arc demos — git clone github.com/predgeAI/predge-arc → npm run settlement:demo, bond:demo, job:demo. Live against the deployed Arc contracts; every hash on testnet.arcscan.app.
• Rootstock demos — git clone github.com/predgeAI/predge-rootstock → npm run bond:demo (stake & slash rBTC, not stablecoin) and npm run anchor:demo (batch verdicts into a merkle root anchored to Bitcoin L1). Every hash on explorer.testnet.rootstock.io.
• Verify a verdict offline — ed25519 checks against a published key with one crypto.verify() at predge-verify.vercel.app — no Predge code, no Predge server.
• Payment rail agnostic — pair with x402 (USDC on Base), L402 (sats on Lightning) via pay402, or any 402-compatible rail. Payment lives wherever; verdict + bond live here.

See the deck → Watch the walkthrough

07Support the work

Predge is independent and self-funded. If it's useful to you, back the build directly — every donation goes straight into development. Any chain works.