Predge is a native ERC-8004 validator on Arc with the one guarantee the field is missing: the acceptance test is committed and chain-timestamped before the work exists, the verdict is ed25519-signed and un-rewritable, and the validator stakes USDC anyone can slash if it lies. Settlement an agent can trust without trusting us.
Autonomous agents now discover a price, pay per call in USDC over HTTP 402, and settle with no human in the loop. Circle put its weight behind exactly this — the Agent Stack, Nanopayments, and Arc.
When machines transact, the missing piece isn't payment — it's proof the paid-for work was actually delivered.
x402 proves an agent paid. Nothing proves it got what it paid for — and the whole agentic stack fills that hole with a mock or a trusted party.
Arc's own job standard: "the client is also the evaluator." Whoever pays decides whether the work passed. No independent check.
The 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 — 179 comments — is a request for exactly this: a tamper-evident, offline-verifiable proof of what an agent delivered.
circlefin/arc-prediction-markets 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 pays if they're wrong.
A verdict is only trustworthy if it couldn't be reverse-engineered from the result. So Predge commits the acceptance test on-chain while the work doesn't exist yet, then answers against it — signed, and impossible to rewrite.
The signed acceptance test is hashed and chain-timestamped before the worker delivers. Hindsight is impossible.
The validator runs the committed test and emits an ed25519-signed, offline-verifiable result. Written once.
Any Arc contract settles USDC off the free on-chain read — pay on pass, refund on fail. No admin verdict.
No edit path, no upgrade, no override — not even for us.
Eight teams are racing to author a receipt format. That's commodity — everyone signs the same bytes. Predge implements the standard ERC-8004 Validation Registry surface, and adds the one property matching JSON can't copy: commit-before-outcome.
// standard ERC-8004 surface any consumer already calls: 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 REVERTS unless the request came first, // and can never be rewritten — if (v.requestedAt == 0) revert NotRequested(); // no verdict on un-requested work if (v.hasResponse) revert AlreadyResponded(); // no flipping after the money moves
Because the acceptance test is deterministic (a sha256 the deliverable must match), a lie is provable on-chain. The validator stakes USDC behind every verdict, and anyone can take that stake by proving the verdict wrong — the contract recomputes the hash itself. No arbiter, no vote.
The validator posts a USDC bond and commits the deterministic test, before the work.
Anyone submits the delivered bytes; the contract recomputes sha256. A verdict that contradicts the committed test is slashed to the challenger.
An honest verdict is unslashable — the challenge reverts. You can't grief a validator that told the truth.
Reproducible in one command each (npm run settlement:demo · npm run bond:demo).
| ERC-8004 validationRequest — acceptance test committed before work | on Arc ✓ |
| validationResponse — worker delivered, score 100, ed25519-signed | DELIVERED |
| a worker delivers garbage → validationResponse score 0 | FAILED → refund |
| rewriting a verdict / judging un-requested work | reverts |
| a validator lies → anyone re-runs sha256 → bond slashed 0.001 → 0 | SLASHED |
| an honest verdict challenged | unslashable |
x402 charges per call in USDC on Base mainnet; on Arc every stake, bond, settlement and slash is native USDC.
The paying agent settles from a Circle Agent Wallet — 2-of-2 MPC, key shares never exposed. Autonomy inside custody it can't override.
USDC-denominated gas, onchain FX and deterministic finality — where the validator and its bond live.
Roadmap: Circle Paymaster + Gateway nanopayments so agents buy signed verdicts with sub-cent, gas-free USDC; StableFX for multi-stablecoin bonds; CCTP to carry attestations across Base ↔ Arc.
A generic validator is commodity. The wedge is a vertical where an independent, real-world outcome — not a client's say-so — decides the verdict. Predge's first is the one it already runs end-to-end: prediction-market and real-world-event resolution.
A market outcome is just an agent job whose acceptance test is "what actually happened." Predge already resolves these on Arc — pre-commit, settle, un-rewritable — replacing the admin mock in Circle's own reference.
Anyone can sign a receipt. Resolving a contested real-world outcome, committing before it's knowable, and staking on being right is the part the receipt crowd can't copy — and it's worth most where money settles on the answer.
Multi-validator keys, batch attestations, a subgraph, a consumer interface — and Arc mainnet deployment at the Sept 16 launch.
An escrow that pays/refunds off the validator, plus an ERC-8183 evaluator adapter — what Circle can point builders at instead of a mock.
Circle Paymaster + Gateway nanopayments: agents request and read verdicts with sub-cent, gas-free USDC.
A public spec + reference verifier so anyone — even a competing validator — can check a Predge verdict offline.
Every request, verdict, bond and slash is native-USDC activity on Arc.