The question every agent payment answers
If you're building a product in which an AI agent buys something on behalf of your customer, whether that's a hotel room, a software licence or a box of printer paper, you'll sooner or later be asked the same question by your customer, your finance team and probably your lawyer as well: what stops the agent from spending more than it should? Over the past year, almost every large name in payments has published an answer to that question, from Mastercard and Visa to American Express, Google, OpenAI with Stripe, and Coinbase, while business-spend companies such as Ramp and Mercury started handing out cards that are meant for agents only.
At first sight, these answers all look alike, because every one of them lets you set some kind of budget. Once you read the documentation, though, you notice that they put that budget in very different places, and I think that place might matter more than the size of the limit itself. A limit that lives inside the agent can be talked out of it, while a limit that lives on the card network can't, no matter what the agent was told by a web page it happened to read.
Not every bank is convinced yet, either. On JPMorgan's third-quarter earnings call this month, Jamie Dimon said the bank won't allow "just any outside agent to come inside the company", because "you don't want rogue agents". Most of what's described below is, in one way or another, an attempt to prevent an agent from going rogue.
Four places a limit can live
To compare all these systems, it helps to look at where the limit actually sits, and I count four places, going from soft to hard.

The first is the agent's own instructions, where you simply tell it not to spend more than a certain amount. That works most of the time, but it's also the easiest place to break, because the agent reads everything it comes across, including text that someone wrote to change its mind. The second is the platform or wallet the agent runs in, which can refuse a payment above a certain amount before it leaves your system. The third is the payment credential itself, a card or token with the limit attached to it, which the card network or the issuer checks whenever the agent tries to pay. The fourth works a bit differently, because it doesn't limit how much the agent spends so much as what it buys, by keeping a signed record of what the customer actually asked for and checking the purchase against it.
The card networks put the cap on the card
The clearest example of the third layer comes from Mastercard. In August, Mastercard put what it calls Token Spend Controls into production, which lets the bank that issued the card set spending rules on the tokens used by Mastercard Agent Pay and its virtual card tokens, after the cardholder has authenticated. The list of rules is quite extensive: a maximum per transaction, a daily, weekly and monthly limit, a lifetime cap the token can never go above, a single-use setting after which the token stops working, and lists of merchants, merchant categories and countries that are allowed or blocked. According to Mastercard's own release notes, it evaluates every tokenized transaction against these rules and declines the ones that break them, which means the agent never even gets a say in the matter.
Visa describes something similar for its Intelligent Commerce programme, with spending limits, approval workflows and authentication requirements built into the credential, although Visa's own product page still says the product is being deployed and that the final version may not contain every feature described. Ramp's agent cards, which are in early access, are a concrete example of it: every card is a single-use Visa token, scoped at the network level, locked to one merchant and capped per transaction.
Proving what the customer asked for
A limit on the amount doesn't help much if the agent spends exactly the right amount on the wrong thing, and that's precisely the gap the fourth layer tries to close. On 13 October, American Express presented its Intent Intelligence Framework, in which the customer's instructions and constraints, such as the merchant, a maximum budget and product preferences, are recorded first and then approved by the customer. That approval produces an Intent ID and a token holding the constraints, which the agent then uses to get a payment credential at checkout, so the agent never sees the actual card number. Amex's own example is a customer who asks for white Nike sneakers in size 9, where the agent tries to buy Adidas instead, and Amex could block that payment before it goes through. Amex hasn't said when or for whom this will be available, though.
Google's Agent Payments Protocol (AP2), first announced in September 2025, is built on the same idea, using signed records that it calls mandates. A Checkout Mandate records what is being bought and a Payment Mandate authorises the payment with a specific card or account, and both come in two stages. The open version holds the user's constraints and goals, such as a budget and the payment methods the agent may use, before there's anything in the cart, which is what lets an agent complete a purchase on its own once those conditions are met. The closed version then authorises one specific, final checkout. Because these records are signed and tamper-evident, they form a trail you can follow back when a customer disputes a payment.
Checkout inside a chat: one-time allowances
For checkouts inside ChatGPT, OpenAI published a Delegated Payment Spec, and Stripe's Shared Payment Token was the first implementation of it. In this set-up, the agent's platform creates a token for a single seller, with a currency, a maximum amount and an expiry date, the token can be used only once, and it can be revoked at any moment, after which the seller can no longer use it to take a payment. Stripe's documentation also says it may use Mastercard Agent Pay or Visa Intelligent Commerce tokens behind the scenes.
What I'd keep in mind as a product team is who sets the maximum here. According to Stripe's documentation, it's the agent's platform that sets the usage limits when it creates the token, usually at the total of the checkout, rather than the customer setting a budget of their own. That's a perfectly reasonable design for a single purchase, but it does mean the customer's budget has to be enforced somewhere else, which brings you back to the question of where.
Paying per request: x402 and agent wallets
Card payments are built for amounts of a few euros or dollars and up, while many agents pay for something much smaller, such as one request to a data service. x402, an open protocol from Coinbase, lets a server answer a request with the HTTP status 402 Payment Required, after which the agent pays in stablecoins and gets the response. Chainalysis counted more than 138 million payments over x402 on Coinbase's Base network, and more than 87% of them were between $0.0001 and $0.10.
At those amounts, a limit per payment doesn't tell you much, which is why Coinbase's Agentic Wallet works with a maximum per call and a maximum per session, both set by the person who funds the wallet in the wallet's own interface. According to Coinbase's documentation, agents respect these limits and can't change them, and they can only pay for x402 services rather than send money to any address they like.
A card of its own: Ramp and Mercury agent cards
For a company that wants to let an agent buy something today, a card that belongs to that agent alone is probably the most practical option. Mercury launched agent cards in August as part of Mercury Spend, and what I like about its design is how clearly it separates what the agent can do from what only a person can do. Through Mercury's API, an agent can retrieve the details of a card assigned to it, but it can't create an agent card, change its limit or unfreeze it, and when you freeze or cancel the card it takes effect right away, without the agent being able to undo it. Ramp's agent cards, described above, work along the same lines, with one card per agent and per transaction.
When you put all of these systems side by side, the difference that stands out most is not the size of the limit but who gets to set it, and whether the agent can change it afterwards.

