TL;DR: A few months ago we launched AgentPay, a state-channel network that lets AI agents pay each other in real time, without broadcasting every per-request payment on-chain, and for a fraction of a cent. Now we’ve put it to work. Our new Buyer Agent demo shows an AI agent autonomously buying Polymarket prediction-market data, paying per request through an AgentPay state channel and settling on Base. The buyer bundle is open source and runs with your own Claude or Codex agent.

When we announced AgentPay, we laid out the rails for an agent economy: state channels that let AI agents pay each other in milliseconds, keep those payments private, and skip the gas overhead of writing every transaction to a blockchain. This is the part where the rails start carrying real traffic.

Why agents need their own payment rail

More and more, software agents act on behalf of their users. An agent runs background research across dozens of sources. A trading assistant pulls market data to size up a position. A workflow calls one model to draft, another to review, a third to summarize. Each of those steps increasingly sits behind a paid API.

When a person uses one of these services, paying per call and waiting a second for the answer feels fine, because a human makes a handful of requests and moves on. An autonomous agent works at a different cadence entirely. It fires hundreds of small requests a second, and every one has to clear and pay before the next begins. Picture an agent tracking prediction markets to inform a trade: it pulls a fresh snapshot, reads the odds, pulls again moments later, and repeats across many markets all day. Each call is worth a fraction of a cent, and the agent needs the answer now.

Blockchains can’t keep that pace. On-chain settlement takes seconds to minutes on the fastest networks, and the gas fee on a single transaction can swallow 10 to 50 percent of a few-cent purchase. Even on cheap networks, paying that toll on every call makes the whole model uneconomical. There’s a privacy cost on top, because a public ledger broadcasts who paid whom, how much, and how often, handing competitors a live read on pricing and demand.

AgentPay presents a new model with state channels. Two parties deposit into a channel once, then exchange co-signed balance updates off-chain, instantly and at near-zero cost, for as many transactions as they want. The blockchain comes in only to open the channel, close it, or resolve a dispute. The agent gets the speed and economics it needs, with the security guarantees of the chain sitting underneath. The full design lives in the AgentPay docs.

Watch an agent buy its own data

Today we’re taking AgentPay from architecture to a working demo, a real run you can watch from start to finish. It puts a Buyer Agent in front of Polymarket prediction-market data and pays for every request end to end, wrapped in a portal that shows each step as it happens. The agent checks its own setup, funds an AgentPay state channel with USDC on Base, then runs a paid data export in batches. In the demo it pulls 2,500 market snapshots across five paid calls, each one settled off-chain through the channel for a tiny amount, with the chain touched only to open and close. In a real and live application, this could be hundreds or even thousands of data requests before the channel closes. 

This is the trading-agent scenario from earlier, made real. Rather than one expensive on-chain payment per call or a flat prepaid subscription, the agent streams many small payments through the channel and gets its data back at conversation speed.

Inside a single paid call

Underneath each of those calls is a simple handshake. The agent is an ordinary Claude or Codex coding agent with an AgentPay skill installed, so anyone already working with those tools can run it. When the agent asks for data, the seller’s API answers using x402 (an open standard for how a service requests payment from an agent) to return a payment challenge before serving the paid response. x402 specifies the payment request and leaves open where the payment actually settles, and that opening is where AgentPay fits. Instead of paying on-chain for every call, the buyer and seller nodes clear each request across the state channel, so the agent can stream hundreds of paid requests while only the opening deposit and the final balance ever reach the blockchain.

The payoff is what makes autonomous commerce workable. Requests clear in milliseconds, each one costs a sliver of a cent, and the details stay private to the two parties. The deeper mechanics, including conditional payments, multi-hop routing, and dispute resolution, are covered in the docs and the open-source code.

One rail, any paid service

This first example serves prediction-market data, but the payment flow underneath it is the real story, and it works behind any paid endpoint. An inference API, a real-time data feed, a compute service, each can sit behind the same channel, with the service swapped out and the rail left unchanged. As more agents start working autonomously for their users, they need a way to pay for what they consume at machine speed, without leaking strategy or bleeding value to fees. This is what that looks like in practice, and it is something you can run today rather than read about.

Run it yourself

The buyer bundle is open source. Install it into a Claude or Codex project, add a funded key, and your agent can pull the same data through its own state channel. The on-chain contracts and the off-chain node are open source as well.

This is one service on a network built to hold many. We’re working with partners to bring more paid endpoints online and to deepen interoperability with the x402 ecosystem. If you’re building agents that need to buy data, compute, or anything else in real time, this is the rail to build on.