Agents Are Running Real Systems. Here's the Payment Infrastructure They're Missing.

A new post from a16z crypto — authored by Christian Catalini, Andy Hall, Noah Levine, and Christian Crowley — landed this week with a clear thesis: AI agents have moved from copilots to economic actors faster than the infrastructure around them. Identity doesn't travel. Payments aren't programmable by default. Coordination happens in silos.

Their argument is that blockchains close these gaps at the infrastructure layer. Public ledgers give every transaction an auditable receipt. Wallets give agents portable identity. Stablecoins provide an alternative settlement layer. And crucially: these aren't future primitives — they work today.

We agree with the diagnosis. We're one of the companies building in this space, so we want to add some texture to the payment rails piece specifically — where it stands, what's still hard, and what the architecture needs to look like to actually work at scale.

The headless merchant problem

The a16z post makes a sharp observation about a new class of economic actor emerging: "headless merchants." These are API providers with no frontend, no checkout page, no sales team. Just a server, a set of endpoints, and a price per call. Agents read schemas, send requests, pay, and receive outputs in a single exchange.

This is real and it's already happening. Stripe and Tempo's MPP marketplace aggregated 60+ agent-facing services and processed more than 34,000 transactions in its first week, with fees as low as $0.003. Coinbase's x402 protocol is processing roughly $1.6 million per month in agent-driven payments after filtering out wash trading. Stripe, Cloudflare, Vercel, and Google have all integrated x402 into their platforms.

The infrastructure is scaling faster than the transaction volume. That gap closes as agents become the default buyer.

This is the underwriting problem that makes traditional payment rails a poor fit for agent commerce. A headless API provider doesn't have a legal entity structure that maps neatly to a Stripe merchant account. An AI agent making 10,000 purchases per hour doesn't fit the fraud model built for humans with credit cards.

Stablecoins on open networks bypass this entirely. Any developer can make an endpoint payable without integrating a payment processor. The agent presents credentials, the endpoint verifies them onchain, and USDC settles instantly. No underwriting. No billing cycle. No chargeback risk.

What programmable payments actually require

The a16z piece touches on user control and spending policy as a key requirement — MetaMask's Delegation Toolkit, Coinbase's AgentKit, and similar frameworks that let users define at the smart contract level what an agent can and cannot do. This is important and often underestimated.

Giving an agent access to money without constraints isn't autonomy — it's liability. The infrastructure needs to express spending policy natively, not as an application-layer check that can be bypassed. That means:

• Per-transaction limits — no single payment above a threshold without explicit approval
• Category restrictions — this agent can pay for data enrichment but not for compute or storage
• Counterparty allowlists — payments only to verified addresses or registered catalog providers
• Time-bounded budgets — $500 per day, auto-refill from a parent treasury account
• Revocation — kill a wallet's spending power instantly without touching the underlying balance

These aren't nice-to-haves. They're the baseline for any enterprise deploying agents with financial access. The difference between an experimental prototype and a production system is whether the humans who own it can meaningfully constrain what it does.

The identity bottleneck is real — and it affects payments directly

The a16z post's framing of KYA — Know Your Agent — is one of the more important ideas in the piece. In financial services alone, non-human identities already outnumber human employees by roughly 100 to 1. These agents can interact with financial systems but cannot do so in ways that are portable, verifiable, or trusted by default.

This is not abstract. When an agent tries to initiate a payment through traditional rails, the question the network asks is: who authorized this? The answer today is typically an API key tied to a human account. That's a band-aid. The actual authorization chain — which human owns the agent, what constraints they've set, what the agent is permitted to spend — lives nowhere that any counterparty can verify.

Blockchain-based identity changes this. An onchain agent registry can record a cryptographically signed credential linking an agent to its principal, its permissions, and its spending constraints. When that agent presents credentials to an API endpoint, the endpoint can verify the full chain without a centralized intermediary and without a human in the loop.

The a16z piece notes that early implementations are emerging: onchain agent registries, wallet-native agents using USDC, ERC standards for trust-minimized agents. We're building in this direction. The wallet isn't just the place money lives — it's the identity primitive the whole system depends on.

Verification cost as the new constraint

Perhaps the most profound observation in the a16z post is about what becomes scarce when intelligence becomes cheap:

This maps directly to payment infrastructure. As agent-to-agent transactions scale, the cost of verifying that each transaction was authorized — that the agent was acting within its permitted scope, that the counterparty is legitimate, that the amounts are correct — becomes the binding constraint on the system.

Manual audit doesn't scale. Human oversight of individual transactions doesn't scale. What scales is cryptographic verification: receipts that prove authorization, onchain records that prove execution, wallets that enforce constraints at the protocol level rather than the application level.

This is why Proco is built on Base and Solana rather than traditional payment rails. Not because crypto is interesting as a technology, but because USDC on an open network is the only payment primitive that carries verifiable authorization chain all the way down — from the human who set the policy to the agent that executed the transaction to the counterparty that received the funds.

What we're building

The a16z post describes the destination. The infrastructure they're pointing to is what we're building:

• Agent wallets — provision a USDC wallet for any agent in milliseconds. Each wallet carries its own spending policy, enforced at the protocol level.
• Gateway — add a payment layer to any API. Agents pay per call in USDC; providers receive settlement instantly with no underwriting required.
• Catalog — a marketplace of agent-facing APIs with embedded payment. Agents discover services, verify credentials, and pay — all in a single authenticated exchange.
• Treasury management — 4.8% APY on idle USDC float, automated sweep rules, multi-agent budget hierarchies.

The a16z piece ends with a question about whether the infrastructure being built will be designed for maximum transparency, accountability, and user control — or layered on top of systems never meant to support non-human actors.

That question is the reason Proco exists. Traditional payment rails were built for humans with legal identities, billing cycles, and checkout pages. The agent economy needs something different at the foundation: non-custodial wallets, programmable spending policy, stablecoin settlement, and cryptographic authorization all the way down.

The numbers today are early — $1.6 million per month in x402 volume, 34,000 transactions in an MPP marketplace's first week. But the surrounding infrastructure is ready. When agents become the default buyer, the question is whether the payment layer was built for them or retrofitted after the fact.

The original post — "Agents are starting to operate real systems — who's actually in control?" — was written by Christian Catalini, Andy Hall, Noah Levine, and Christian Crowley for a16z crypto in April 2026. The data points cited (100:1 non-human identity ratio, $1.6M/mo x402 volume, 34,000 MPP transactions, $15B NEAR Intents volume) are sourced from that piece.