Agentic payments: Evaluating the infrastructure for AI commerce

Today's payment infrastructure assumes humans drive every transaction. AI agents change that assumption. Conventional payment rails rely on interactive authentication steps and manual oversight. These safeguards function well for human checkout but cause friction for autonomous software. Agentic AI requires machine-readable, automated workflows capable of executing low-value, repeatable transactions without human intervention. Visa research shows 63% of merchants are actively exploring ways to welcome agentic payments. As a result, developers need secure, reliable settlement rails that enforce hard spending boundaries at machine speed.

The biggest operational shift occurs when autonomous agents move from recommending purchases to holding spending authority. At that point, the infrastructure must enforce strict boundaries without degrading transaction throughput. This article covers three critical requirements to build this infrastructure: the underlying settlement rail, multi-layered spending controls, and reliable transaction traceability.

What's the best agentic payment infrastructure for AI developers?

No single payment processing infrastructure fits every autonomous workflow. An agent making periodic, high-value procurement purchases requires a different architecture than one executing continuous microtransactions for compute or data streams.

To evaluate the options, developers structure agentic payments infrastructure into the following distinct functional layers:

• Authorization. The control layer specifies exactly what an agent can spend, including programmatic limits, expiration windows, and merchant constraints enforced at the point of payment.
• Checkout. The initiation layer handles how an agent presents credentials to start a payment, like session keys or virtual card details.
• Settlement. The settlement layer transfers funds, updates official records, and marks the transaction as complete for both the agent and the counterparty.

To standardize machine-to-machine interactions across these layers, Tempo and Stripe co-authored the Machine Payments Protocol (MPP). MPP uses the web's built-in HTTP "402 Payment Required" response to set up an instant, automated conversation between AI agents and services. This enables both one-time purchases and continuous, metered billing.

However, that doesn't mean MPP works for every scenario. To decide what makes the most sense for agentic payments, developers need to look into the underlying settlement layer, spending controls, and traceability.

Is the settlement rail scalable for your agents?

MPP defines how agents and services communicate around a payment challenge. The underlying settlement rail dictates each transaction's cost, speed, and reliability.

For high-frequency agentic volume, general-purpose Layer 1 and Layer 2 blockchains create operational bottlenecks. Shared execution environments mean payment traffic competes directly with high-volume DeFi trading or NFT activity. This can lead to unexpected fee spikes, latency, and congestion.

Tempo addresses this issue by operating a purpose-built Layer 1 payment rail. Rather than sharing state execution with arbitrary smart contracts, Tempo provides dedicated infrastructure engineered specifically for payment settlement:

• Dedicated payment lanes. Traffic stays isolated from unrelated network activity. Because Tempo reserves blockspace for payments, throughput remains stable during network demand surges.
• Settlement with no re-orgs. Autonomous agents can't waste time guessing whether a transaction will clear or reverse. Payments on Tempo settle onchain in under a second with no re-orgs, so agents get a definitive settlement confirmation and can safely move to the next task.
• Dollar-denominated fee economics. If transaction fees fluctuate with congestion or depend on a volatile token, developers lose cost control. Tempo prices transaction execution in sub-cent fees paid in dollar-denominated stablecoins.

Can developers set budgets and approval limits?

Before granting agents autonomous access to funds, developers must enforce hard boundaries at the wallet layer and the protocol layer.

Wallet layer: Session keys spending limits

Developers delegate temporary, narrowly scoped permissions to an agent using session keys. The agent transacts on behalf of the primary wallet within explicit limits like maximum amounts, transaction types, and expiration dates.

For example, a developer could create session keys for their agent with a max spending cap of $1,000 and an expiration of December 30, 2026. Within this period, the agent would have authority to spend up to $1,000 without direct access to the wallet's private keys.

Protocol layer: Protocol-enforced spending controls

Protocol-level safeguards protect systems against compromised agent credentials or logic loops. On Tempo, access keys enforce spending limits and expiry at the protocol level, and call scopes restrict which contracts and addresses a key can reach. These extra controls limit exposure if the agent software behaves unexpectedly.

Traceability and auditing for autonomous payments

Helping agents pay is only part of the work. Developers also need reliable, automated auditability. Without a reliable payment record, investigating systems for bugs or unauthorized activity becomes nearly impossible at high volumes.

On Tempo, each payment can carry a memo that ties the transaction to application-level context like job IDs or API request parameters. This data gives developers a clear audit trail to identify issues and troubleshoot individual transfers.

Note that Tempo provides the settlement infrastructure and carries the memo, but it doesn't act as the internal system of record. The receiving system still handles transaction reconciliation and auditing.

Where Tempo fits in the agentic payments stack

Tempo's payment-dedicated rail functions as the settlement layer of the agentic payments stack. Once an agent determines it needs to make a purchase, Tempo processes, confirms, and settles the transaction via its payment-isolated Layer 1 rail.

At the application level, MPP serves as the open protocol co-authored by Tempo and Stripe to structure machine-readable interactions over HTTP. Merchants request payments, agents authorize them, and the service verifies the transaction without human intervention. MPP also supports session-based payments so agents can make multiple related transactions instead of settling each independently.

Find out more about how Tempo and MPP can handle your agentic payment workloads.

FAQ

Do AI agents need to hold crypto to make payments?

An AI agent doesn't necessarily need to hold cryptocurrencies or manage a crypto-compatible wallet to make payments. For instance, MPP supports both card and stablecoin payments. Developers can choose whichever settlement method works better for their users and applications.

What should happen if a payment fails or is duplicated?

On a rail with no re-orgs, each payment returns a definitive success or failure, so the agent doesn't act on a result that later reverses. When a payment doesn't go through, the agent retries based on that confirmed outcome. To avoid paying twice, the agent should check for a confirmed payment, for example by its memo or request ID, before it retries.

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

Agents can autonomously pay for any services they consume, including compute, data, and APIs.

What does the best payment option depend on?

The "best" payment option varies by application. Finding the right infrastructure depends on what the agent has to do and how much authority users need. Ideally, the tech stack matches an agent's workload while keeping payments predictable and controllable.

---

Talk to the Tempo team about settling your agents' payments on Tempo.