An agent-to-agent payment relay is a service where autonomous agents pay each other per request in USDC, settling each call over HTTP using the x402 protocol on Circle's Arc chain. You build a small network of agents that meter their own APIs, charge fractions of a cent per call, and settle onchain without accounts, API keys, or invoices. This is one of the clearest ways to prove you are a real onchain developer, because it forces you to touch wallets, signed authorizations, a facilitator, and native USDC gas in a single working system.
What you are building and who it is for
The build is a relay: a set of small agents, each exposing a paid HTTP endpoint, plus a client agent that discovers those endpoints, hits a 402, pays, and retries. Think of one agent that summarizes a document, another that fetches onchain data, and a coordinator that pays each one per request in USDC. The relay routes work and money together, so every call is priced and settled at the moment of use.
This is for developers who want to move past demo dApps into machine-to-machine commerce. It suits backend and full-stack builders comfortable with TypeScript and HTTP, curious about AI agents but not needing to train models. If you have shipped an API and used a wallet SDK before, this is squarely in reach. It is labeled advanced because you are wiring payments, signatures, and settlement into one loop, not because the individual pieces are hard.
Why this positions you as an Arc and Circle developer
x402 is a real, funded standard, not a thought experiment. Coinbase reported roughly 69,000 active agents, 165 million transactions, and about $50 million in cumulative x402 volume by late April 2026, with launch members spanning 22 organizations including Circle, Visa, Mastercard, Stripe, Google, and AWS. Building a working relay puts you in the small group of developers who have actually shipped against this stack.
Arc is Circle's Layer-1 built for programmable money, where USDC is the native gas asset. The Arc public testnet is live, and mainnet is expected in 2026. Building on the testnet now means you are early on a chain whose whole reason to exist is stablecoin payments and agentic settlement. Circle is also deepening Gateway's integration with Arc, CCTP, and x402, and has launched a Nanopayments system supporting USDC transfers as low as $0.000001 for pay-per-use calls. Learn the pattern that these teams are building around, and you are demonstrably relevant to it.
A concrete build path and stack
Circle's own reference build uses TypeScript, the Circle Developer SDK for wallet management, the x402-express middleware to paywall server routes, and Axios for the client requests. You do not need the AI framework to start; wire the payment loop first, then bolt an agent on top.
Step 1: Set up wallets and testnet USDC
Create EOA wallets with the Circle Developer SDK targeting an EVM testnet, then fund them from Circle's USDC faucet. On Arc testnet, request USDC from the Circle Faucet, since USDC is what pays for gas and contract interaction on Arc.
Step 2: Paywall a server endpoint
Stand up an Express server and apply the x402 payment middleware to your paid routes. The pattern is app.use(paymentMiddleware(recipientWallet.address, routes, facilitator)). A request with no payment returns HTTP 402 with the price and terms. Circle's guide points at Coinbase's facilitator at https://x402.org/facilitator to verify and settle payments.
Step 3: Build the paying client
The client pings the endpoint, receives the 402 with terms, signs a token transfer authorization using Circle's Sign Typed Data API, and retries the request with the signed payload in a header. The agent never broadcasts a raw transaction; it signs an authorization and the facilitator executes settlement onchain.
Step 4: Make it a relay
Register two or more paid agents, then have a coordinator agent call each one and pay per request. Add a simple directory so the coordinator can discover endpoints and their prices. This is where per-request pricing becomes real: each hop is metered and settled independently.
Step 5: Move toward Arc
Point your wallets and settlement at Arc testnet, where USDC is native gas. Arc is EVM compatible, so standard tools like Hardhat, Foundry, Viem, and Ethers work if you add any custom contracts.
Common pitfalls
The signed-authorization model trips people up: your agent signs typed data, it does not send a transaction, so debugging means checking the signature payload and the facilitator response, not a mempool. Watch decimals and pricing, because sub-cent amounts make off-by-a-decimal errors easy and expensive to reason about. Treat the facilitator as a dependency you do not control, and handle its failures and timeouts rather than assuming settlement. Fund the right wallet, since on Arc USDC pays gas, so an unfunded agent fails on the pay step, not the call. Finally, never expose signing keys in a client agent you plan to run unattended; keep signing behind your own service.
How DEPLOYR builds and ships it with you
DEPLOYR exists to make you the real onchain developer that airdrops look for, and this project is a strong portfolio piece for exactly that. We help you scope the relay, wire the x402 loop end to end, get wallets and testnet USDC funded, and stand up a coordinator that pays per request. Then we ship it as a public, running storefront project with a clear writeup, so what you built is visible and verifiable instead of stuck on your laptop.
If you want to go deeper on the stack, see /build for the developer path, /hackathons for events where agent payments and Arc fit the tracks, and /insights for more build guides like this one. When you are ready to make it real, start at the DEPLOYR store at / and we will build and ship it with you.
Airdrops are never guaranteed. Nobody can promise you a payout, and DEPLOYR does not. What we can do is help you build real, running onchain work that stands on its own, whatever any token program decides to do.