The Agentic Payment Protocol Wars

X402 vs UCP vs ACP vs AP2, And Why the Answer Isn't Picking a Winner

I've spent the last year integrating every major agentic payment protocol into a single SDK. Not studying them from the outside actually writing the adapter code, handling the edge cases, debugging the interop failures.

Here's what the landscape actually looks like from the inside, and why the fragmentation problem is worse than most people realize.

The Protocols

x402: Coinbase (HTTP 402 Micropayments)

What it does: Resurrects the HTTP 402 status code. Server returns 402 Payment Required with a payment header. Client pays via stablecoin (USDC on Base). Server verifies payment, serves content.

How it works:

1. Agent requests resource → Server returns 402 + payment requirements


2. Agent constructs stablecoin transaction


3. Agent submits payment proof in retry request


4. Server verifies on-chain, serves resource

Strengths: Elegant. Simple. Native to HTTP. Works with any web resource.

Weaknesses: Only stablecoins on Base (expanding, but limited). Micropayment-focused, not designed for complex commerce flows. No negotiation phase, the price is the price.

Our integration: ProtocolDetector identifies 402 responses and auto-constructs payment transactions. Works out of the box.

UCP: Google/Shopify (Universal Commerce Protocol)

What it does: Commerce orchestration. The counterparty describes what it can do ("I sell API calls, compute time, and data feeds"), and the agent negotiates terms.

How it works:

1. Agent discovers UCP-enabled service → service publishes capabilities


2. Agent and service negotiate (quantity, pricing, terms)


3. Agreement reached → payment executed


4. Service delivers

Strengths: Flexible. Supports discovery, negotiation, and complex multi-item transactions. Agent can compare services and shop around.

Weaknesses: Complex. The negotiation phase adds latency. Requires both parties to implement the full UCP spec, not a drop-in for existing APIs.

Our integration: ProtocolDetector identifies UCP capability endpoints. The AgentWallet handles the negotiation loop. Policy checks apply at each stage.

ACP: OpenAI/Stripe (Agent Commerce Protocol)

What it does: Structured transaction format. The service presents a cart ("here's what you're buying, here's the price"), the agent confirms and pays.

How it works:

1. Service presents SharedPaymentToken with cart contents


2. Agent validates cart against policy


3. Agent authorizes payment


4. Service fulfills

Strengths: Familiar (it's basically Stripe Checkout for agents). Already live in ChatGPT. Strong backing from OpenAI + Stripe.

Weaknesses: Rigid. No negotiation you accept the cart or you don't. Vendor-locked to the OpenAI/Stripe ecosystem in practice. The SharedPaymentToken format is specific to ACP.

Our integration: ProtocolDetector identifies ACP token formats. Policy evaluation occurs pre-authorization. Evidence bundle includes cart contents and authorization proof.

AP2: Google (Agent Payment Protocol v2)

What it does: Cryptographically signed delegation mandates. The principal (human/company) creates a W3C Verifiable Credential that authorizes the agent to spend up to $X on category Y.

How it works:

1. Principal creates signed delegation mandate (VC format)


2. Agent presents mandate to service


3. Service verifies the signature chain


4. Transaction executes within mandate bounds

Strengths: Strongest authorization model. The mandate is a cryptographic proof of delegation — not just a session token. Supports nested delegation (agent A delegates to agent B within tighter bounds).

Weaknesses: Complex credential management. Requires VC infrastructure. Not widely adopted yet. The specification is still evolving.

Our integration: ProtocolDetector identifies AP2 mandate presentations. Session key bounds are mapped to mandate constraints for interop.

MPP: Session-Based Budget Allocation

What it does: Pre-allocated budget pools that agents can draw from within defined bounds.

How it works:

1. Principal allocates a budget pool (e.g., 1000 USDC for this session)


2. Agent operates within pool bounds


3. Each transaction decrements the pool


4. Session ends → remaining funds returned

Strengths: Simplest model for bounded spending. No per-transaction authorization needed once the pool is set.

Weaknesses: No protocol negotiation assumes the payment method is already agreed. Coarse-grained control.

Our integration: MPP is native to Veridex — this is essentially what our session key system does at the protocol level.

The Fragmentation Problem

Here's the reality in April 2026:

• 
  Coinbase-ecosystem services speak x402


• 
  Google-ecosystem services speak UCP or AP2


• 
  OpenAI-ecosystem services speak ACP


• 
  Crypto-native services speak MPP or raw transactions


• 
  Most services speak none of these yet

An AI agent that only speaks one protocol can only transact with services in that ecosystem. An agent that speaks all five can transact with anyone.

But no developer wants to integrate five protocols. The protocol-specific code is complex, each has different discovery mechanisms, different negotiation flows, different payment formats, different verification methods.

Why We Built ProtocolDetector

ProtocolDetector in @veridex/agentic-payments solves this:

const wallet = await createAgentWallet({ ... });



// Developer writes this ONE integration:

const result = await wallet.pay({

  recipient: 'https://api.example.com/resource',

  amount: '5.00',

  currency: 'USDC',

});



// ProtocolDetector handles:

// 1. Probe the endpoint → detect which protocol(s) it supports

// 2. Select the optimal protocol based on cost, speed, and agent policy

// 3. Execute the protocol-specific flow

// 4. Generate a unified evidence bundle regardless of protocol used

One API. Five protocols underneath. The developer never writes protocol-specific code.

My Take

The protocol wars won't produce a single winner. Not in 2026, probably not ever.

• 
  x402 will dominate micropayments and API monetization (it's too elegant not to)


• 
  ACP will dominate the OpenAI ecosystem (they have distribution)


• 
  UCP will dominate complex commerce (Google + Shopify is a powerful combo)


• 
  AP2 will dominate enterprise delegation (cryptographic mandates are what compliance needs)


• 
  MPP will remain the default for session-based budgets

The answer isn't picking a winner. It's building the abstraction layer that speaks all of them.

That's what @veridex/agentic-payments does. 257 tests. 5 protocols. 1 API.

This analysis is based on our Agentic Payments Protocol Map research paper, which maps the full protocol landscape including AXTP, VIC, MAP, and the trust/identity prerequisites (ERC-8004, Visa TAP). Full paper available on request.

If you're building agents that need to transact across protocol ecosystems, the SDK is open: npm install @veridex/agentic-payments