Data as of Aug 25, 2026 · Based on 38 AI responses from ChatGPT Search and Google AI Mode · See how Parse measures this
VisaYour brand can be here too.
Source | Citation share |
|---|---|
 How to Set Spending Controls for AI Agentshttps://ramp.com/blog/ai-agent-spending-controls | 3.5% |
 Infrastructure for AI Agentshttps://arxiv.org/abs/2501.10114 | 1.5% |
 Announcing Agent Payments Protocol (AP2) | Google Cloud Bloghttps://cloud.google.com/blog/products/ai-machine-learning/announcing-agents-to-payments-ap2-protocol | 1.5% |
 How AI Agents Will Pay Each Otherhttps://www.youtube.com/watch | 1.5% |
Arden — A wallet for every AI agenthttps://arden.sh/ | 1.3% |
 PayPalhttps://medium.com/@miteshshah/payment-rails-for-ai-agents-enabling-the-machine-economy-7f2d12463dc1 | 1.3% |
 How to Add Payments to Your AI Agent (Cards, Stablecoins, Wallets)https://www.crossmint.com/learn/add-payments-to-ai-agents | 1.3% |
 How to control AI agent spending with limited financial controls?https://www.facebook.com/groups/chatgpt4u/posts/1990795964883436/ | 1.3% |
 'The stakes are high: a misconfigured payment flow doesn't just produce a bad answer, it moves real money': Amazon Bedrock teams up with Coinbase and Stripe to let AI agents carry out transactions using stablecoinshttps://www.techradar.com/pro/the-stakes-are-high-a-misconfigured-payment-flow-doesnt-just-produce-a-bad-answer-it-moves-real-money-amazon-bedrock-teams-up-with-coinbase-and-stripe-to-let-ai-agents-carry-out-transactions-using-stablecoins | 1.3% |
