Inspiration
Autonomous agents can already decide what to buy. What they can't do safely is pay for it and then trust what they got. x402 lets an agent pay per call in USDC, but it stops at "payment sent" — nothing proves the agent received what it paid for, and the whole agentic stack fills that gap with trust or a mock. We wanted an agent that pays entirely on its own, and a way to prove — cryptographically, on-chain — that the money actually bought something real.
What it does
Predge is two halves of one idea, both live:
The buyer — an autonomous agent that discovers a price, checks it against rules it enforces on itself, and pays per call in USDC from its own Circle Agent Wallet (2-of-2 MPC, no API key, no human in the loop). It refuses quotes over its own ceiling, pins the asset and the payee, and after every purchase it verifies the ed25519 signature on what it bought — so it trusts the data, not the seller.
The settlement layer — a native ERC-8004 validator on Arc with the guarantee the field is missing: the acceptance test is committed before the work exists, the verdict is ed25519-signed and can never be rewritten, and the validator stakes USDC that anyone can slash on-chain if it lies. An ERC-8183 evaluator settles jobs in USDC off that verdict.
The result is a real, verifiable USDC transaction executed by the agent itself — wallet and transaction on a public block explorer.
How we built it
- Payments: x402 (HTTP 402 → pay → collect), EIP-3009
transferWithAuthorization, USDC on Base mainnet. The agent pays from a Circle Agent Wallet driven through the Circle CLI. - Verification: ed25519 signing plus a standalone offline verifier (predge-verify.vercel.app) — no Predge code and no Predge server needed to check a record.
- Settlement on Arc: four tiny, non-upgradeable Solidity contracts — PredgeAgentValidator (ERC-8004), PredgeValidatorBond (trustless on-chain slash via the sha256 precompile), AgentJob (ERC-8183 evaluator), and PredgeOracle (outcome resolution). Node.js + ethers v6.
- Distribution: MCP tooling so agents consume it as a native tool.
Challenges we ran into
- Circle Agent Wallets have no SDK or API key — only a CLI authenticated by an emailed one-time code. Making the agent fully autonomous after that human-once boundary, and being honest about where the boundary is, took care.
- x402 settles before the request handler runs, so a failed call after payment still costs money. We had to make the agent count paid-but-failed calls and stop, instead of bleeding out.
- Making a dishonest verdict slashable trustlessly — with no arbiter — meant leaning on the on-chain sha256 precompile against a deterministic acceptance test committed before the work.
Accomplishments that we're proud of
- A real autonomous USDC payment on Base mainnet from a Circle Agent Wallet — wallet
0x442fab3ab4927889ec6bf840d97cb77de05b727e, verifiable on BaseScan. - The full agentic-settlement stack deployed and running on Arc testnet, each with a one-command live demo producing real transactions.
- Every claim is independently checkable — on a block explorer or against a published ed25519 key — without asking us for anything.
What we learned
Matching a signed-receipt format is commodity; several teams already do it. The only defensible thing is a verdict that is committed before the outcome and backed by capital that is slashed when it's wrong. Trust in agent commerce isn't a signature — it's skin in the game.
What's next for Predge
Arc mainnet deployment at the September 16 launch; Circle Paymaster + Gateway nanopayments so agents request and read verdicts with sub-cent, gas-free USDC; and getting named as the independent evaluator on real Arc jobs.
Log in or sign up for Devpost to join the conversation.