Visa Intelligent Commerce vs Mastercard Agent Pay vs Stripe ACP: Which Agent-Payment Layer Do You Actually Integrate?

What actually shipped in June 2026?

Three agent-payment launches shipped within days of each other around June 10, 2026: Visa Intelligent Commerce, Mastercard Agent Pay for Machines, and Stripe’s Agentic Commerce Protocol plus Shared Payment Tokens. The headlines framed them as a cage match. They are not. They sit at different layers, and for most builders you integrate exactly one of them — Stripe SPT/ACP — which provisions the Visa and Mastercard agentic tokens for you.

Let me state what shipped, then tell you the part the launch blogs skip: which one you actually write code against.

Visa Intelligent Commerce arrived wired into ChatGPT, shipping with Agent Scoring, an Agentic Registry, and a Large Transaction Model (an AI model trained on billions of transactions to cut false declines and improve fraud detection). That’s the card rail plus an identity-and-trust layer for agent-initiated transactions.

Mastercard Agent Pay for Machines — the machine-to-machine track of Mastercard’s Agent Pay family — landed the same week with its own twist: sub-cent micropayments spanning cards, accounts and stablecoins, with 30+ launch partners that skew toward crypto and PSP infrastructure (Stripe, Coinbase, Adyen, Checkout.com, Polygon, Solana Foundation, Ripple).

And Stripe’s Agentic Commerce Protocol plus Shared Payment Tokens — ACP is open-source (Apache 2.0), co-developed with OpenAI; SPT is a new payment primitive that lets an app like ChatGPT initiate a payment without ever touching the buyer’s card credentials.

The press called it a three-way war. For a builder, that framing is wrong, and acting on it would have you integrating three things when you need one.

Here’s the thesis up front: these sit at different layers. Visa and Mastercard are the network rails plus agent identity. Stripe ACP/SPT is the integration primitive you build against — and it provisions the networks’ agentic tokens for you.

One honest caveat before we go further (this is opinion, labeled as such): all of this is weeks old and still ramping. Availability is uneven and real agent-checkout volume in 2026 is unproven. Build it behind a feature flag. Don’t re-architect your checkout on a bet you can’t yet measure.

Is this really a three-way war?

No. The mental model that works is layers, not competitors.

The bottom layer is the rails plus trust. Visa Intelligent Commerce and Mastercard Agent Pay for Machines provide the agentic network tokens, plus agent identity, scoring, and registries. This is the card networks’ job. You do not reimplement agent scoring or stand up an agent registry — that’s their infrastructure, not yours.

The top layer is the integration primitive. Stripe ACP (the protocol) and Shared Payment Tokens (the primitive) are what your code actually calls. An SPT is scoped to a specific merchant and cart total, and it provisions the underlying Visa or Mastercard agentic token without exposing card credentials to the agent.

So Stripe is not a competing rail. It’s the abstraction that routes down to the network rails — and to BNPL. If you’ve integrated Stripe before, this shape is already familiar: you build against Stripe Checkout today, and Stripe talks to Visa and Mastercard on your behalf. Agentic commerce keeps exactly that shape. You integrate the abstraction; the abstraction talks to the networks. (More on the Stripe foundation in how to integrate Stripe into your SaaS.)

The left column is infrastructure you consume. The right column is the one thing you actually integrate. As of 2026 — confirm current details against the docs — that division is the whole game.

What is each one, exactly?

Precise definitions, so you stop conflating them. No invented methods here.

Visa Intelligent Commerce is Visa’s agentic-payments rail, wired into ChatGPT. It ships agent identity through an Agentic Registry, Agent Scoring (which evaluates whether a merchant site is agent-ready and which agents can be trusted), and a Large Transaction Model trained on billions of transactions to reduce false declines. Read it as: the card rail plus the trust layer for agents.

Mastercard Agent Pay for Machines is the machine-to-machine track of Mastercard’s Agent Pay family. Its differentiator is sub-cent micropayments spanning cards, accounts and stablecoins, with 30+ launch partners including Stripe, Coinbase, Adyen, Checkout.com, Polygon and Solana Foundation — a partner list that tells you where this lives: machine-to-machine, pay-per-call economics. Think an agent paying fractions of a cent per inference or per API hit, with permissions and credentials recorded on public chains (initially Polygon, Solana and Base).

Stripe ACP + SPT is the Agentic Commerce Protocol (open-source, Apache 2.0, built with OpenAI) plus Shared Payment Tokens. An SPT is scoped to a specific merchant and cart total, can be constrained by amount, and is issued without exposing the buyer’s payment credentials to the agent. For an existing Stripe merchant, Stripe says agentic payments can be enabled in as little as one line of code. This is the developer integration layer that provisions the network tokens above it.

One line each, so it sticks: Visa is rails plus agent trust; Mastercard Agent Pay for Machines is rails plus stablecoin micropayments; Stripe is the primitive you integrate.

So which one do I integrate? (the decision)

For most builders — including a Mexican or LATAM SaaS — you integrate one primitive: Stripe SPT/ACP. You generally do not integrate Visa and Mastercard separately. That’s the headline answer, and it’s deliberately boring because boring is correct here.

The decision flow is short. First, integrate Stripe SPT/ACP in your checkout — the same layer you already build against if you take cards. Second, the SPT provisions the underlying Visa or Mastercard agentic network token. Third, the networks handle agent identity, scoring and registry — not your code. Fourth, ship it behind a feature flag so you can measure real agent traffic before you commit engineering time to it.

