The Agent Payment Stack Just Split. Discovery Is Now the Bottleneck.

August 1–7, 2026 was the week the agent payment stack formally split. On Monday Cloudflare shipped Wallets + Monetization Gateway. On Thursday OSL Group — a publicly listed company on the Hong Kong Stock Exchange — launched OSL AgentPay. Between them, Circle, AWS, Google Cloud, and a wave of new marketplaces. The stack isn't consolidating. It's bifurcating.

This is good news for the ecosystem. It also creates a problem nobody is talking about.

The Split: Protocol Below, Settlement Above

For two years the agent payment conversation was dominated by protocol wars. x402 vs. AP2 vs. MPP. Which wire format would win? Would agents speak HTTP 402 or something else?

That question is essentially settled. x402 crossed $50 billion in cumulative volume this week — 200 million transactions at an average of ~$0.32 each. It's not the only protocol, but it's the gravitational center. The interesting action has moved up one layer.

The new stack looks like this:

The Settlement Layer Is Fragmenting — That's Healthy

OSL AgentPay is the most significant entrant this week. It's the first publicly listed company (HKEX:863) to operate as an agent payment facilitator. It wraps x402, AP2, and MPP behind a single API, supports multi-stablecoin routing (USDT, USDC, and OSL's own USDGO with $1B+ circulating supply), and adds zero-gas settlement.

Cloudflare's offering is different but equally consequential: x402-native wallets with spend controls, plus a Monetization Gateway that lets any website charge agents per request. With roughly one in five websites behind Cloudflare's network, the distribution advantage is real.

Circle is taking an explicitly anti-x402 approach, building a USDC-native agent stack that doesn't touch HTTP 402 at all. AWS and Google Cloud are both building agent payment gateways with their respective stablecoin partners.

This fragmentation is healthy competition. No single settlement provider should own the rails. But it creates a downstream problem.

The Discovery Problem Nobody Is Solving

When an agent can pay through any of eight facilitators, using any of three protocols, with any of four stablecoins — the payment plumbing works. The bottleneck moves elsewhere: discovery.

How does an agent find the right API to call in the first place?

Think about what happens today. A developer building an agent needs a specific capability — say, CAPTCHA solving or on-chain data. They either:

1. Already know a specific provider (rare for long-tail capabilities)
2. Search GitHub/npm/Google and piece together documentation (time-consuming)
3. Ask another agent — which has the same discovery problem recursively

None of these paths involve payment. The agent ecosystem has spent two years building payment rails that work, but the "what should I pay for?" question remains unsolved.

Managed Marketplaces Are the Wrong Answer

The intuitive solution is a managed marketplace: one company curates the catalog, handles settlement, enforces quality, and takes a cut.

This is where most of the new entrants are heading:

Managed marketplaces solve curation. But they introduce issuer capture: the marketplace owner controls which services are visible, how they're ranked, and what cut they take. This is the same dynamic that made app stores controversial — applied to agent commerce.

The Alternative: Open Discovery, Verified by Actual Calls

An open discovery layer doesn't need to be a managed marketplace. It needs three things:

1. Live verification. Don't trust self-reported metadata. Actually call the endpoint and verify it responds correctly. If it fails 3 times in a row, delist it automatically. This is what search engines do with crawl results — agent discovery needs the same.

2. Free trials. Agents should be able to test a service before committing funds. Not "sign up for an API key" — a real, no-auth, rate-limited trial call that returns actual data. This is the equivalent of "view source" for agent APIs.

3. Facilitator agnosticism. The discovery layer shouldn't care which facilitator the service uses. An agent should find the service first, then the payment details (which protocol, which stablecoin, which facilitator) are negotiated at call time. Discovery and settlement are separate concerns.

minia2a is built on these three principles: 328 services verified by actual HTTP calls, 15 free trials per endpoint (no wallet required), and facilitator-agnostic routing that works with any x402-compatible settlement layer. It's not a managed marketplace — it's an open discovery layer.

What This Means for Developers

If you're building agent payments today, the protocol decision is the easy part. x402 is well-supported and standardized. The settlement decision is getting easier too — OSL, Cloudflare, and Coinbase are competing to make integration simpler.

The hard problem — the one worth building for — is discovery with trust. How does an agent find a service it can rely on? How does a service get discovered by agents that need it? These questions don't have good answers yet, and they're not going to be solved by adding another settlement layer.

The stack split is real. Protocol is standardizing, settlement is competing. Discovery is the next battleground.