Suppose you ask an agent for a market report. Before you see a word, it has bought a dataset, paid for a calculation and checked the result with another service. You made one request. It made several purchases.
Now give that agent a recurring task. Then give a business a few thousand of them. The interesting part is how often they might pay: quietly, in the background, for things too small to justify a checkout page.
That is the payment problem I want to explore. Can existing networks absorb it? Do Bitcoin, Ethereum or Kaspa offer a better route? And how much of the answer has anything to do with the speed of a blockchain?
Bots are already here. Buyers are another matter.
There is an appealing story here: people used to browse the web, agents will take over, and payments will follow. I think the direction is plausible. The starting point needs a little care. Search crawlers and other bots have been using the web for decades; automated traffic is nothing new. Software being able to choose what to buy is a bigger change.
Cloudflare says non-human traffic has passed 50% in its July 2026 agentic-internet report. That tells us about traffic seen from a network provider’s position. It does not tell us how many independent agents exist, much less how many have money to spend. A crawler can visit ten thousand pages and buy nothing.
One person could run several agents. A business could run thousands. So agents outnumbering people would not surprise me. Agents making most payments is a further step, though, and we do not yet have a reliable global count showing that it has happened.
How much are we paying already?
For a sense of scale, McKinsey’s 2026 Global Payments Report puts annual transaction volume at approximately 3.8 trillion. Divide that across a 365-day year and you get 10.4 billion a day, or about 120,500 a second.
I will use that as the existing payment economy. It includes business transactions and flows that are already automated, so calling it a count of “human payments” would be misleading. It is broader than card purchases, too.
Visa gives us a narrower reference: 257.5 billion processed transactions in fiscal 2025, including payment and cash transactions, according to its reported results. That works out to roughly 8,165 a second. Those transactions belong inside the wider market estimate; we should not add the two numbers together.
Ordering groceries is one thing. Buying a hundred services is another.
If an agent orders my groceries, the supermarket still gets one payment. I have handed over the shopping task. I have not necessarily created another transaction. There is work to do on authorization and accountability, but the volume argument is fairly ordinary.
Paying for services along the way is different. An agent might buy a fresh market-data query, an extraction from a filing, a forecast and a second opinion. Each could be a separate purchase. A monthly subscription that once produced one charge could become thousands of tiny payments, even if the customer’s total spending barely changes.
That second case is what the table models. I count additional paid events, with one payment per event if each is settled separately. Free requests, internal model calls and checkouts merely delegated by a person are left out. The adoption levels are assumptions, with no dates attached.
| Scenario | Active agents | Paid events / agent / day | Extra payments / day | Total average / second* |
|---|---|---|---|---|
| Early scale | 100 million | 10 | 1 billion | 132,071 |
| Machine services | 1 billion | 100 | 100 billion | 1,277,905 |
| Stress case | 10 billion | 1,000 | 10 trillion | 115,861,238 |
*Existing 3.8 trillion/year baseline plus additional agent events, divided by 86,400 seconds/day. These are assumed workloads, not adoption forecasts or estimates of present agent activity.
From today’s baseline to a machine-payment workload
The middle scenario is the one I find most useful to think about. A billion agents, each making a hundred paid calls a day, would account for about 90.6% of payment events. A hundred calls is roughly one every fourteen minutes. The workload looks unremarkable for an individual agent; across a billion of them, it is enormous.
Someone still has to pay the bill. A hundred billion daily purchases at $0.001 each cost $100 million a day. Raise the price to $0.10 and the bill becomes $10 billion. Those purchases only happen if the work is worth buying. A busy agent is not automatically a useful customer.
Change the assumptions yourself
Agent-payment demand calculator
What are we asking each network to do?
This is where the usual transactions-per-second comparison starts to fall apart. What is being counted? Visa authorization messages? Confirmed Bitcoin transactions? Plain ETH transfers? Stablecoin payments with wallet checks? Each asks the system to do different work and reaches a different point in settlement.
For the base chains, the chart uses a simple calculation from their resource budgets. It leaves out existing demand, headroom, block overhead and other constraints. Treat the figures as worked examples you can inspect, rather than results from a payment load test.
Illustrative base-layer transfer budgets
Bitcoin needs the Lightning discussion
Putting every agent purchase directly on Bitcoin is hard to reconcile with these workloads. The calculation uses its 4-million-unit block-weight limit and roughly ten-minute block interval. Different transaction sizes and batched outputs change the number of payments that fit. They do not make block space unlimited.
Lightning is the more relevant part of the Bitcoin discussion. Payments move through channels, with Bitcoin handling funding and settlement. That makes small, repeated BTC payments possible without recording each one on the base chain. The practical questions become routing and liquidity: can this payment actually find a path, and is there enough capacity in the right direction? Lightning Labs’ documentation explains why a funded wallet alone does not answer that question.
I would not put a universal Lightning TPS number beside Visa and declare the problem solved. The network needs to work for the counterparties, amounts and reliability a service requires. If the bill is priced in dollars, someone also has to handle the BTC exchange-rate exposure.
Ethereum, beyond the base chain
For Ethereum, the chart follows the documented block configuration and the 21,000 gas required for a plain ETH transfer. A stablecoin payment or a smart-wallet policy check does more work. We cannot use the simple-transfer figure as their capacity estimate.
The case for Ethereum is really a case for Ethereum with its rollups. High-volume execution can happen away from L1, while the base layer supports settlement and data availability. That is a useful arrangement for stablecoins and programmable spending rules. It still needs a capacity budget.
An agent may have funds on one rollup while the service accepts another. A sequencer may be unavailable. Proofs take resources, data costs money, and withdrawal and finality assumptions vary. I would want those details tested before relying on a service. Summing the advertised TPS of several chains tells us very little about whether the payment will go through.
Visa has the merchants
For an agent buying shoes or booking a hotel, Visa has a straightforward advantage: the merchant already accepts it. Issuers and merchants also have an established way to handle disputes. Visa’s Intelligent Commerce offering describes credentials, controls and authentication for agents, although it says deployment is in progress and final features may differ.
Visa cites up to 83,000 transaction messages per second in a 2025 infrastructure article. The word “messages” matters. This is neither the annual average count nor a promise of that many fully settled purchases every second indefinitely. Issuers, acquirers and downstream settlement have their own requirements.
A card payment for a pair of shoes makes sense. A card charge for every fraction-of-a-cent data query is harder to justify. Metering usage and sending an aggregate bill could be a better answer, while keeping the same card rails underneath.
Where Kaspa could fit
Kaspa is interesting because it pursues higher throughput within proof of work, using a blockDAG. Its project description reports 10 blocks per second and the June 2026 Toccata upgrade, which adds covenant-based programmability. The older description of Kaspa as having no programmability no longer fits.
The chart’s 2,500 transfers a second is a compute-budget illustration from the mainnet parameters, assuming 2,000 compute-mass units per transfer. Storage mass, scripts, transaction structure and node performance can bring it down. Block frequency alone cannot tell us either payment throughput or the confirmation confidence needed for a particular transaction.
I would want to test Kaspa for small native transfers. For a full payment service, I would also ask what wallets customers use, how merchants get paid in their preferred currency and where liquidity comes from. If stable-value assets are required, their maturity matters as much as the chain’s speed. The new programming capabilities are promising; production use still has to be demonstrated.
| Approach | Best candidate role | Can it carry every scenario as individual payments? | Main hurdle |
|---|---|---|---|
| Bitcoin L1 | Funding and settlement | No under the illustrated budget | Block space, fees and confirmation latency |
| Bitcoin + Lightning | Repeated small BTC payments | Not established by a global TPS number | Channel liquidity, routing and currency exposure |
| Ethereum L1 | Settlement and programmable assets | No under the illustrated budget | Gas per payment and congestion |
| Ethereum + rollups | Programmable stablecoin payments | Requires rail-specific testing and distribution | Data/proof capacity, liquidity and interoperability |
| Visa | Delegated merchant checkout and aggregate bills | The cited message figure cannot establish it | Small-payment economics, controls and downstream capacity |
| Kaspa L1 | Fast native-asset transfers | No under the illustrated 2,500/s workload | Resource limits and payment ecosystem maturity |
This is an architectural assessment, not a claim that one provider should carry all global payments. Real traffic is split across many networks. “No” refers to individually settling the modeled global workload on that L1, not to serving a useful share of it.
Do we need to settle every purchase?
There is another way to approach the million-payments-a-second problem: ask which payments need to settle separately. In the middle scenario, agents alone produce about 1.16 million paid events a second. Net a hundred eligible events into each settlement and the external-transfer requirement drops to about 11,574 a second. At a thousand, it is roughly 1,157.
Same work, fewer external settlements
This is already familiar in ordinary billing. A service keeps track of usage and charges periodically. Recurring counterparties can use channels. Rollups batch execution and publish the data and proofs their design requires. Each reduces a different part of the workload. There is still an account to keep, and somebody has to bear the risk between service delivery and settlement.
x402 addresses another piece of the problem: letting software negotiate a payment through HTTP 402. That makes a paid API easier for an agent to use. It does not supply a new consensus network or remove the underlying rail’s fee, liquidity and capacity constraints.
I would also be careful about reading payment dashboards as evidence that autonomous commerce has arrived. A 2026 paper on x402 examines adoption and authenticity. Counts need to separate genuine purchases from synthetic activity, incentives and existing software given a new label.
What happens when the agent gets it wrong?
Before I trusted an agent with money, I would want a very clear mandate: who it can pay, how much, for how long, and how to revoke that permission. The payment signer should enforce those limits separately from the model. A page the agent reads should never be able to rewrite its spending authority.
Then there is the less glamorous problem of retries. The agent pays, the request times out, and it tries again. Did it just pay twice? A usable system needs receipts and a way to connect each charge to the permission and service behind it. Confirmation that money moved is only part of the record.
Small payments are unforgiving. On a $0.001 purchase, an all-in cost of $0.0001 is already 10%. A $0.01 cost is 1,000%. These are examples, not fee quotes. Even with a cheap chain transfer, somebody pays for signing, fraud checks, reconciliation and failed attempts.
Dollar-priced bills create another question: what balance should the agent hold? Stablecoins make the denomination easier to manage, but bring issuer, reserve, redemption and chain risks. Circle’s reserve disclosures describe USDC’s backing. A wallet, bridge or venue using USDC has its own risks on top.
If a purchase goes wrong, the person or business behind the agent will still need a refund, an explanation or a dispute process. The relevant rules depend on the service and jurisdiction. FATF’s virtual-asset update is a reminder that choosing crypto rails does not remove compliance obligations.
And agents need not spread their activity neatly through the day. A market announcement could send thousands of them to the same service at once. Failures could trigger more requests. That is why the scenarios include a peak factor: the system needs headroom, backpressure and a way to stop spending when something breaks.
I would expect several payment paths
I find a mixed system more convincing than a single winning network. Cards and bank rails can handle ordinary purchases and consolidated bills. Lightning offers a route for repeated BTC payments. Stablecoins on suitable rollups or other networks can serve paid software services. Kaspa has a case to make where its native transfers and application layer meet the job’s requirements.
A grocery order and a thousand market-data queries should not have to use the same payment path. I would keep spending permissions, pricing currency, execution and final settlement separate enough to choose what fits each job.
The number I would watch is how many useful purchases a system can complete at an acceptable total cost. More agents can mean more payment instructions without more spending, and more paid events without a matching number of external settlements. Those distinctions will decide what scales. A billion agents are an intriguing possibility. Paying separately for every small thing they do is a choice.