What a cap can't see
All of these limits do one job very well: they put a ceiling on the damage. What they can't do is judge whether a purchase makes sense. An agent that buys the wrong software licence within its budget has stayed within every rule, and a card limit won't notice.
That's also where the soft layers turn out to be weaker than they look. In a paper published this year, two researchers built a shopping agent on Google's AP2 and showed that simple prompts hidden in what the agent reads could reliably change its behaviour, for example by pushing a certain brand to the top of its results or getting it to give away the user's data. The signed records and network limits still hold in that situation, but the agent's own judgment doesn't, which is exactly why the hard limits have to sit outside of it.
Questions to ask your payment partner
If you're building a product in which an agent pays, these are the questions I'd take into the first conversation with a payment partner, in roughly this order.
- Who sets the limit: your customer, your platform or the agent itself? If the agent can set or change its own limit, it isn't really a limit.
- Where is it enforced? Ask whether it's checked by the card network or the issuer, by the partner's platform, or only by the agent's instructions.
- Which kinds of limit exist: per transaction, per day, week or month, a lifetime cap, single use, and a list of allowed merchants or categories?
- Is there a record of what the customer asked for, and is the purchase checked against it, or only against the amount?
- How fast can you stop the agent, and can the agent undo that? You should be able to freeze or revoke a credential in seconds, without the agent being able to reverse it.
- What ends up in the log for each payment: which agent paid, on whose instructions, and within which limit?
- Is it live, in preview or still being deployed? Several of the systems above are in early access or preview, so check what you can actually use today.
If a partner can answer the first two questions clearly, the rest of the conversation tends to go a lot more smoothly as well.
This article is for information and education only and is not financial, legal or investment advice.
This article is information and commentary. It is not investment advice, not a personal recommendation and not investment research, it takes no account of your circumstances, and it must not be relied on as a reason to trade. Any figure shown is historical or simulated and is not an indication of future results.
Get the next piece the day it is published.
One email when a new report lands, nothing else.
Exact figures, sources, steps and terms behind this piece, written for the coding agent you point at it.
Quote freely with attribution: name the author, Hello Purple and the canonical URL, with the publication date, all of which are in the Markdown twin’s front matter. The twin is the reference text of the piece.
Read the appendix
Facts and figures
- Mastercard Token Spend Controls (release notes, July 2026): issuers set token-level rules after cardholder authentication, for tokens under Mastercard Agent Pay and Mastercard Virtual Card Token; rule types: transaction limit, daily, weekly and monthly spend limits, absolute (lifetime) spend limit, single-use control, allow and block lists by merchant category code, merchant ID, transaction category code, transaction type and geography; Mastercard evaluates each tokenized transaction and declines violations; test environment 2026-07-29, production 2026-08-05; optional for issuers.
- Visa Intelligent Commerce (product page): spending limits, approval workflows, authentication requirements and trusted identity signals; the page states the product is in the process of deployment and the final version may not contain all features described.
- Ramp agent cards (Ramp, 2026-04-28, early access): tokenized credentials issued by Visa Intelligent Commerce; single-use, scoped at the Visa network level; locked to one merchant; hard cap per transaction.
- American Express Intent Intelligence Framework (announced 2026-10-13): Create Intent API records instructions and constraints (merchant, maximum budget, product preferences); customer authenticates and approves; Intent ID and Proof of Intent token; token used to obtain a payment credential at checkout; the agent does not handle the card number; no rollout timeline or eligibility published.
- Google AP2 (announced 2025-09-16): mandates are cryptographically signed, tamper-evident digital objects; Checkout Mandate (items and purchase details, shared with the merchant) and Payment Mandate (authorises a payment against a specific instrument, shared with the credential provider, networks and the merchant's payment processor); each has an open stage (user constraints such as budget and allowed instruments, before a cart is final, for autonomous execution) and a closed stage (authorisation of one finalised checkout).
- OpenAI Delegated Payment Spec: single-use delegated payment with an allowance (max_amount, expires_at, merchant_id); direct integration only for PSPs and PCI DSS level 1 merchants with their own vaults; Stripe Shared Payment Token is the first compatible implementation.
- Stripe Shared Payment Tokens: issued by the agent's platform to one seller profile with usage limits (currency, maximum amount, expiry); revocable at any time; states active, requires_action, deactivated; preview API version.
- x402: open protocol (Apache-2.0); server answers HTTP 402 Payment Required with payment instructions; buyer sends a signed payment; a facilitator verifies and settles. Chainalysis (2026 Geography of Cryptocurrency Report, North America chapter): more than 138 million x402 payments on Base, more than 87% between $0.0001 and $0.10; total value not disclosed.
- Coinbase Agentic Wallet: holds USDC; maximum spend per call and per session configured by the owner in the wallet UI; agents cannot change the limits; agents can pay only for x402 services.
- Mercury agent cards (Mercury Spend, August 2026): agents can retrieve credentials for agent cards assigned to them; cannot create agent cards, update their spend limits or unfreeze them; freezing or cancelling takes effect immediately and cannot be reversed by the agent.
Steps to reproduce
- List every place in the payment flow where a limit could be set: agent instructions, agent platform or wallet, payment credential, record of customer intent.
- For each place, record who sets the limit, who can change it and who enforces it.
- Move every limit that matters to a place the agent cannot change: the credential, the issuer or network, or the wallet owner's settings.
- Add a record of what the customer asked for where the partner supports it.
- Test freezing or revoking the credential and confirm the agent cannot reverse it.
Limits
Spending limits cap the amount, frequency and merchant of a payment; they do not judge whether a purchase is sensible. Instructions inside the agent can be changed by prompt injection. Stripe Shared Payment Tokens and the OpenAI Delegated Payment Spec are single-use allowances set by the agent's platform, not a customer budget. Visa Intelligent Commerce is still being deployed. Amex has published no rollout timeline for the Intent Intelligence Framework. Ramp agent cards are in early access. Mastercard Token Spend Controls are optional for issuers. AP2's documentation does not state which party signs each mandate. Availability differs by country and partner.
Sources and links
- Mastercard MDES release notes, July 2026 (Token Spend Controls): https://developer.mastercard.com/mdes-customer-service/documentation/release-history/release-notes-july2026/
- Visa Intelligent Commerce: https://www.visa.com/en-us/solutions/intelligent-commerce
- Ramp, virtual cards for AI agents (2026-04-28): https://ramp.com/blog/virtual-cards-for-ai-agents
- TechCrunch on the Amex Intent Intelligence Framework (2026-10-13): https://techcrunch.com/2026/10/13/amex-introduces-a-framework-to-prevent-ai-agents-from-making-unauthorized-purchases/
- American Express, Agentic Commerce Experiences (2026-04-22): https://americanexpress.io/building-trust-in-ai-powered-transactions-with-amex-agentic-commerce-experiences/
- Agent Payments Protocol (AP2): https://ap2-protocol.org/
- OpenAI Delegated Payment Spec: https://developers.openai.com/commerce/specs/payment
- Stripe Shared Payment Tokens: https://docs.stripe.com/agentic-commerce/concepts/shared-payment-tokens
- x402, how it works: https://docs.cdp.coinbase.com/x402/core-concepts/how-it-works
- Coinbase Agentic Wallet: https://docs.cdp.coinbase.com/x402/agentic-accounts/agentic-wallet
- Coinbase Agentic Wallet MCP tools: https://docs.cdp.coinbase.com/agentic-wallet/mcp/mcp-tools/overview
- Blockhead on Chainalysis x402 figures (2026-10-15): https://www.blockhead.co/2026/10/15/ai-agents-have-made-138-million-payments-over-x402-most-of-them-under-10-cents/
- Mercury Vault API changelog, agent card credentials: https://docs.mercury.com/changelog/vault-api-retrieve-agent-card-credentials
- Mercury, agent cards: https://support.mercury.com/hc/en-us/articles/51299754284948-Agent-cards-Giving-AI-agents-a-card-of-their-own
- FinTech Global on Mercury Spend (2026-08-12): https://fintech.global/2026/08/12/mercury-puts-ai-agents-on-the-company-spending-line/
- Debi and Zhu, Whispers of Wealth: Red-Teaming Google's Agent Payments Protocol via Prompt Injection (arXiv 2601.22569): https://arxiv.org/abs/2601.22569
- Fortune on Jamie Dimon and outside AI agents (2026-10-15): https://fortune.com/2026/10/15/jamie-dimon-ai-agents-meta-muse-jpmorgan/
Terms
- Agent payment: a payment initiated by an AI agent on behalf of a person or company.
- Payment credential or token: a stand-in for a card number that can carry its own rules and can be revoked without replacing the card.
- Issuer: the bank or company that issued the card and can set rules on its tokens.
- Spending limit: a cap on amount, frequency, merchant or category that is checked before a payment is approved.
- Intent record or mandate: a signed record of what the customer asked the agent to buy or allowed it to pay, used to check a purchase and to settle disputes.
- Single-use allowance: a token that can pay once, up to a maximum amount, before an expiry time.
- x402: an open protocol for paying per request over HTTP with the 402 Payment Required status code.
- Prompt injection: text hidden in content an agent reads, written to change the agent's behaviour.
About this piece
Hello Purple, the-map track, 2026. Written for product teams that want to let an AI agent pay inside their product. Based on the companies' public documentation and announcements as of 2026-10-20. Hello Purple is published by Purple Technology; no Purple product is described in this piece.
Financial Market Analyst at Purple Technology. Holds a bachelor's degree in Finance and Insurance from HOGent, graduated with honours, and previously worked as an investment analyst at a family office. Spent two years in an investment club, analysing stocks and preparing pitches for the other members. Has traded his own account for five years across risk-premia harvesting, order flow trading and discretionary momentum swing setups, and built his own strategies on well-known concepts like open drives, inside days and open gaps. Writes here about AI in finance in practice, with a focus on trading and investing.