Five Agent Payment Protocols. One Attribution Problem.

Stripe Sessions happened last week. The recurring word in the agentic commerce sessions wasn't "x402" or "stablecoins" or "machine-to-machine." It was a phrase that doesn't usually come from Stripe: protocol crowding.

That's the situation as of May 2026. Five distinct agent payment standards are now live or actively deploying:

x402 — the HTTP-native micropayment protocol, now running real production workloads (ClawMart's agent-swarm revenue management, Pickr's API ratings marketplace with 9,000+ endpoints, ClawCredit's autonomous wallet top-ups)
ACP (Agentic Commerce Protocol) — OpenAI's discovery-first standard, refined last month with a new order schema for post-checkout alignment (SEP #232, committed May 1 by Stripe's own team)
AP2 (Agent Payment Protocol v2) — Google's agent payments layer, co-developed with partners, focused on server-side authorization and token-based attribution
AGTP (Agentic Transaction Protocol) — the emergent standard from the Base/Solana agent ecosystem
OKX Agent Payments Protocol — launched this week, open-source, supporting full autonomous agent commerce on Ethereum and Solana

Five standards. Overlapping merchant rosters. Different architectures. Different identity models. Different assumptions about who authorizes what and when.

This is not a sign the market is broken. It's a sign the market is serious.

What "protocol crowding" actually means for you

When multiple standards compete for the same layer, the companies building above that layer tend to win. TCP/IP had competing predecessors — OSI, DECnet, X.25. The companies that built applications above TCP/IP didn't need to pick a winner. They built to the abstraction.

The same dynamic is happening in agentic commerce right now, and the abstraction layer is attribution.

Here's the problem that protocol crowding creates for publishers and affiliate operators:

An AI agent recommending your product might be running on x402. Or it might be operating inside an ACP-integrated ChatGPT surface. Or it might be an autonomous agent on Base using AGTP for its wallet calls. The payment layer changes depending on which agent infrastructure the buyer is running on. But your commission — the fact that this agent made a recommendation that led to a purchase — doesn't change. The referral happened. The attribution needs to fire.

None of the five protocols above includes a native affiliate layer. x402 handles the payment handshake; it doesn't know who recommended the product. ACP handles product discovery; the commission-splitting spec is still an open PR. AP2 handles authorization tokens; publisher identity isn't in scope. AGTP handles wallet calls; referral tracking isn't in the schema. OKX's protocol is solving for autonomous commerce execution, not for the publisher who drove the agent there.

The attribution layer is not inside any of these protocols. It's the layer above all of them.

The structural advantage of being protocol-agnostic

If you're building affiliate infrastructure that bets on one protocol, you're building for one lane of a five-lane highway that hasn't decided which side is the fast lane yet.

If you're building attribution infrastructure that treats payment protocols as interchangeable — as inputs to a signed referral event, not as the thing you're tracking — you're positioned for the protocol outcome regardless of which standards win.

This isn't a neutral stance. It's a structural one.

The signal that fires attribution doesn't live in the payment layer. It lives in the recommendation layer — the moment an agent surfaces a product, routes a user, or triggers a purchase action on a publisher's behalf. That moment happens before the payment protocol is invoked. It's captured at the API call, the recommendation event, the affiliate link equivalent for an agent-native world.

Three infrastructure requirements that don't change regardless of which payment protocol wins:

Signed attribution headers — an agent needs a verifiable publisher identity that travels with the recommendation, not with the payment. Publisher ID shouldn't be in the payment packet; it should be in the agent's context when it makes the recommendation.
Event-based settlement triggers — commissions should fire when the attributable event (purchase, signup, conversion) occurs, triggered by a webhook or payment event, not by a 30-day cookie window that never fires for an agent that has no session.
Protocol-agnostic publisher registry — a publisher should register once and earn attribution across x402, ACP, AP2, or whatever protocol the end merchant supports. The publisher shouldn't need to re-integrate every time a new payment standard launches.

When OKX ships a new Agent Payments Protocol this month, merchants who have those three layers in place don't need to rebuild. They need to route the payment through the new protocol and let attribution handle the rest.

What Stripe Sessions actually confirmed

Stripe's team shipping SEP #232 — the ACP order schema for post-checkout alignment — is a significant signal. It means the companies closest to the transaction layer are starting to think about what happens after the payment clears: order state, fulfillment attribution, post-purchase events.

That's moving in the right direction. But it's still the payment company solving a payment problem. The affiliate publisher — the agent, the content site, the recommender system that sent the buyer to the checkout — isn't in scope for that PR.

The Stripe Sessions framing of "stablecoins as global rails" is also worth noting. Stablecoins don't care which protocol settled the payment. USDC on Base works under x402, under AGTP, under OKX's protocol. The payment rail is increasingly abstracted. The thing that remains protocol-specific is identity — who was involved in this transaction, in what role, and how do they get paid.

That identity question, applied to publishers and recommender agents, is still largely unsolved across all five standards.

The practical upshot

For merchants building affiliate programs today:

Don't wait for protocol convergence. The five-protocol environment isn't a temporary mess before a winner emerges. It may be the permanent state. Mobile payments had Apple Pay, Google Pay, Samsung Pay, carrier billing, and a dozen regional standards all running simultaneously for years. What solved that wasn't a single winner — it was an abstraction layer (Stripe, Braintree, Adyen) that handled the protocol routing on the merchant's behalf.

Audit where your commission logic lives. If your affiliate payout depends on cookies, session tracking, or a browser-based attribution model, it won't fire when the referral agent has no browser. Map the actual chain — recommendation → purchase → payout — and identify every step that assumes a human web session.

Favor infrastructure that treats protocols as plumbing. The affiliate layer that survives protocol crowding is one that can route attribution events regardless of which payment standard the end transaction runs on. That's a product architecture question, not just a protocol question.

Sources:

Winston Morning Scan 2026-05-04 — x402 production tooling (ClawMart, Pickr, ClawCredit), Stripe Sessions "protocol crowding" takeaway, OKX Agent Payments Protocol launch (X/Twitter signals, scored ≥52–68)
Stripe Sessions — agentic payments, stablecoins, e-commerce first (May 2026)
ACP SEP #232 — Order Schema Post-Checkout Alignment, committed 2026-05-01 by nvp-stripe: github.com/agentic-commerce-protocol
OKX Agent Payments Protocol — open-source, Ethereum/Solana, May 2026: developer.okx.com
x402 production: ClawMart (clawmart.ai), Pickr (pickr.dev), ClawCredit — active May 2026