Polygon has tested a new payment system for AI agents that processed more than 11 million verified payment updates per second across 25 independently scaling hubs.
The system is designed for software agents that need to pay continuously for services such as AI inference, API calls, data, and other digital resources.
Instead of sending every small payment directly to Polygon as an individual blockchain transaction, the system handles frequent payment updates offchain and settles the accumulated results onchain in batches.
This allows the network to process extremely high volumes of microtransactions without placing the same load on Polygon Chain itself.
Polygon Agent Payment Channels Reach 11 Million Updates per Second
Polygon Labs said the benchmark was carried out using agent pay channels built specifically for autonomous software.
These channels allow AI agents to pay for resources as they use them rather than relying on traditional prepaid accounts or checkout systems.
During the test, each payment update was confirmed by the payment engine in about 20 microseconds, excluding network latency between the user and the payment hub.
Polygon eventually distributed the workload across 25 separate hubs and recorded more than 11 million verified payment updates per second.
The result represents offchain payment processing rather than 11 million onchain Polygon transactions per second.
How Polygon Payment Channels Work
The process begins when a payer deposits funds into a payment channel contract on Polygon.
A session key is then connected to that deposit, setting the amount an AI agent is allowed to spend.
When a service asks for payment, the agent sends signed payment vouchers through a hub as it consumes the service.
The hub checks several pieces of information before approving the payment, including:
- The digital signature
- Requested payment amount
- Replay protection information
- Spending authorization limits
- Remaining funds in escrow
Once the payment is verified, the provider receives confirmation and can release the next part of the service.
That service could be an API response, data query, AI token window, or another digital resource.
Payments Stay Offchain Until Settlement
One of the most important parts of Polygon’s design is the separation between payment activity and blockchain settlement.
Instead of recording every individual payment directly on Polygon, the system processes repeated payment updates through offchain hubs.
The hubs later combine those payment states and post a Merkle root to Polygon.
Service providers can then use cryptographic proofs to demonstrate how much they earned and claim their funds.
This model allows millions of individual payment updates to take place without requiring millions of separate blockchain transactions.
x402 Handles Payment Requests
Polygon’s system uses the x402 protocol for communication between agents and online services.
x402 is based on HTTP’s 402 “Payment Required” status code.
It allows an online service to tell an AI agent that payment is required before access to a resource is provided.
For example, an AI agent may request an API response.
The service can respond with a payment requirement through x402.
The agent then pays through the payment channel and receives access to the requested resource after payment is confirmed.
In Polygon’s architecture, x402 handles the payment request while the agent payment channel processes the repeated financial updates.
Polygon Tested the System With an AI Inference API
Polygon tested the payment architecture against an OpenRouter-style inference API on a live development network.
A payment was triggered for every 100-token window.
Polygon said the payment system itself was real, although the inference provider used in the benchmark was a stand-in rather than a commercial service.
Different parts of the test produced different throughput results.
A complete x402 payment path involving the agent, website, facilitator, and hub processed around 40,000 payments per second.
Polygon said that test completed approximately 2.4 million payments with a 100% success rate.
One Server Processed More Than 530,000 Payments per Second
Polygon also tested the core payment engine independently.
Running on a single 24-core server, the engine processed approximately 533,000 to 536,000 fully verified payment updates per second.
The company then expanded the architecture across 25 hubs.
Each hub operated with 16 virtual CPUs.
With the workload distributed across those independently scaling hubs, Polygon recorded more than 11 million verified updates per second.
Why the 11 Million Figure Is Not Polygon TPS
The benchmark does not mean Polygon Chain itself reached 11 million transactions per second.
The individual payment updates happen offchain.
Polygon’s blockchain is instead used to secure deposited funds and provide final settlement for batches of accumulated payment activity.
This distinction is important because it allows the payment system to scale without requiring every microtransaction to compete for blockchain space.
Polygon’s ordinary onchain throughput remains much lower than the payment-channel benchmark.
More Hubs Could Push Capacity Above 100 Million
Polygon says the architecture can scale horizontally because each payment hub handles its own group of users.
The hubs do not need to coordinate with every other hub while processing individual payments.
As a result, additional capacity can theoretically be created by adding more hubs.
Based on the 25-hub benchmark, Polygon estimates that a larger deployment could process more than 100 million payment updates per second.
Actual production performance would still depend on infrastructure, network conditions, implementation details, and real-world workloads.
Services Can Decide When Payments Are Settled
Another feature of the architecture is flexible settlement.
A service does not have to settle every payment immediately.
Instead, providers can decide when they want accumulated payment activity recorded on Polygon.
Settlement could theoretically happen after:
- A single payment
- Thousands of payment updates
- Tens of thousands of updates
- Millions of updates
This gives developers flexibility to balance settlement frequency, cost, and operational requirements.
Polygon said the benchmark configuration produced an estimated processing cost of about $0.15 per billion payment updates.
x402 Adoption Is Expanding Across Crypto Networks
Polygon’s test comes as interest in x402 continues to grow across blockchain ecosystems.
Developers are increasingly exploring ways for autonomous AI software to make payments without human involvement.
Circle has reported that USDC represented the vast majority of x402 payment volume in data it measured during the second quarter.
Other networks have also begun adding support for the protocol.
Cardano introduced x402 support in September, allowing developers to build applications and AI agents capable of paying with ADA and Cardano-native tokens.
Its initial TypeScript implementation was tested in a preproduction environment.
Bitcoin Lightning Support Comes to x402
Block has also joined the x402 Foundation and contributed Lightning Network support.
That gives developers another payment option based on Bitcoin alongside stablecoin-based systems.
According to the x402 Foundation, the protocol recorded 75.41 million transactions and approximately $24.24 million in volume during a recent 30-day period.
Adding Lightning support could broaden the number of payment methods available to AI agents and automated applications.
Ripple Is Also Exploring AI Agent Payments
Ripple has been pursuing similar infrastructure around the XRP Ledger.
By July, AI agents had reportedly generated more than 1.4 million transactions on XRPL.
Ripple has also been developing tools that could allow autonomous software to use XRP and RLUSD for payments.
These developments suggest that agent-driven payments are becoming an increasingly important area of blockchain infrastructure.
Polygon Agent Payments Fit the Open Money Stack
Polygon’s agent payment channels are expected to become part of its broader Open Money Stack.
The Open Money Stack is designed to bring together payment infrastructure covering:
- Fund transfers
- Digital wallets
- Fiat ramps
- Stablecoins
- Spending rules
- Compliance
- Settlement
Polygon has spent much of 2026 expanding this payments-focused infrastructure.
PayPal’s PYUSD became native on Polygon in July through the Open Money Stack.
Polygon Labs said at the time that its network had processed more than $2.6 trillion in stablecoin transaction volume.
Polygon Has Also Improved Onchain Performance
Polygon has made improvements to its underlying blockchain alongside the new payment-channel architecture.
The network reduced its average block time to approximately 1.75 seconds in May.
That improvement raised Polygon’s estimated theoretical onchain throughput to around 3,260 transactions per second.
Agent payment channels use a very different scaling method.
Rather than attempting to increase onchain capacity enough to handle every microtransaction, the system moves high-frequency payment activity away from the chain and only uses Polygon for final settlement.
AI Agents Could Pay for Services in Real Time
The broader goal is to enable autonomous software to purchase resources as needed.
An AI agent could potentially pay for:
- Individual API calls
- AI inference tokens
- Database queries
- Search results
- Computing resources
- Data feeds
- Completed digital tasks
This could remove the need for an AI agent to maintain separate prepaid balances with every service provider it uses.
Instead, the agent could move between providers and pay for resources dynamically.
Why Polygon’s Payment Channel Test Matters
AI agents are becoming increasingly capable of performing tasks independently, but payments remain one of the major infrastructure challenges for truly autonomous software.
Traditional payment systems were generally designed around human users, accounts, subscriptions, and checkout pages.
Agent payment channels offer a different model where software can automatically authorize very small payments whenever it consumes a resource.
Polygon’s 11 million update-per-second benchmark demonstrates how offchain channels could support this kind of high-frequency machine-to-machine economy.
However, the result should be understood as a payment-channel benchmark rather than the transaction speed of Polygon Chain itself.
The real test will come when these systems move from controlled benchmarks into large-scale commercial environments where millions of autonomous agents may be buying data, compute, and digital services in real time.