When would you reach past the abstraction and go direct? One real case: if you specifically need sub-cent stablecoin micropayments — genuine machine-to-machine, pay-per-inference billing — that’s where Mastercard Agent Pay for Machines leans, and you’d evaluate it directly. Confirm availability in your country first. (If usage-metered billing is your actual problem, the usage-based billing for AI breakdown is the more grounded starting point today.)

Opinion, labeled: don’t bet your roadmap on agent-checkout volume you can’t yet measure. The whole virtue of integrating the abstraction is that Stripe lets you turn agent payments on cheaply and rip them out cheaply. That optionality is worth more right now than picking a “winner” among three things that aren’t actually competing.

On code: the object you create and constrain is the Shared Payment Token — merchant scope, amount cap, and the lifecycle controls Stripe exposes — plus the webhooks you already monitor. Any specific SDK method name below is pseudocode; verify the real namespace against docs.stripe.com/agentic-commerce before you ship. These APIs are weeks old and will move.

// PSEUDOCODE — not a real SDK call. Verify the actual namespace/method
// against docs.stripe.com/agentic-commerce before using.
// You constrain an SPT to a merchant + cart total, then hand it to the agent.
const agentToken = await stripe.SHARED_PAYMENT_TOKENS.create({
  merchant: "acct_yourstore",
  amount: cartTotal,          // cap the agent to this cart
  currency: "mxn",
});
// Stripe provisions the underlying Visa/MC agentic network token.
// The agent never sees raw card credentials. Webhooks stay your source of truth.

For the broader LATAM payments picture, the payment gateways in Mexico guide covers the surrounding plumbing your agent flow still has to settle through.

How does an agent purchase flow across the layers?

End-to-end, so the layering stops being abstract.

A user gives an agent — say, inside ChatGPT — permission and a budget. The agent builds a cart from your store over ACP. Stripe issues a Shared Payment Token scoped to your merchant and that exact cart total. The SPT provisions a Visa or Mastercard agentic network token. The network runs its agent identity and scoring and authorizes the transaction. The charge then settles to your store like any normal payment.

The thing to internalize: your store sees a familiar payment object. The agent-specific machinery — identity, scoring, the agentic token — sits below your integration line. You don’t handle it; you receive a payment.

Credentials never touch the agent. The SPT is the buffer between the agent and the buyer’s real card. That’s the security story, and it’s exactly why scoping to a single merchant and cart total matters — a leaked or misbehaving agent token is bounded to one cart, not the buyer’s full payment method.

Webhooks stay your source of truth. Monitor SPT events the way you already monitor payment events — and if you’re orchestrating the agents yourself, the same production discipline from running LLMs in production applies: log everything, alert on anomalies, assume the agent will do something weird eventually.

What’s shippable today vs roadmap?

Let me separate roadmap from reality, because this is where overconfident posts get builders in trouble.

Shippable today: integrating Stripe ACP/SPT against a US-centric agent surface. ChatGPT Instant Checkout started US-first — Etsy sellers first, then over a million Shopify merchants like Glossier, SKIMS and Vuori coming online. If you’re an existing Stripe merchant, enabling agentic payments is close to a one-line change. That part is real.

Still ramping — and I won’t overstate it: broad agent adoption, cross-network parity, and how much actual purchase volume flows through agents in 2026. The capability shipped; the behavior change hasn’t been proven at scale. Those are different things.

The LATAM angle: the integration point is the same Stripe SPT/ACP layer regardless of geography. The open question isn’t your code — it’s availability, and whether your buyers’ agents and their card issuers actually participate in your market yet. Treat it as a flagged experiment, not a launch you put on a roadmap slide. Confirm country availability before you promise agent checkout to a Mexican customer.

Stablecoin caution, labeled and explicitly non-legal: Mastercard Agent Pay for Machines’ stablecoin micropayments are real as a capability. But stablecoin rules in Mexico — Ley Fintech and the related regime — are evolving, and nothing here is legal clearance. Confirm country availability and get compliance and legal advice before you ship any stablecoin flow. I build payments; I don’t give legal opinions, and you shouldn’t take one from a blog post.

Opinion to close the section: pick the abstraction, build behind a flag, measure, and let agent adoption prove itself before you re-architect anything.

FAQ

Is Stripe a competitor to Visa and Mastercard here? No. Stripe ACP/SPT is the integration layer that provisions the networks’ agentic tokens. You build against Stripe; Stripe routes to the rails. Same relationship you already have with Stripe Checkout.

Do I need to integrate Visa and Mastercard separately? Usually no. Integrating Stripe SPT/ACP abstracts both networks (plus BNPL). Go direct only for niche needs like stablecoin micropayments.

Where do stablecoins fit? Mastercard Agent Pay for Machines supports sub-cent micropayments across cards, accounts and stablecoins, settling on public chains like Polygon, Solana and Base. Confirm availability and get legal and compliance advice first — the rules are evolving and this isn’t legal guidance.

Can I ship agent checkout in Mexico today? The integration layer is identical anywhere; availability is the gatekeeper. Verify country support before promising it, and ship behind a flag.

What does my code actually call? You create and constrain a Shared Payment Token — merchant scope, amount, lifecycle controls — and handle webhooks. Treat any specific SDK method as pseudocode and verify against current Stripe docs, because these APIs are weeks old.

The short version

Three June-2026 launches, three layers — not three competitors. Visa Intelligent Commerce and Mastercard Agent Pay for Machines are the network rails plus agent trust. Stripe ACP/SPT is the primitive you integrate.

So integrate one thing: Stripe SPT/ACP. Let it provision the network tokens, run it behind a feature flag, and measure real agent traffic before you bet any roadmap on it. The abstraction is cheap to turn on and cheap to remove — which, in a market this new, is exactly the position you want to be in.