Agentic payments: Evaluating the infrastructure for AI commerce

Agentic payments are payments that a software agent starts and completes on someone's behalf, within limits a person or business sets in advance. This guide covers how they work, the layers of the payment stack an agent depends on, and how to set spending controls and audit trails. For Tempo's approach, see agentic payments on Tempo.

A research agent needs a premium dataset to finish a report. The data provider charges $0.40 per query. A person would create an account, enter a card and pick a plan. An agent needs to see the price, pay it within its budget and get the data in the same request, without anyone clicking through a checkout page.

Merchants are preparing for this. Visa research shows 63% of merchants are actively exploring ways to accept agentic payments. The hard part changes once agents move from recommending purchases to holding spending authority: the payment stack then has to enforce limits on software, at machine speed, and record every payment for later review.

What are agentic payments?

Agentic payments are payments that a software agent starts and completes on a person's or business's behalf, within spending limits and rules set in advance, without a person approving each payment.

Agentic payments vs. agentic commerce

Agentic commerce is the wider process of agents finding, comparing and buying goods or services. Agentic payments are the money movement inside that process: authorizing, sending and settling the payment, then recording it.

Why existing payment flows break for agents

Card checkout and bank payments assume a person is present. They rely on interactive steps such as one-time passcodes, 3-D Secure prompts and manual review. Those steps protect people at checkout, but an agent cannot complete them, and a person approving every call defeats the point of automation.

Agent spending also looks different. Many purchases are small and frequent: a single API call, a minute of GPU time or a slice of a data stream. Card fees and minimums make microtransactions of a few cents uneconomic, and subscription plans assume a long-term customer relationship that a one-off agent task does not have.

How agentic payments work

An agentic payment passes through three functional layers. Each layer can come from a different provider, and each one answers a different question.

At the checkout layer, the Machine Payments Protocol (MPP) gives agents and services a shared format. A service answers a request with the HTTP 402 Payment Required status and a price, the agent pays, and the service verifies the payment and returns the resource. MPP supports one-time charges and metered, session-based billing.

Choosing a settlement rail for agent payments

The settlement rail sets each payment's cost, speed and certainty. The right rail depends on the workload.

• Periodic, higher-value purchases. An agent that buys software licenses or books travel each month can use cards or virtual cards, where chargeback rights and merchant acceptance matter more than per-payment cost.
• Frequent, low-value payments. An agent that pays per API call or per second of compute needs fees well below the payment amount and a clear result within the request. Stablecoins on a low-fee network suit this pattern.
• Payouts to bank accounts. When the recipient needs local currency, an on-ramp or off-ramp provider converts the stablecoins. That leg follows the provider's coverage and local banking hours, and local rules such as capital controls still apply.

On general-purpose blockchains, payment traffic shares blockspace with trading and other activity, so fees and confirmation times can rise during demand spikes. Fees priced in a volatile token also make an agent's budget harder to predict. Developers should check how a network prices fees, whether a confirmed payment can later reverse, and what happens to throughput when the network is busy.

Setting spending controls for agents

Developers should set hard limits on what an agent can spend before granting it access to funds. Controls work best in two layers, so a bug in one does not leave funds exposed.

Wallet layer: session keys

Session keys delegate temporary, narrowly scoped permissions to an agent. The agent signs payments on behalf of the main wallet within explicit limits such as a maximum amount, allowed payment types and an expiry date. For example, a developer could give an agent a key capped at $1,000 that expires on December 30, 2026. The agent can spend up to $1,000 in that period without ever holding the wallet's private key.

Protocol layer: enforced limits

Limits that the network itself enforces protect against compromised credentials or an agent stuck in a loop. If the network rejects any payment over the key's limit or after its expiry, a faulty agent cannot spend past those bounds, whatever its code does. Scopes that restrict which contracts and addresses a key can reach narrow the exposure further.

Traceability and audit trails for agent payments

At high volume, finding a bug or an unauthorized payment requires a reliable record that ties each payment to the work that caused it. Each payment should carry a reference, such as a job ID or API request ID, that links it to application logs.

Transfer memos attach that reference to the payment itself. Memos on a public network are public transaction data, so keep customer details and other sensitive information in internal systems. The same reference also prevents double payment: before retrying, the agent checks whether a confirmed payment with that reference already exists. Reconciliation stays with the business, which still matches payments to orders, jobs and invoices in its own records.

Where Tempo fits

Tempo is a payments network that can serve as the settlement layer for agentic payments, with MPP, which Tempo co-authored with Stripe, handling the request and payment flow above it.

• Onchain settlement in under a second. Stablecoin payments on Tempo settle onchain in under a second with no re-orgs, so an agent gets a definitive result before moving on.
• Payment lanes and stablecoin fees. Payment lanes reserve capacity for eligible payment activity, and sub-cent network fees are paid in stablecoins.
• Access keys. Access keys limit an agent's spending by asset, amount, expiry and permitted calls at the protocol level.
• Transfer memos. Memos attach job IDs or request references to each payment.

The business stays responsible for its agents' logic, budgets, compliance checks, and reconciliation in its own systems. Talk to the Tempo team about settling your agents' payments.

Frequently asked questions

What are agentic payments?

Agentic payments are payments that a software agent starts and completes on a person's or business's behalf, within spending limits and rules set in advance. The agent pays without a person approving each payment.

Do AI agents need to hold crypto to make payments?

No. The Machine Payments Protocol supports both card and stablecoin payments, so developers can choose the payment method that fits their users and application.

How do developers limit what an agent can spend?

Developers give the agent a scoped key instead of the main wallet key. The key carries limits such as a maximum amount, an expiry date and the contracts or addresses it can reach.

What should happen if an agent's payment fails or is duplicated?

The agent should act only on a confirmed success or failure. Before it retries, it should check for an existing confirmed payment, for example by its memo or request ID, so it does not pay twice.

Can agents pay for compute and data, or just APIs?

Agents can pay for any service that accepts machine payments, including compute, data feeds and API calls.

Who reconciles agentic payments?

The business that receives or sends the payment. The settlement network carries the payment and any memo, but the business's own systems still match payments to orders, jobs and invoices.