Agentic Payments: What Onchain Data Reveals Commerce | Visahttps://www.visa.com/en-us/thought-leadership/innovation/agentic-payments-from-the-ground-up | 1.3% |
The emerging category is agentic payments / agentic commerce infrastructure. Think of it as a combination of a programmable wallet + authorization system + policy engine + payment rails.
A useful architecture looks like this:
$500/month maximum$50 maximum per transactionThe payment infrastructure checks those rules before money moves. AWS's AgentCore Payments, for example, performs atomic budget reservation so concurrent agent actions can't accidentally spend the same budget twice. Amazon Web Services 4. Payment rails
The distinction is important: the wallet answers “where does the money live?”, while the payment rail answers “how does this particular merchant get paid?” 5. Scoped credentials Instead of giving an agent your actual Amex number, infrastructure can issue a temporary or merchant-specific virtual card/token. Stripe describes this model using Stripe Issuing: the agent gets a temporary virtual card rather than access to the underlying card details. Stripe 6. Audit + approval layer Every transaction should record:
This turns an autonomous agent from “a bot with my credit card” into a delegated financial actor.
There are several layers emerging simultaneously:
So if you're thinking about this as a startup/infrastructure category, I'd describe the core primitive as:
A programmable spending account that an AI agent can control, subject to deterministic policies. The interesting part isn't really the wallet. The moat is the authorization + policy layer: proving that this agent was allowed to spend this much on this thing, and enforcing that constraint atomically before the payment happens.
That's what makes an AI agent economically autonomous without giving it unrestricted access to someone's money.
Enabling an AI agent to hold a budget and execute transactions requires a stack spanning programmable treasury/spend management, identity and authorization protocols , and network-level payment rails.
Instead of giving an agent access to a human's permanent credit card or a raw private crypto key, modern infrastructure isolates risk through single-use limits, cryptographic sign-offs, and micro-transaction protocols.
For traditional web commerce, software APIs allow developers to provision scoped, ephemeral purchasing power.
create_card(amount=$50).A flurry of open standards and protocols connect AI frameworks directly to checkout engines and merchant catalogs:
For API-to-API communication, traditional credit card rails have high fixed fees and friction. Crypto infrastructure provides native, instant settlement for autonomous agents:
x402 (by Coinbase and Cloudflare) transform standard HTTP 402 errors into machine-native payment prompts.Are you looking to build an agent that makes traditional e-commerce purchases (via virtual cards) or pays for machine-to-machine API calls (via stablecoins)? I can dive deeper into the specific stack you'll need.
Enabling an AI agent to hold a budget and make purchases requires a stack of specialized infrastructure distinct from traditional human-centric e-commerce . Because machines operate at high velocities, execute micro-transactions, and require strict security boundaries, traditional banking rails (which rely on manual two-factor authentication, slow settlement times, and high percentage-based fees) fall short.
The modern agentic commerce stack is divided into four main layers:
Agents need programmatic custody solutions where a private key or secure enclave is tied strictly to the agent’s runtime environment rather than a human user's daily banking login.
Traditional credit cards fail for machine-to-machine microtransactions due to per-transaction overhead. The ecosystem is shifting toward stablecoin and cryptographic rails designed for instantaneous settlement.
An agent cannot be given an uncapped bank account. Budget execution requires hard-coded programmatic constraints (spending caps, approved vendor white-lists, and velocity limits).
On the receiving end, merchants must be able to authenticate that an incoming request is from a legitimate, authorized agent and securely capture funds.
Would you like to explore how to set up programmatic spending limits using a specific framework, or are you interested in the security risks of prompt-injection attacks targeting agent wallets?
The infrastructure is usually called agentic payments or agentic commerce infrastructure. The key idea is: don’t give the AI your credit card or bank credentials; give it a constrained financial authority.
A production stack typically looks like this:
$100/day, $20/transaction, approved merchants/categories, velocity limits, or an expiration time. Crucially, these limits are enforced outside the LLM, so a prompt injection or hallucination can't simply tell the model to raise its budget. There are now several layers/products:
The interesting architectural distinction is wallet vs. control plane vs. payment rail:
Agent → policy/budget engine → delegated wallet/card → payment rail → merchant The policy/budget engine is arguably the most important new piece. A wallet alone lets an agent spend; the control plane determines what it is allowed to spend, where, when, and under whose authority.
If you're asking because you're considering building an AI agent that can autonomously buy things, I can also break down the concrete architecture/API stack I'd use today, including Stripe/virtual cards vs. stablecoin wallets.
Enabling an AI agent to hold a budget and make purchases requires a secure, programmatic stack bridging financial accounts, identity/authorization, smart contracts/APIs , and guardrails.
Here is the core infrastructure required to make autonomous agent commerce a reality:
Would you like to explore how to implement a proof-of-concept setup using a specific stack (like crypto/account abstraction vs. traditional corporate virtual cards)?
The infrastructure is usually called agentic payment infrastructure or an AI agent financial stack. It combines a wallet, identity, authorization, payment rails, and spending controls so an AI agent can act with money without having unrestricted access to a person’s accounts.
A typical architecture looks like this:
Agent wallet (where the budget lives)
Identity and authorization layer
Policy engine / budget controls
Payment execution layer
Merchant/service discovery
Security and monitoring
A simplified flow:
User funds agent wallet
↓
User sets rules:
"$500/month"
"No purchases above $100"
"Only approved vendors"
↓
AI agent decides it needs something
↓
Payment system checks policy
↓
Wallet signs transaction
↓
Merchant/API receives payment
↓
Audit log records the action
Examples of emerging approaches:
The key design principle is bounded autonomy: the agent gets enough financial capability to complete tasks, but its authority is constrained by cryptographic controls, policies, and budgets rather than by trust alone.
The emerging infrastructure is usually called agentic payments / agentic commerce infrastructure. The key idea is: don’t give the AI your actual card or bank credentials; give it a constrained financial capability.
A useful stack looks like this:
Stripe is building this around Shared Payment Tokens: an agent gets a payment token rather than the underlying credential, and the token can be constrained by business, time, or amount. Stripe also recommends virtual cards with spend controls for agents doing corporate purchasing.
Visa Intelligent Commerce is taking a network-level approach. Its infrastructure includes agent-specific payment tokens, authenticated user instructions, transaction controls, and commerce signals. In other words, the network itself can enforce that an agent's transaction matches the authorized amount and merchant.
Visa and OpenAI announced a collaboration in June 2026 specifically around this model, including spending limits, merchant-category restrictions, required approvals, tokenized credentials, and real-time authorization/fraud monitoring.
So conceptually, you could give an agent:
Budget: $1,000/month
Purpose: office supplies
Per-purchase limit: $150
Allowed merchants: Amazon Business, Staples
Approval: human required above $150
Credential: agent-specific virtual/tokenized card
The agent then has something much closer to a programmable corporate purchasing account than a credit card.
The interesting part is that the budget itself doesn't necessarily have to be a pile of cash sitting in an AI wallet. It can be a set of enforceable permissions over an existing bank/card account. The payment infrastructure acts as the enforcement boundary.
Visa's recent research describes essentially this transition: agents are already beginning to book travel, reorder inventory, buy data, and purchase compute, making the combination of agent identity + delegated authority + scoped payment credentials + policy enforcement the emerging financial infrastructure for autonomous agents.
If you're asking because you're thinking about building an AI agent that has its own spending account/budget, I can also map out the actual architecture and the companies/APIs you could use today.
To let an AI agent securely hold a budget, make independent financial decisions, and execute transactions, a specialized stack of AI-native financial infrastructure is required. Traditional banking APIs (like standard Stripe or Plaid accounts) aren't built for non-human entities that might need to spend$0.0 5 on an API call or make a purchase at 3:00 AM without human intervention.
Here is the core infrastructure stack that makes autonomous AI spending possible:
Traditional corporate credit cards rely on human pre-authorization and slow settlement. AI agents need cryptographically secure, programmatic wallets with strict policy controls.
You cannot give an AI agent an un-capped corporate card (the "hallucinated $10,000 AWS bill" nightmare). Policy engines act as the intermediary between the agent's intent and the transaction execution.
Before an entity accepts money from an AI, it needs to verify which agent is paying and whether that agent is authorized.
Standard e-commerce checkouts are designed for humans with eyes, captchas, and click paths. AI agents need standardized ways to discover pricing and check out.
402 Payment Required status code accompanied by a lightning/crypto/micro-payment address, allowing the agent to pay the toll on the fly and immediately receive the data payload.If you're building an agent right now, let me know:
I can dive deeper into specific provider APIs or security patterns for your use case.
The infrastructure is emerging as agentic payments / agentic commerce infrastructure. The key idea is to give an AI agent bounded financial authority, rather than handing it your credit card or bank credentials.
A useful mental model is:
Human/company → budget → policy engine → agent wallet/token → payment rail → merchant → receipt/audit
Agent identity
A programmable wallet or payment credential
A policy/spending-control layer This is arguably the most important piece:
$100/day$50 per transaction$250Mastercard's new Agent Pay infrastructure explicitly includes programmatic authorization rules and spending limits.
Payment rails The actual money movement can happen through:
Mastercard's 2026 Agent Pay system, for example, supports settlement across cards, accounts and stablecoins.
Authorization / intent protocols Instead of “here's my card, do whatever,” the user creates a machine-readable mandate:
Agent X may spend up to $500 on office supplies from approved vendors until Friday.
Visa describes this emerging architecture as embedding payment credentials, controls, authentication and protections into automated purchases.
Audit, receipts and dispute mechanisms Every action needs to be attributable: agent → authorization → purchase → settlement → receipt.
That's particularly important when an autonomous agent makes hundreds of purchases without a human clicking “Buy.”
There are now several approaches:
| Layer | Examples |
|---|---|
| Agent wallets / credentials | Stripe, Cloudflare |
| Card/payment-network rails | Visa, Mastercard |
| Stablecoin/on-chain payments | Coinbase and various wallet/payment providers |
| Agent-payment protocols | emerging standards such as machine-payment and agent-authorization protocols |
| Enterprise spend management | Ramp, Brex and procurement platforms are adjacent, though traditionally designed around humans |
Visa itself describes agents already being used to book travel, reorder inventory, query data providers and purchase compute.
The hard problem isn't actually giving an agent a wallet. It's giving the wallet a programmable constitution.
You want something like:
Budget: $10,000/month
Agent: Procurement Agent
Allowed: AWS, office supplies, software
Per-transaction limit: $1,000
Daily limit: $3,000
Approval: required over $1,000
No: new vendors without approval
Expiration: 30 days
Audit: immutable transaction log
Then the LLM can be highly autonomous while the financial authority remains deterministic and enforceable outside the LLM.
That's why I would distinguish “AI agent with a payment method” from “AI agent with economic agency.” The latter requires identity + delegated authority + policy enforcement + wallet + settlement + auditability. Current infrastructure is rapidly assembling those pieces, but there isn't yet one universally accepted stack.
If you're thinking about this from a startup/infrastructure opportunity perspective, the particularly interesting layer is the “financial policy engine for AI agents”—the equivalent of an authorization system that sits between the agent's reasoning and its ability to actually move money.
To give an AI agent the ability to hold funds and execute purchases, you need a combination of financial primitives, identity/authentication layers , and guardrail infrastructure.
Here is the core infrastructure stack that enables autonomous economic agency:
If you are planning to build one, tell me:
I can help you map out the ideal architecture and tool stack for your specific use case.
