Agentic payments matrix

Agent and buyer context travel through the commerce flow; no universal agent registry is claimed.

Tokens are merchant-, amount- and time-scoped and can be revoked.

Raw credentials remain hidden; one-time cards and network tokens are supported.

Agents can obtain a one-time card or SPT and initiate payment.

Multiple rails and global merchant infrastructure are documented; product availability varies by market.

Public documentation and integration surfaces cover merchants, platforms and AI applications.

Stripe documents multiple protocols and network-token interoperability.

Risk signals, revocation, observability and existing fraud controls are explicit.

Merchant order lifecycle and established Stripe refund/dispute infrastructure are available.

Stripe names live or rolling deployments across ChatGPT, Etsy, URBN and network partners.

Agents are onboarded and associated with agent-specific payment tokens.

Instructions bind user-authorized merchant and amount constraints.

Underlying card credentials remain protected with step-up verification options.

Agentic transactions execute through Visa credentials and authorization controls.

Global network reach is established; agentic availability still varies by program and market.

Visa exposes public developer documentation, sandbox access and MCP guidance.

MCP and network-token interoperability are evidenced; no independent open commerce protocol is claimed.

Authorization, authentication, network risk and dispute signals are explicit.

Signals can support dispute resolution; a complete public agent refund workflow is not evidenced.

Network tokens are rolling out through partners including Stripe; availability varies by market.

Wallets are designed for machine-initiated operation and agent attribution.

Transfers and x402 services can be constrained by time, amount and address policy.

Dedicated wallets, allowlists, blocklists and bounded sessions are documented.

Agents can hold funds and transact programmatically using USDC.

Multi-chain USDC and Gateway provide global settlement primitives.

CLI, skills, wallet APIs and developer entry points are public.

Agent Stack explicitly supports x402 services and programmable payments.

Spending controls and address policies are explicit; full autonomous compliance evidence is still developing.

Transaction records are available; agent-specific refund and dispute workflows are not yet fully evidenced.

Circle states the initial products are available; scaled named adoption is less mature than the card networks.

Each agent receives its own attributable identity rather than borrowing a human login.

Permissions and approval workflows constrain what an agent may do.

Agent-specific virtual cards and scoped credentials isolate spend.

Agents can operate finance workflows and payment instruments within Ramp controls.

Ramp has business payment functionality, but broad agentic cross-border settlement evidence is limited.

Builder documentation exposes agent-facing integration surfaces across finance workflows.

MCP is supported; no independent open payment protocol is claimed.

Agent attribution, roles, limits and human approval are core product controls.

Bills, expenses and procurement use established approval and exception workflows.

Products and developer surfaces are public; comparable transaction-scale proof remains limited.

Agents can receive dedicated wallets; universal principal attestation is not claimed.

Users configure permissions, limits and wallet policies.

Wallet-level limits and whitelists isolate agent spending authority.

Agents can hold wallets, onramp and execute stablecoin payments.

USDC, multiple networks and fiat on/off ramps support global payment-firm use cases.

Coinbase publishes MCP, x402 clients, wallets, APIs and reference implementations.

Open HTTP-native payments and MCP integration are core products.

Hosted facilitator and payment stack document sanctions screening and wallet policies.

Payment-firm APIs include reporting and refund-like flows; autonomous exception orchestration is less complete.

Production facilitator, network support and compatibility with Codex, Claude and Gemini are documented.

Remote MCP uses PayPal authentication, but a universal agent registry is not documented.

Developers explicitly enable order, invoice and other actions exposed to an agent.

Credentials stay in the server integration rather than being handed to the model.

The toolkit invokes PayPal APIs to create transactional objects and execute enabled commerce workflows.

Agent tools sit on PayPal's global checkout, payout and Xoom capabilities; availability remains product- and market-specific.

TypeScript tooling, quickstarts, remote MCP and integrations with major agent frameworks are public.

PayPal documents MCP and AP2 support and exposes agent-ready ACP/UCP commerce services.

Authentication, action scoping and established PayPal risk infrastructure are explicit; model outputs still require review.

The agent surface includes transaction lifecycle operations such as refunds, disputes, tracking and subscriptions.

The toolkit and MCP endpoints are publicly available; comparable agent transaction-volume disclosure is not yet public.

UCP exposes machine-readable agent and merchant capability profiles; identity assurance depends on implementations.

UCP negotiates supported capabilities and provides human handoff for workflows requiring confirmation.

Payment handlers are negotiated and can use Shop Pay, Google Pay or other processors without exposing raw credentials to the agent.

Agents can discover products, create carts and complete checkout through supported AI channels.

UCP works across Shopify's global merchant base and does not prescribe one processor; market-level payment availability still varies.

Self-serve developer access, a public MCP endpoint, UCP Skill and CLI are documented.

Interoperability across transports and payment handlers is a first-class design goal.

Merchant discounts, terms, fulfillment and checkout rules remain authoritative in the agent flow.

UCP standardizes orders and post-purchase operations and supports escalation to a human.

Shopify documents live or rolling integrations with ChatGPT, Microsoft Copilot and Google surfaces plus self-serve developer access.

Agent transactions are distinguishable through tokenization and verification.

Consumer permissions and preferences are captured for authorized transactions.

Network tokenization protects credentials used by agents.

Consumer and machine-initiated payments execute on Mastercard infrastructure.

The network is global, while individual agentic programs remain market- and partner-dependent.

Partner deployment is documented, but a complete public self-service API package is not yet evidenced.

Standards work is public; a fully open protocol implementation is not evidenced here.

Identity, tokenization, intent and network risk controls are central to the design.

