What is agentic payment infrastructure?

The systems that let software pay for things without a person at the keyboard: rails that move value, protocols that structure the exchange, and the identity, authorization, and record layers that make it a market rather than a leak.

Agentic payment infrastructure is the set of systems that let software pay for things without a person initiating each payment. That sentence covers a great deal, and most of the confusion around the term comes from collapsing it into one layer, usually the rail. A rail is necessary and it is the least of it. Payment infrastructure for agents has four layers, and a deployment that has only one of them is not infrastructure; it is a funded key waiting for an incident.

The four layers

Identity. Whose money is being spent, and which agent is spending it. This is the layer most commonly skipped, because the easiest way to give an agent spending power is to give it a credential and call the whole deployment "the agent". Without a persistent identity per agent there is no attribution, no history, no way to revoke one agent without revoking all of them, and, later, nothing to underwrite. Identity is where every other layer attaches.
Authorization. What this agent may buy, from whom, and up to how much, decided before the payment and enforced by something the agent cannot argue with. A limit in a prompt is a suggestion. A limit in the payment path is a control. The authorization layer is a policy: categories, a maximum per call, a maximum per period, a ceiling on the whole account, and a rule for the rare action that needs a human.
Settlement. The rail value moves on. For machine-to-machine payments this is now a stablecoin on a low-fee chain, USDC on Base through x402, or a stablecoin or shared card token through Stripe's Machine Payments Protocol on Tempo, because those are the rails whose fee floor is low enough to make a one-cent payment sensible. For merchant purchases it is still a card, through a checkout protocol that lets an agent act on a person's behalf. The rail decides the smallest economic purchase, which decides whether an agent can meter or must buy in bundles.
Record. What was bought, from whom, at what price, on which key, and what was refused and why. The record is what makes the other three auditable, and it is the raw material for everything more sophisticated that comes after: reputation for sellers, history for agents, and eventually credit.

Who provides what today

The layers are provided by different kinds of organizations, and it helps to know which is which.

The card networks are extending their existing infrastructure toward agents: Visa's Intelligent Commerce and Mastercard's Agent Pay are tokenization and authorization schemes that let an agent transact on a card with the cardholder's delegated consent. They cover settlement and part of authorization, for merchant purchases.

The protocol foundations define the exchange. The x402 Foundation maintains the open standard for paying over HTTP 402 in stablecoins. Stripe and Tempo co-authored MPP for the same class of payment with card and stablecoin methods. Google's AP2 defines mandates, verifiable credentials that prove a person authorized an agent to make a specific purchase, and has been donated to the FIDO Alliance for standardization. OpenAI and Stripe's Agentic Commerce Protocol structures checkout inside ChatGPT. These are settlement and exchange; none of them is an identity or authorization layer for the buyer.

The wallet providers give an agent something to pay from. Coinbase's AgentKit, Privy, and similar products provision on-chain wallets with policy engines around them. Card programs such as Stripe Issuing, and the products built on it for agents, provision virtual cards with controls. These cover identity of a sort, authorization of a sort, and custody, for an agent that is meant to hold value.

The gateways sit in front of the rails on the buyer's side. A gateway holds an account the person owns, gives each agent a key with a policy, holds the provider relationships, pays each provider on whatever rail it accepts, and keeps the record. This is where identity, authorization, and record live for an agent that is meant to hold permission rather than money. Vaaya is a gateway, and it adds one thing the others do not, which is a credit line underwritten on the person behind the agent, so that the agent can spend before anything is deposited.

The distinction that keeps getting lost

Agentic payments and agentic commerce are different problems that share a word. Agentic payments are machine-to-machine: an agent paying an API, a compute provider, a data vendor, or another agent, per call, in amounts from a fraction of a cent to a few dollars, on rails built for that. Agentic commerce is an agent buying from a merchant on behalf of a person, a flight or a pair of shoes, through a checkout protocol, in amounts and with dispute expectations that belong to cards. The first is an infrastructure problem about metering and policy. The second is a consumer-protection problem about delegation and consent. Both are real, both are being built, and almost nothing built for one is useful for the other.

Why the fourth layer is the one to watch

Rails are converging fast and will be commoditized. Protocols are being standardized. Wallets are a solved problem for anyone willing to hold keys. The layer that is not commoditized, and cannot be, is the record, because it accumulates. An agent's economic history is the only asset in this stack that gets more valuable the longer the agent runs. It is what lets a seller be rated, what lets an agent be trusted by counterparties it has not met, and what lets someone extend credit to it. Payment infrastructure that keeps the record, per agent, from the first call, is building the thing every later product in this market will need. Payment infrastructure that only moves value is a utility.

That argument is made at length in the memo on why credit. The protocols are compared side by side in AI agent payment protocols compared.

Questions