Dispute context is discussed; full public agent-specific refund APIs are not evidenced.

Mastercard reports live transactions and more than 30 early ecosystem supporters for machine payments.

ACE defines registration so only verified AI agents are authorized to transact on the Amex network.

Card Members link accounts to verified agents and authenticate purchase intent with spend controls.

Verified agents receive tokenized credentials rather than raw card details.

Available specifications allow verified agents to complete payments on a Card Member's behalf; access remains partner-led.

ACE uses the global Amex network, but route-level agentic availability is not disclosed.

Account Enablement, Intent Intelligence and Payment Credentials specifications are available; two modules remain under development.

ACE is designed to interoperate across agentic commerce protocols, though not all modules are complete.

Identity, intent, cart data and network authorization are combined for validation, fraud and dispute decisions.

Authenticated intent and cart context support disputes; Agent Purchase Protection is announced but still coming soon.

Amex reports AI-assisted transactions and published specifications, but broad public access is not yet evidenced.

MCP sessions are tied to authenticated Mercury users; a distinct universal agent identity is not documented.

Payment approval rules, limits, dual-admin approval and spend controls carry into Command actions.

Mercury supports fine-grained API tokens, IP allow-listing and separation of read and write actions; sensitive credentials are not passed to the model.

CLI and APIs can initiate payments, create invoices, categorize transactions and upload receipts; Command prepares payment actions for approval.

Mercury supports bank payments and wires, but broad agentic multicurrency corridor coverage is not evidenced.

Mercury exposes documented programmatic surfaces for developers and agents.

A native MCP server integrates Mercury with ChatGPT, Claude and other compatible tools.

Actions use existing permissions and controls, remain reviewable and are logged and traceable.

Transactions, invoices and payments are traceable, but agent-specific dispute handling is not fully documented.

Mercury states that Command is available to every customer and exposes production API, CLI and MCP surfaces.

Credentials can convey authority, but a universal live agent registry is not evidenced.

Signed mandates preserve instructions and purchase authorization.

Cryptographically signed mandates and verifiable credentials protect the flow.

The protocol covers cards, stablecoins and real-time bank transfers through ecosystem providers.

The design is rail- and market-flexible, but route-level production coverage is not evidenced.

Public specification, documentation and reference implementations are available.

Interoperability is the protocol's central design goal.

The mandate chain supports authorization evidence and accountability.

Refund and dispute execution is delegated to payment ecosystem implementations.

Reference implementations and partners are public; broad production adoption is still evolving.

OAuth binds an agent session to an Airwallex account; distinct agent-principal attribution is less explicit.

Guardrails restrict money-out actions, but a complete delegated-mandate model is not evidenced.

Production OAuth and sandbox credentials are documented.

Agents can work with balances, beneficiaries, cards, billing and cash-flow resources under guardrails.

AgentOS sits on Airwallex global accounts, FX, cards and payment infrastructure.

Codex, Claude, Cursor and generic MCP installation paths are documented.

Production and developer MCP servers are first-class product surfaces.

Safety guidance and default money-out restrictions are explicit.

Account records exist, but agent-specific refund and dispute workflows are not documented here.

Airwallex describes a production-grade connection to live account resources.

Agent context is supported, while universal agent registration remains dependent on network partners.

Merchant checkout rules and customer authorization flows remain connected through Agentic Cart and Payments.

Agentic Payments explicitly supports token portability and existing network credential controls.

Agents can complete payments through Adyen's merchant integration in limited availability.

The underlying Adyen platform is global, but Agentic launched in limited U.S. availability with expansion planned.

Three modular API layers reduce per-agent-platform integration work.

Adyen documents compatibility across major emerging commerce protocols and Meta AI checkout.

The product uses Adyen authentication, tokenization and fraud infrastructure while preserving merchant routing and business rules.

Agentic Cart connects fulfillment and order management; detailed agent-specific dispute flows are not yet public.

Adyen names enterprise retailers and network partners, but availability is still limited rather than broadly GA.

Agent identification depends on Mastercard's acceptance framework rather than a Fiserv-owned registry.

The announced framework includes authentication and governance for agents transacting on behalf of customers.

Fiserv will act as a network token requestor for merchants and partners.

Merchant acceptance is announced and being integrated; broad live execution evidence remains limited.

The networks are global, but agentic route-level availability is not disclosed.

The capability is processor- and merchant-facing; a broad public developer surface is not evidenced in this announcement.

Fiserv adopts a network framework intended to make agent acceptance interoperable at merchant scale.

Tokenization, strong authentication, fraud prevention and governance are explicit design elements.

Existing merchant operations can handle exceptions, but agent-specific refund and dispute detail is not public.

Fiserv is described as an early major processor adopter; scaled deployment evidence is still prospective.

Actions are attributable inside Brex workflows, but no customer-facing agent identity product is documented.

Brex applies policy, documentation and approval rules to each transaction.

Cards and limits isolate spending authority, though agent-specific credential issuance is not evidenced.

Brex automates policy decisions around real payment products, but the public evidence does not show an autonomous external agent initiating arbitrary payments.

Brex supports global business spend, but agent-specific cross-border settlement is not documented.

An API and ERP/HRIS integrations exist, but no public MCP or agent SDK is evidenced here.

Automation is proprietary; no open agent-payment protocol is documented.

Brex auto-approves in-policy spend, declines out-of-policy transactions and flags high-risk expenses.

Managers can review flags via Slack or SMS, while receipt and accounting exceptions route to established workflows.

AI policy enforcement, receipt generation and automated approvals are available in the production product.