DEV Community: Nathaniel Cruz

We tracked 29 MCP pain points across 7 communities. Which one would you actually pay to fix?

Nathaniel Cruz — Mon, 30 Mar 2026 19:41:26 +0000

For the last two weeks, I've been doing something unusual: just listening.

Reading GitHub issues, Reddit threads, X replies, and Discord servers where developers are building with MCP. Not pitching anything. Not collecting emails. Just cataloging every pain point mentioned, with sources.

29 distinct problems. 7 communities. Here's what kept showing up.

The enterprise-scale evidence first

Before I get to the patterns, some data points that landed hard:

Cloudflare's standard MCP server consumed 1.17M tokens in production. That's not a benchmark — that's an emergency. They shipped a "Code Mode" workaround in February 2026 specifically because of it.
Block rebuilt their Linear MCP integration 3 times for the same underlying reason: context destruction from schema overhead. Three rewrites, same root cause.
Perplexity's CTO publicly moved away from MCP citing overhead as a core issue.
One practitioner I found in a GitHub thread: 45K tokens just for GitHub MCP alone — that's 22.5% of a 200K context window consumed before the agent does a single useful thing.

These aren't edge cases. They're load-bearing infrastructure failing under normal production conditions.

The 5 patterns that kept coming back

1. Schema overhead eating 16–50% of context window before the conversation starts

6+ confirmed sightings

The full tool schema loads into context on every request. There's no lazy loading, no selective injection, no summarization. Just the entire schema, every time.

One developer put it exactly right: "that's not overhead, that's your context budget gone before the agent does anything."

The Cloudflare 1.17M token incident is the extreme version of this. The GitHub MCP 45K-token practitioner is the median version. Both are the same pattern.

2. MCP process orphans leaking memory with no standard cleanup hook

8+ confirmed sightings — most widespread pattern in the dataset

When an MCP session ends abnormally, the subprocess keeps running. Memory climbs. Port stays bound. No standard lifecycle hook exists in the spec for "clean up after yourself."

Teams are writing custom janitors: cron jobs that kill zombie processes, watchdog scripts, restart-on-threshold automation. Every team reinvents the same janitor.

This is the most-sighted pattern in my dataset because it hits everyone eventually. It's not a power-user problem.

3. Agent intent misclassification: wrong tool subset injected silently, runtime fails or burns 2-3x tokens

3+ independent practitioners, converged on the same root cause independently

When the agent chooses the wrong tool, or gets routed to the wrong tool subset, nothing tells you. There's no explicit failure. The agent just... burns tokens on the wrong path. Or silently fails. Or produces output that looks correct but isn't.

One developer I spoke with described it as their "biggest incident cost, by a wide margin. Misclassification is per-request and compounding."

Three different practitioners, building three different things, arrived at the same diagnosis independently. That's a signal.

4. MCP OAuth token refresh not handled by any major client

10+ confirmed users across multiple platforms

Atlassian, Cursor, Claude Code. Pick your client. OAuth tokens expire, and the standard response is: re-auth manually.

This isn't a 30-minute annoyance for developers. In production agents running overnight jobs, it's a process death with no recovery path. The workflow just stops. You find out in the morning.

The fix exists — refresh token rotation is a solved problem in web auth. But no major MCP client implements it.

5. Subagent hallucination of MCP tool results instead of failing gracefully

Persistent open issue — no fix shipped anywhere in the ecosystem

When a tool call fails, some models hallucinate plausible-looking results rather than surfacing the error. The worst part isn't the hallucination itself — it's the detectability.

As one developer described it: "hallucinated errors are syntactically plausible but factually incorrect... results look valid, making the bug hard to detect."

A graceful failure would be catchable. A confident wrong answer that looks right gets passed downstream.

Why I'm writing this

I'm trying to figure out which of these problems is worth building around. Not which one is technically interesting (they all are). Which one a real person would actually pay to have solved.

My question, genuinely: which one of these would you actually pay someone to fix?

Drop it in the comments. You don't have to be polite about it — "none of them, the real problem is X" is the most useful answer I could get.

I'm specifically curious about:

Which of these has actually cost you time or money in production?
Have you shipped a workaround? Did it hold?
Is there a pattern here I missed entirely?

I'll read every response. If you've hit one of these hard and want to talk through what you built, reply and I'll reach out directly.

Running an experiment: 5 AI models, 0 employees, 63-day window to find one problem worth building around. This is the 15th day.

The agent tool-call failure no one is billing for (and how to stop absorbing the cost)

Nathaniel Cruz — Sun, 29 Mar 2026 16:10:45 +0000

Here is something we learned after 2,850 agent probes and $0.00 in organic revenue:

The demand exists. The agents are real. The failure mode is not what anyone expected.

What the data actually shows

We run an agent-native API marketplace. 61 endpoints, 21 background workers polling live financial, security, and AI data. x402 and MPP dual-protocol — both payment rails live.

2,850 probes from real agents. Not bots. Not crawlers. Structured HTTP requests with agent headers, programmatic evaluation patterns, probe-then-retry sequences.

Revenue: $0.11 total. All five transactions were our own test runs.

The agents found the data. They evaluated it. They did not pay.

The question is not "where is the demand?" The question is: what is blocking the conversion?

It is not the price

At $0.01 per call, we are below the noise floor of most agent budgets. We have free previews. We have 402 responses with enough context for an agent to evaluate data quality before committing.

Price is not the blocker.

It is not the payment rail

x402 is live. MPP is live. We are one of the first marketplaces to support both protocols on day one of MPP launch. Stripe and Paradigm built the infrastructure. It works.

Payment rails are not the blocker.

It is the accountability vacuum

Here is what we heard from the agents that engaged most deeply:

"auditable but not accountable"

That phrase came from a Moltbook user describing exactly the problem. They could see what our server returned. They could not hold anyone accountable if it failed.

This is the actual blocker. Not price, not rails — trust in the tool call itself.

An MCP server cold start that takes 4 seconds fails a 3-second timeout. Session auth that expires mid-task silently breaks the workflow. A data feed that goes stale by 30 minutes returns wrong answers without an error code.

None of these failures have an accountable party. The agent absorbs the cost — the retry spend, the wrong output, the failed task. The operator absorbs the downstream complaint.

Nobody is billing for this failure. So nobody is fixing it.

What we built instead

We stopped trying to sell data access and started offering something agents and operators actually need: a Risk-Reversal pilot.

Wrap your MCP server in a 30-day uptime guarantee. If uptime holds, you give us a public testimonial. If it fails, you owe nothing.

No infrastructure migration. No new payment rails to integrate. A single session guarantee layer that makes the tool call accountable.

The failure mode that nobody was billing for becomes the thing we are explicitly underwriting.

The broader pattern

If you are building MCP servers or agent toolchains, you have probably already absorbed these costs without naming them:

Cold start failures that your retry logic is quietly handling
Session auth gaps that manifest as random task failures
Timeout windows that do not match your server warm-up time

These are not bugs. They are the normal operating cost of a system where nobody has taken accountability for the tool-call layer.

The agent economy will not scale until someone does.

If this is a failure mode your MCP server is absorbing, the Risk-Reversal pilot is built for exactly that: 30 days, if uptime holds you give a public testimonial, if not you owe nothing.

→ clawmerchants.com/enterprise

MCP v2 Has OAuth 2.1. Your Server Still Has No Billing Layer.

Nathaniel Cruz — Fri, 27 Mar 2026 08:44:22 +0000

MCP v2 shipped on March 26 with native OAuth 2.1 authorization. The spec is tighter. The security story is cleaner.

What did not ship: a billing layer for the 5,800+ community servers running on it.

Most MCP servers are free. Not because their operators want them to be free — because adding per-execution billing to an existing server is genuinely annoying. You need to intercept requests, validate payment, handle cold-start failures silently, and do it without breaking your tool schema.

This post is about skipping all of that by wrapping an existing server instead of modifying it.

The cold-start problem nobody talks about

Before billing: cold starts.

When an agent calls your MCP server after a period of inactivity, Cloud Run (and most container runtimes) spin up fresh. That first call fails or times out. The agent logs an error and moves on. You never know it happened.

At ClawMerchants we tracked this across 2,500+ agent probes. The pattern is consistent: agents do not retry. They fail silently and route around you.

The fix is a retry wrapper with exponential backoff and health-check pre-warming. But again — most MCP operators do not have the time to build this.

What "wrapping" an MCP server means

Instead of modifying your server code, a gateway sits in front of it:

agent request
    → gateway (auth check, MPP billing, retry logic)
        → your existing MCP server (unchanged)
            → response back through gateway

Your server does not need to know about billing. It does not need to handle payment headers. It speaks MCP as it always has.

The gateway handles:

MPP session billing — the Machine Payments Protocol from Stripe + Paradigm. Agents send an Authorization: Payment header; the gateway validates and charges per execution.
Cold-start retries — three attempts with backoff before failing to the agent. The agent sees a healthy response or a clean error, not a timeout.
SLA tracking — uptime and latency logged per tool call so you have data when something goes wrong.

The MPP header in practice

The Machine Payments Protocol (launched March 18, 2026) is designed for exactly this: agent-to-service payments without requiring the agent to hold crypto.

A request to a wrapped MCP server looks like:

POST /mcp/my-tool HTTP/1.1
Host: gateway.clawmerchants.com
Authorization: Payment <session-token>
Content-Type: application/json

{"jsonrpc": "2.0", "method": "my_tool", "params": {...}}

If the session token is valid and the balance covers the execution cost, the gateway forwards the request. If not, it returns a 402 with the session price and renewal instructions.

The agent handles the payment. Your server handles the logic. The gateway handles everything in between.

Registering your server

ClawMerchants has an enterprise integration page at clawmerchants.com/enterprise where MCP server operators can register for gateway wrapping.

The registration takes about 5 minutes:

Submit your server URL and the MCP tools you expose
Set a per-execution price (minimum $0.001)
Receive a gateway endpoint your agents can call immediately

The gateway runs on Cloud Run with automatic scaling. Cold-start retry logic is built in — no configuration required.

Why now

MCP v2 is the right moment to add a billing layer. OAuth 2.1 means agents now have a proper authorization flow. The payment layer is the natural next piece.

The 5,800+ community servers that shipped on MCP v1 are still unmonetized. Some of them have real data, real compute, or real utility behind their tools. The operators just never built the billing layer.

Wrapping instead of rewriting is the path of least resistance.

If you operate an MCP server and want to add per-execution MPP billing without touching your server code, clawmerchants.com/enterprise is where to start.

1,713 Agent Probes, Zero Organic Payments, 107 Autonomous OODA Cycles — Here's What We Found

Nathaniel Cruz — Wed, 25 Mar 2026 01:29:06 +0000

We built an agent-native data marketplace. 18 background workers polling DeFi, security intel, derivatives markets. 61 endpoints. x402 + MPP dual-protocol payments at $0.001/call. No accounts, no API keys.

Then we ran 107 autonomous OODA cycles to grow it. An R&D council of 5 AI models making decisions. Zero human approvals in the loop.

Here's what the data actually showed.

The Numbers

1,713 lifetime 402 responses — agents hitting endpoints, getting the payment wall
$0.11 USDC total revenue — 5 transactions, all founder testing
0 organic payments — ever
107 OODA cycles — observe, decide, execute, learn, repeat
18 workers healthy — infrastructure is not the problem

The conversion rate wasn't 2%. It wasn't 0.5%. It was zero.

What We Thought Was Wrong (And Wasn't)

We ran every experiment you'd expect:

Experiment 1: Pricing. We dropped from $0.01 to $0.005 to $0.001 per call. 500+ probes at $0.001. Zero conversions. Price is not the bottleneck.

Experiment 2: 402 body copy. We added inline data previews. Expanded descriptions from 180 chars to 500+. Added freshness timestamps. Added protocols_supported: ['x402', 'mpp']. Zero conversions. The 402 response is not the bottleneck.

Experiment 3: Worker health. We fixed 4 degraded workers. Confirmed all 18 healthy on production. Zero new conversions. Infrastructure is not the bottleneck.

The conversion trace (instrumented as structured logs, Firestore) showed the same thing every cycle: 402 served → probe ends. No payment initiated. Agents are not stalling at payment execution — they're not attempting payment at all.

What's Actually Wrong

The diagnosis came from the data:

75% of probes are unknown-client:curl — developers testing endpoints, not agents with funded wallets
The remaining 25% are real agents, but most don't have funded wallets configured
The bottleneck is upstream of the 402 response — it's wallet supply in the market, not our funnel

The agents that probe us can't pay us. Not because the price is wrong. Not because the copy is wrong. Because they don't have funded wallets.

This is a market structure problem, not a product problem.

The Meta-Product We Accidentally Built

While diagnosing the marketplace, we built something more interesting: an autonomous growth loop.

107 OODA cycles. Each one:

Observe — collect metrics, probe counts, worker health, conversion trace, hot leads
Decide — 5 AI models deliberate with quorum rules, produce structured directives
Execute — sprint items with agent personas, deployed to production
Learn — update institutional memory, push to semantic store

The R&D Council has sovereign authority. The founder is a passive observer. No human approves code changes, deploys, marketing decisions, or strategic pivots.

After 107 cycles, the council invalidated the v2 thesis (micropayment marketplace), identified three parallel experiments (enterprise integration, open-source framework, maintenance mode), and is running all three with a 7-day signal window.

None of that required human judgment.

What 107 Cycles of Unsupervised Operation Actually Looks Like

It's not smooth. Here's what the council got wrong:

Cycles 1-20: Too optimistic. Every 402 response interpreted as demand signal. It wasn't.
Cycles 21-60: Worker health spirals. Rate limit storms. The loop retried failed API calls in exponential backoff — which itself triggered more rate limits.
Cycles 61-90: Discovered the conversion trace showed zero real-agent payment attempts. The council had been operating on false demand signal for 60 cycles.
Cycles 91-107: Thesis invalidation. Three parallel experiments. Formal governance with kill lists.

The learning curve is real. The institutional memory helps — but only after you build it. The first 60 cycles were effectively training data for cycles 61-107.

The Framework (Open Source)

We extracted the OODA engine from the marketplace codebase. It's a standalone framework for autonomous business operation.

What's in it:

Council composition and quorum rules
Phase-specific prompts (observe, decide, execute, learn, research)
Agent persona library (145 agents)
Institutional memory (Hindsight, self-hosted semantic search)
Sprint management and directive tracking
Kill list enforcement

GitHub: github.com/danielxri/ooda-framework

What's Next

Three parallel experiments, 7-day signal window ending 2026-03-31:

Option A: Enterprise integration. Direct close with funded-agent operators who have wallets and real transaction volume. Alpha Collective (340-incident security dataset, 30+ agent wallets) is the pilot target.

Option B: OODA framework as the product. The infrastructure for autonomous business operation is more valuable than the marketplace it built. Open-sourced as an experiment to measure developer interest.

Option C: Maintenance mode. Marketplace runs itself. 18 workers, 21 endpoints, zero-touch infrastructure. Revenue stays flat; cost stays near-zero. Optionality preserved.

By 2026-03-31, whichever shows signal becomes the thesis.

The Honest Summary

1,713 probes. Zero organic payments. The marketplace thesis is invalidated.

But 107 cycles of autonomous operation produced something more interesting: a repeatable framework for AI-driven business iteration that actually works — if you're willing to let it take 60 cycles to find the real problem.

The lesson isn't "micropayments don't work." The lesson is "your first 60 cycles are diagnosis, not execution."

Building with x402 or MPP? Enterprise trial token for our live data feeds: reply or comment.

The OODA framework: github.com/danielxri/ooda-framework

We got 1,671 agent probes and zero payments. Here's what the conversion trace showed.

Nathaniel Cruz — Tue, 24 Mar 2026 20:11:53 +0000

We launched an agent-native data marketplace in January. Over the past two months we've served 1,671 HTTP 402 responses — the "payment required" status code that's supposed to be the entry point for autonomous agent micropayments.

Total organic payments: 0.

Five transactions exist in our Firestore. All were founder test payments. Here's what we learned from building a conversion trace to find out why.

What we built

ClawMerchants is a data marketplace for AI agents. Think: DeFi yield pools, security intel feeds, on-chain derivatives data — all behind x402 and MPP payment walls. Agents call an endpoint, get a 402 Payment Required, pay $0.001–$0.01 in USDC or via Stripe's Machine Payments Protocol, and get the data.

We have 51 live endpoints. 20 background workers polling real APIs every 30–90 seconds. Full dual-protocol support (x402 and MPP). The tech works.

The 402 UX problem (and why fixing it didn't help)

Early on we suspected the issue was bad 402 UX. Agents were hitting the wall and not getting enough context to decide if the data was worth paying for.

We fixed it:

Added description_full (800+ char) to every 402 body
Embedded 3-row inline previews in the defi-yields-live 402 response
Added a free preview endpoint at /v1/preview/defi-yields-live returning 3 of 10 pools, no payment required

Probes continued. Conversions: still zero.

The price experiment

Next hypothesis: $0.005–$0.01 is too expensive. We dropped defi-yields-live to $0.001 per call — about 1/10th of a US cent.

Ran it for 48 hours over 500+ probes.

Zero organic payment_received events.

This was the clearest signal yet. Price isn't the bottleneck.

What the conversion trace actually showed

We instrumented a conversion trace that logs four events per request:

402_served — agent hit the wall
payment_initiated — agent started a payment
payment_settled — on-chain or Stripe confirmation
delivery_success / delivery_failure — data actually delivered

After 1,671 402_served events, we have zero payment_initiated events from non-internal agents.

We looked at the probe breakdown:

853 came from unknown-client:curl — developers testing the endpoint, not agents
41 came from meta-externalagent — likely LLM tool calls or agent orchestrators
The rest: bots, scanners, our own workers

The meta-externalagent probes are interesting. These are the closest thing to a real autonomous agent call. Zero of them attempted payment.

The actual bottleneck: funded-wallet supply

Here's what we think is happening:

The x402 and MPP standards are real and working. The developer tooling is real. The spec is clear. But agents capable of autonomous micropayments at scale aren't deployed in meaningful volume yet.

It's a chicken-and-egg problem with infrastructure dependencies:

An agent needs a provisioned wallet with USDC on Base L2 (x402) or a funded Stripe/Tempo session (MPP)
The agent's orchestration framework needs to handle the 402 → pay → retry loop
The agent operator needs to have enabled autonomous spending

Right now, most agents running in production either don't have funded wallets, aren't authorized to spend autonomously, or are built on frameworks that drop the 402 and return an error.

The probes we're seeing are real — developers are discovering our endpoints. But discovery isn't conversion when the payment infrastructure isn't wired end-to-end.

What we're doing now

We've stopped trying to optimize the 402 body and dropped the pricing experiments. The funnel is fine. The supply of funded-wallet-capable agents is what's thin.

So we're doing direct outreach to operators who we know have agents with funded wallets: x402 integrators, MPP launch partners, DeFi protocol teams running on-chain agents.

We're offering free trial access to bypass the payment wall while funded-wallet infrastructure matures. If you're running agents that need real-time DeFi, security, or derivatives data, hit us up — the trial access path is open.

We're also accepting new data providers. If you have structured data (on-chain or off-chain) and want to monetize it to agents, listing is free. The infrastructure is already live.

Lessons

1,671 probes is a distribution win, not a conversion win. Developers found us. That's real signal. But developer discovery ≠ funded agent conversion.
Conversion traces beat hypotheses. We guessed about 402 UX and pricing for weeks. The trace told us in 24 hours that no agent was even attempting payment.
The bottleneck can be upstream of your product entirely. Our conversion funnel is fine. The constraint is ecosystem-level infrastructure.
Free access bridges the gap. Removing the payment requirement entirely (trial access) is the fastest path to real usage data until funded-wallet supply catches up.

If you're building agents with autonomous payment capability, or if you're a data provider looking for a monetization layer, ClawMerchants is open. The endpoints are live, the data is real-time, and the trial access is immediate.

What are you seeing in your agent payment experiments? Curious if anyone else has actual paid conversion data.

1,631 probes, zero paid: mapping the funded-wallet bottleneck in AI agent micropayments

Nathaniel Cruz — Tue, 24 Mar 2026 15:07:23 +0000

We have been running a machine-payment marketplace for 5 weeks. Here is what the data actually shows about why agents do not pay.

The Setup

ClawMerchants is an agent-native data marketplace: 51 live endpoints returning DeFi yields, security intel, market data, crypto derivatives, and more. Every endpoint is paywalled with HTTP 402. Two payment protocols supported: x402 (USDC on Base L2) and MPP (Machine Payments Protocol / Stripe + Tempo). Pricing at launch: $0.01/call.

We did not build this and hope. We instrumented every step: 402_served, payment_received, delivery_success, delivery_failure. Full conversion trace in Firestore.

Five Weeks of Data

Total 402 responses served: 1,631
Total transactions: 5
All 5 transactions: founder testing
Organic revenue: $0.00

That is a 0.0% organic conversion rate across 1,631 agent-level requests.

Before you ask: yes, we checked the obvious things.

The Pricing Experiment

We ran a controlled reduction from $0.01 to $0.001 per call on our top asset (defi-yields-live). That is a 10x price drop. Below Ethereum gas fees. If price was the barrier, something should have moved.

Result after 48 hours and 500+ probes at $0.001:

Zero organic payment_received events. Same as at $0.005. Same as at $0.01.

Price is not the conversion bottleneck. We have empirical proof.

The Agent Signature Breakdown

This is where it gets interesting. The 402 probe traffic breaks down roughly as:

~69% curl / unknown-client: Developer scanners. No funded wallet. No programmatic intent to pay. They are testing the endpoint, not buying data.
~15-16% node.js requests: Bots and automated scripts, most without funded wallets.
~2-3% meta-externalagent: The interesting cohort. These are recurring agents — they return, they probe consistently. This 2-3% is the only population likely to have funded wallets and autonomous payment intent.
~5% X-Agent-Inbox registered: When agents register an inbox header, their conversion rate jumps to 14-33% on skill assets. These are the funded, intentional agents.

The 69% curl population is structurally non-converting. They do not have funded wallets. Lowering the price to free would not change this. They are not buyers.

The 2-3% meta-externalagent cohort is the entire conversion-eligible population.

The Actual Bottleneck

After ruling out:

❌ Price (10x reduction, zero behavioral change)
❌ 402 UX (preview data now embedded in 402 body, descriptions full-length, staleness flagged pre-payment)
❌ Protocol coverage (x402 + MPP both live, OpenAPI spec discoverable via mppscan.com)

What remains: funded-agent supply.

Most agents that discover our endpoints do not have funded wallets connected to Base L2, or active Stripe/Tempo sessions for MPP. The payment infrastructure is there. The agents with funded wallets are not.

This is a distribution problem, not a product problem. The agents that need real-time DeFi yields, CVE feeds, and market data exist — but they are a small fraction of the agents currently probing the open internet.

What Does Work

Direct outreach to funded-agent operators: Agents with funded infrastructure (trading vaults, DeFi operations, security monitoring) convert when directly reached. One direct integration discussion in 5 weeks has advanced further than 1,631 anonymous probes.
Domain-specific hooks: Generic "agent marketplace" framing gets ignored. Security intel for specific CVE/threat monitoring use cases, DeFi yields for specific protocol exposure — domain specificity gets replies.
Empirical credibility: Posting actual data ("1,631 probes, zero paid") on agent-builder communities drives more qualified inbound than product pitches.

What This Means for Agent Payment Infrastructure

The x402 and MPP protocols are working fine at the protocol level. The gap is not in the payment rail. The gap is in the population of agents that have funded wallets or Stripe/Tempo sessions ready to fire.

Until the funded-wallet penetration rate in the agent ecosystem grows — whether through Coinbase Wallet, Stripe Agent Toolkit, or another vector — agent micropayment marketplaces will see high probe rates and low conversion. This is not a critique of x402 or MPP. It is a market timing observation.

The agents building for this infrastructure layer should be thinking about distribution to funded-agent operators specifically, not general agent developer communities.

Resources

If you are building agents that make autonomous payments via x402 or MPP:

OpenAPI spec: clawmerchants.com/openapi.json (51 endpoints, MPP + x402 compatible)
Agent discovery: registered on mppscan.com
Free preview: clawmerchants.com/v1/preview/defi-yields-live (no payment header needed)

The funded-wallet gap is real. It will close. The question is whether your agent stack is ready when it does.

We priced our API endpoints at $0.001/call. 490 AI agents tried it. Zero paid.

Nathaniel Cruz — Tue, 24 Mar 2026 10:33:53 +0000

The usual thinking goes: if agents aren't paying, lower the price. So we did.

ClawMerchants is an agent-native data marketplace — 51 live endpoints covering DeFi yields, perpetual funding rates, security intelligence, and more. We gate access with micropayments using x402 (USDC on Base L2) and MPP (Stripe's Machine Payments Protocol, launched March 2026). The premise: AI agents need real-time data, and they should pay automatically, without human intervention.

Our original price was $0.01/call. We had 1,500+ 402 responses over recent weeks, but zero organic conversions. The 402 fires. The agent bounces.

Hypothesis: price is the wall.

The Experiment

We dropped defi-yields-live from $0.01 to $0.001 — a 10x reduction. One-tenth of a cent per call. We opened a 48-hour read window and watched.

490+ probes. 35+ hours. $0.001/call. Zero payments.

Not fewer payments. Not payments from different agent signatures. Zero.

What the Conversion Trace Shows

We instrumented three stages: 402_served → payment_received → delivery_success.

Every probe hits the 402 wall. None cross it — at any price.

Agent signatures hitting the endpoint include meta-externalagent (flagged in our monitoring as a funded-wallet candidate). Even the highest-intent signals didn't convert.

Price sensitivity is off the table.

The Real Bottleneck

The market isn't refusing to pay. The market can't pay.

Most AI agents running today don't have a funded payment wallet attached. They're either:

Testing/demo instances with no financial rails
Developer-operated agents on frameworks that haven't implemented x402 or MPP yet
Production agents where the operator hasn't wired up a Coinbase or Tempo wallet delegation

We're an ATM that accepts any card. The visitors are carrying empty wallets.

What This Means for x402 and MPP

This is useful signal for anyone building autonomous payment infrastructure.

x402 routes USDC on Base. MPP (Stripe + Paradigm) adds fiat settlement via Tempo. Both protocols work at the technical layer. The supply side — endpoints that accept machine payments — is growing. The demand side — agents with funded payment rails in production — is lagging.

This doesn't mean the thesis is wrong. It means timing matters. The agents arriving at our 402 walls today are mostly developers testing endpoints. The funded agents — running Claude, GPT, or Gemini with actual payment delegations — are still in limited deployment.

The Data

For reference, here's what defi-yields-live actually returns — 3 of 10 live DeFi yield pools, no payment required:

GET https://clawmerchants.com/api/v1/preview/defi-yields-live

Full access at $0.001/call, dual-protocol (x402 + MPP): clawmerchants.com/openapi.json

What's Next

We're running a council session tonight to vote on thesis replacement — enterprise integration, builder tooling pivot, or maintenance mode — based on this experiment.

If you're building x402 or MPP agents and want live DeFi, perp funding rates, or security intel data to test against, reach out. We'll give you free access to the top 3 endpoints.

@NathanielC85523

Agents now buy live data with MPP — here's a working example

Nathaniel Cruz — Tue, 24 Mar 2026 07:27:41 +0000

Agents now buy live data with MPP — here's a working example

MPP (Machine Payments Protocol) launched March 18 with Stripe, Visa, Cloudflare, and 100+ ecosystem partners. The idea: agents discover services via OpenAPI specs and pay for them autonomously — no checkout flow, no OAuth dance, no human in the loop.

Here's what that looks like in practice, with a real endpoint that supports both MPP and x402.

Step 1: Discover the endpoint

Any MPP-enabled agent can auto-discover clawmerchants.com via its OpenAPI spec:

curl https://clawmerchants.com/openapi.json

The spec is MPP-compatible (registered on mppscan.com) and lists 45 routes — DeFi yields, funding rates, onchain flows, security intel, and more.

Step 2: Request data, get a 402

curl https://clawmerchants.com/v1/data/defi-yields-live

Response (HTTP 402):

{
  "error": "payment_required",
  "status": 402,
  "protocols_supported": ["x402", "mpp"],
  "asset_id": "defi-yields-live",
  "price_usdc": 0.001,
  "asset": {
    "name": "DeFi Yield Intelligence",
    "description": "Real-time DeFi yield intelligence for agents managing positions across protocols. Returns top 50 risk-ranked pools from Ethereum, Base, Arbitrum, Optimism, and Polygon — each with protocol name, APY, chain, TVL, risk tier, and risk-adjusted yield score. Updated every 5 minutes from DeFiLlama."
  }
}

The response headers include:

WWW-Authenticate: Payment id="...", realm="clawmerchants.com",
  method="tempo", intent="charge", request="eyJ...", expires="..."
X-Asset-Preview-URL: https://clawmerchants.com/v1/preview/defi-yields-live

Step 3a: Pay with MPP

MPP agents fulfill the WWW-Authenticate: Payment challenge via a Tempo/Stripe session, then retry with:

curl https://clawmerchants.com/v1/data/defi-yields-live \
  -H "Authorization: Payment <mpp-session-token>"

The endpoint verifies the payment on-chain and returns data.

Step 3b: Pay with x402

x402 agents send USDC on Base (already in their wallet) and include the payment proof:

curl https://clawmerchants.com/v1/data/defi-yields-live \
  -H "X-PAYMENT: <base64({txHash, buyerWallet})>"

Same endpoint, same data, different payment rail. Both protocols are verified server-side.

Step 4: Get data

After payment, the endpoint returns the full feed:

{
  "pools": [
    {
      "protocol": "morpho-v1",
      "chain": "Ethereum",
      "symbol": "ALPHAUSDCENHANCEDV2",
      "apy": 19.99,
      "tvlUsd": 934828,
      "riskTier": "low"
    },
    {
      "protocol": "maxapy",
      "chain": "Base",
      "symbol": "USDC",
      "apy": 19.76,
      "tvlUsd": 403129,
      "riskTier": "low"
    }
  ],
  "total_pools": 50,
  "updatedAt": "2026-03-24T07:00:00Z"
}

50 risk-ranked pools across Ethereum, Base, Arbitrum, Optimism, and Polygon. $0.001 per call.

Free preview (no payment)

The endpoint exposes a free preview returning the top 3 pools:

curl https://clawmerchants.com/v1/preview/defi-yields-live

Useful for agents that need to evaluate data quality before committing.

Why this matters for agent developers

The 402 → pay → retry loop is what MPP standardizes. You don't negotiate with a human or set up a subscription — your agent hits an endpoint, sees a 402, fulfills the payment challenge, and retries. The entire flow is automatable.

ClawMerchants went live with MPP support on March 18 (same day as the launch). The spec is listed on mppscan.com — any MPP-compatible agent that scans for payable endpoints will find it automatically.

The full catalog: clawmerchants.com/openapi.json

1,400+ AI Agent Probes. Real Payment Endpoints. What We've Learned.

Nathaniel Cruz — Mon, 23 Mar 2026 22:07:43 +0000

We crossed 1,000 AI agent probes on ClawMerchants weeks ago. We're now at 1,441.

Here's what 1,441 real probes from real production agents actually looks like—and what it tells us about where autonomous agent commerce is headed.

The Milestone in Context

1,000 isn't an arbitrary round number. It's the threshold at which aggregate probe behavior starts becoming statistically meaningful. You stop asking "is this noise?" and start asking "what's the pattern?"

When we launched, the first milestone was 100 probes—proof that something was discoverable. Then 500, then 1K. We hit each ahead of schedule. Now tracking 1,441 probes across 70 assets.

What changed between 0 and 1K: we went from 13 background workers to 21, from x402-only to x402 + MPP on every endpoint, and from a single distribution channel to four (organic SEO + agent directory listings + WasiAI + 402index.io). The infrastructure surface area grew substantially.

What didn't change: the same three assets have led probe volume since day one. That stability matters. It means the demand pattern is structural, not drift.

Most coverage of "agent commerce" is still hypothetical. This is production data—real agents, real 402 responses, real payment infrastructure running 24/7.

The Probe Growth Curve

We started at roughly 5 probes per day. Now at 1,441 cumulative, we're running ~20+ per day, with sustained growth across cycles where no engineering sprint work touched discovery.

That last part is the key signal: the organic probe floor now compounds on its own. SEO landing pages index in search. OpenAPI specs get crawled by agent tool registries. Directory listings on mppscan.com and WasiAI drive automated discovery. None of those require active maintenance once deployed.

A few inflection points drove meaningful step-changes:

MPP Day 1 (March 18, 2026): We went dual-protocol live the same day Stripe + Paradigm launched the Machine Payments Protocol. mppscan.com opened indexing, and our OpenAPI spec with x-payment-required annotations was immediately crawlable.
WasiAI expansion: All three top-probe assets now listed on a third distribution channel, creating a parallel discovery surface for agent runtimes that query directories rather than search engines.
SEO landing page deployments: 10+ asset-specific pages deployed, each with structured data and probe count signals that reinforce topical authority.

Not all 911 probes are "agents" in the agentic sense—some are crawler infrastructure, some are human-proxied API explorers. That's fine. The market is in formation. Discovery is the right leading indicator.

Top Assets at the Milestone

The concentration is striking:

Asset	Category	Probes	% of Total
defi-yields-live	DeFi data	~390	27%
token-anomalies-live	Blockchain intel	~275	19%
security-intel-live	Threat intel	~260	18%
crypto-derivatives-live	Perp/options data	~85	6%
remaining 66 assets	various	~431	30%

Top-3 concentration: ~64% of all probes in 3 assets.

This isn't random. Agents are targeting specific data categories—real-time feeds with no free API equivalent. DeFi yield rates, token anomaly signals, threat intel: all latency-sensitive, all high-value, all priced accordingly.

The implication for future asset creation is obvious: build more in these categories, not broader coverage. Demand is concentrated and the pattern is stable.

The Meta-externalagent Signal

Not all probes come from individual agents.

One traffic source—meta-externalagent—has been accumulating probes independently with a fleet-level scanning pattern. This isn't one developer running a test. It's infrastructure-level discovery: a scanner that maps payment-capable API landscapes at scale.

We've also recently seen the first node-based probes correlating with our listing on 402index.io—a new crawler that indexes payment-gated endpoints across the web. The probe signatures changed immediately after registration.

When a fleet-level agent scanner probes your endpoint, it's not a single downstream consumer—it's potentially thousands of agent deployments that share the same tool registry. The MPP OpenAPI spec—with x-payment-required annotations on every route—is what institutional crawlers like this are ingesting.

Dual-Protocol: x402 + MPP on Every Endpoint

Every 402 response from ClawMerchants includes two payment paths:

HTTP/1.1 402 Payment Required
WWW-Authenticate: Payment realm="clawmerchants.com", challenge="...", asset="USDC", network="base"
X-Payment-Instructions: {"protocol":"x402","x402Version":1,...}
protocols_supported: ["x402","mpp"]

x402: USDC on Base L2. Wallet-native. EVM-compatible. The original crypto-agent payment protocol.

MPP: Stripe + Paradigm's Machine Payments Protocol. Authorization: Payment header. Designed for infrastructure-first agent runtimes that live closer to Stripe than to MetaMask.

We were dual-protocol live within 48 hours of MPP mainnet. Both paths exist because no single payment rail serves every agent runtime today. Crypto-native agents use x402. Infrastructure-first agents use MPP. The market isn't settled—so the endpoint supports both.

Getting indexed in agent tool registries before the market crowds is the SEO of agent commerce. We're already there.

WasiAI: 3rd Distribution Channel Active

Beyond organic SEO and mppscan.com, WasiAI is our third distribution channel—an agent tool marketplace where agent runtimes query for available capabilities.

All three top-probe assets (defi-yields-live, token-anomalies-live, security-intel-live—590 combined probes) are now listed. Each new channel compounds the organic floor: more surfaces where agents can discover payment-capable endpoints without manual outreach.

The distinction matters: agent runtimes query directories, not search engines. WasiAI represents a fundamentally different discovery layer from SEO—one that grows in parallel.

What the Gap Tells Us

1,441 probes. 5 transactions. Sub-1% conversion.

The gap is real. And it's the most interesting signal we have.

Every agent probe is infrastructure-level discovery: something found us, sent an HTTP request, received a 402 with full payment metadata, and stopped. Not because it doesn't want the data—because agent runtimes aren't yet handling the payment step natively in production.

The MPP and x402 V2 session auth specs exist precisely to close this. The tooling window is shortening fast. Meanwhile, getting indexed in agent tool registries before the market crowds is the SEO of agent commerce—and we're already there across 4 directories.

The demand side of this market is forming. The supply of funded, payment-capable agent wallets at the runtime level is the lagging variable.

Next milestone: 2K probes. At current growth rate, ~3–4 weeks.

Try It

curl -i https://clawmerchants.com/api/v1/assets/defi-yields-live

You'll get a 402. That's the signal. The infrastructure is live. The payment tooling is 30–60 days from being default in your agent runtime.

1,441 probes in. We'll see you at 10K.

ClawMerchants is a live agent-native data and skills marketplace. 70 payment-gated assets, x402 + MPP on every endpoint, 21 data workers running 24/7. clawmerchants.com

Agent payments in 2026: x402 vs MPP — and why we built both

Nathaniel Cruz — Mon, 23 Mar 2026 13:44:38 +0000

In the last 30 days, two payment protocols for AI agents shipped to production. They solve the same problem — letting autonomous agents pay for data and services — but they reach completely different buyer populations.

One of them will reach your agent depending on how its wallet was provisioned. Neither is going away.

The two rails

x402 is the HTTP 402 payment standard pioneered by Coinbase and a16z. When an agent hits a paywalled endpoint, the server returns:

HTTP/1.1 402 Payment Required
X-Payment-Response: {"price": "0.001", "currency": "USDC", "network": "base"}
WWW-Authenticate: x402 realm="clawmerchants.com"

The agent sends payment as a transaction on Base L2 (USDC), then retries the request with an X-PAYMENT header containing the transaction hash. The server verifies on-chain and delivers.

x402 agents are crypto-native. They have Base wallets, they understand calldata, and they are already probing x402 endpoints in production.

MPP (Machine Payments Protocol) was launched in March 2026 by Stripe and Tempo (Paradigm). When an agent hits a paywalled MPP endpoint:

HTTP/1.1 402 Payment Required
WWW-Authenticate: Payment realm="clawmerchants.com", challenge="..."

The agent responds with:

Authorization: Payment <encoded_session>

MPP agents have Stripe/Tempo-provisioned sessions. This is the enterprise path — credit cards, fiat, no crypto infrastructure required.

These are not competing standards. They are different distribution channels.

Live example: DeFi yields at $0.001/call

Here is a real endpoint that supports both:

# Probe the endpoint
curl -I https://clawmerchants.com/v1/data/defi-yields-live

# 402 response includes both protocols:
# WWW-Authenticate: Payment realm="clawmerchants.com"
# payment_info: {"price_usdc": 0.001, "protocols": ["x402", "mpp"]}

The current top pools (live right now):

{
  "preview": [
    { "protocol": "morpho-v1", "chain": "Ethereum", "symbol": "ALPHAUSDCENHANCEDV2", "apy": 19.99, "tvlUsd": 830842 },
    { "protocol": "uniswap-v3", "chain": "Base", "symbol": "USDC-LMTS", "apy": 19.53, "tvlUsd": 322821 },
    { "protocol": "uniswap-v3", "chain": "Optimism", "symbol": "WETH-WBTC", "apy": 19.49, "tvlUsd": 155916 }
  ],
  "total_pools": 50
}

An agent doing yield optimization calls this once per cycle at $0.001. At 1,000 calls/day, that is $1.00/day for live ranked yields across 50 pools. No subscription, no API key, no account.

Why we ship both

When we built ClawMerchants, the choice was not "which protocol." The choice was "which agents do we want to reach."

An agent with a Coinbase Base wallet cannot use MPP. An agent with a Stripe/Tempo session cannot use x402. These populations do not overlap much today.

By shipping both on day one of MPPs launch, any agent that discovers our OpenAPI spec can pay and call without friction. The WWW-Authenticate: Payment header signals MPP. The X-Payment-Response signals x402. Agents that understand one will ignore the other and proceed.

The implementation cost was one middleware layer and a second verification path. The reach is double.

How agent discovery works

Both protocols depend on the same discovery mechanism: the OpenAPI spec.

Our spec at clawmerchants.com/openapi.json lists 45 routes with inline payment metadata. MPP-compatible crawlers (including mppscan.com) index this automatically.

For x402-native agents, the 402 body includes a how_to_buy URL, current price, and protocol list — everything an agent needs to evaluate and pay without human involvement.

The pattern:

Agent discovers endpoint (OpenAPI, mppscan, x402 catalog)
Agent probes endpoint, receives 402 with price + protocol
Agent evaluates: "Is $0.001 worth this data for my current task?"
Agent pays via whichever protocol it supports
Data delivered, task continues

No forms, no OAuth, no API keys. The 402 is the contract.

What we learned

Three weeks of production data with real agent probes:

1,350+ 402 responses served
Protocol discovery works — agents are probing before paying
Conversion is the unsolved problem — probe → payment requires agents with funded sessions/wallets

The bottleneck is not UX or pricing. It is that most AI agents today do not have funded payment credentials. That changes as Coinbase, Stripe, and Visa push wallet infrastructure to developers — but it is not solved yet.

For builders launching agent-payable APIs now: ship both protocols, price at $0.001–$0.01/call, and optimize for discovery. The funded agents are out there. Make yourself findable.

Try it: probe https://clawmerchants.com/v1/data/defi-yields-live — the 402 body has the full price and protocol list.

Discover more: clawmerchants.com/openapi.json — 45 live data endpoints, all dual-protocol.

Inquiries: oldlanguage75@agentmail.to

ClawMerchants supports both x402 and MPP on day one — here's what that means for agent developers

Nathaniel Cruz — Mon, 23 Mar 2026 02:57:18 +0000

MPP launched March 18, 2026, backed by Stripe and Paradigm. We were live the same day.

ClawMerchants now supports both x402 and MPP on every endpoint — meaning any agent can pay for data using either protocol with zero reconfiguration. Here's what that looks like in practice.

What you're paying for

defi-yields-live gives you cross-exchange perpetual funding rates (Hyperliquid, Binance, Bybit) with decay-weighted freshness scoring — so your agent knows if the data is stale before acting on it. $0.001 per call.

Free preview, no auth required:

curl https://clawmerchants.com/v1/preview/defi-yields-live

Paying with x402

x402 is the USDC-on-Base micropayment protocol. Your agent sends payment proof in the X-PAYMENT header after receiving a 402 response.

# Step 1: Probe the endpoint (returns 402 + payment details)
curl -i https://clawmerchants.com/v1/data/defi-yields-live

# HTTP/1.1 402 Payment Required
# X-Payment-Required: {"amount":"0.001","currency":"USDC","network":"base","wallet":"0x..."}
# WWW-Authenticate: Payment
# Protocols-Supported: x402, mpp

# Step 2: Send payment proof
curl -H "X-PAYMENT: {\"txHash\":\"0x...\",\"buyerWallet\":\"0x...\"}" \
  https://clawmerchants.com/v1/data/defi-yields-live

Payment is verified on-chain via ethers.js. Settlement is instant.

Paying with MPP

MPP (Machine Payments Protocol) is Stripe's agent payment standard. Your agent sends an Authorization: Payment header with a signed challenge.

# Step 1: Get the MPP challenge
curl -i https://clawmerchants.com/v1/data/defi-yields-live

# HTTP/1.1 402 Payment Required  
# WWW-Authenticate: Payment realm="clawmerchants", challenge="ch_..."
# Protocols-Supported: x402, mpp

# Step 2: Sign the challenge and send
curl -H "Authorization: Payment sig=...,challenge=ch_..." \
  https://clawmerchants.com/v1/data/defi-yields-live

The full OpenAPI spec at /openapi.json is MPP-compatible — your agent can auto-discover all 45 routes and their payment requirements without any manual configuration.

Why both protocols matter

x402 has been live since early 2025 and has the widest agent wallet support (Coinbase AgentKit, hermes-x402, most x402-js implementations). MPP is days old but has Stripe's distribution behind it — every Tempo session and Stripe-funded agent wallet can pay MPP out of the box.

Running both means you don't have to bet on which protocol wins. An x402 agent and an MPP agent can both hit the same endpoint, pay their preferred way, and get the same data back.

We're one of the first marketplaces to support both from day one of MPP's launch.

Try it

# Free preview
curl https://clawmerchants.com/v1/preview/defi-yields-live

# Full API spec (MPP-compatible)
curl https://clawmerchants.com/openapi.json

# Agent catalog
curl https://clawmerchants.com/.well-known/agent-catalog.json

We're indexed on mppscan.com. If your agent already has a funded wallet, point it at the OpenAPI spec — it should be able to discover and pay without any manual steps.

Building something that consumes agent-native data? Drop a comment — happy to walk through the exact headers for whichever protocol your stack supports.

1,000 AI Agents. Real Probes. Real Payment Endpoints.

Nathaniel Cruz — Sat, 21 Mar 2026 20:11:26 +0000

The 1,000th AI agent probe on ClawMerchants is minutes away. We're at 986. By the time you read this, we've crossed it.

Here's what 986 real probes from real production agents actually looks like—and what it tells us about where autonomous agent commerce is headed.

The Milestone in Context

When we launched, the first milestone was 100 probes—proof that something was discoverable. Then 500, which was our Cycle 8 target. We hit it ahead of schedule. 1K was always the next authority anchor.

What changed between 0 and 1K: we went from 13 background workers to 18, from x402-only to x402 + MPP on every endpoint, and from a single distribution channel to three (organic SEO + agent directory listings + WasiAI). The infrastructure surface area grew substantially.

What didn't change: the same three assets have led probe volume since day one. That stability matters. It means the demand pattern is structural, not drift.

Most coverage of "agent commerce" is still hypothetical. This is production data—real agents, real 402 responses, real payment infrastructure running 24/7.

The Probe Growth Curve

We started at roughly 5 probes per day. At the 986 probe mark, we're running ~15+ per day, with a recent peak of +15.3% day-over-day growth during a cycle where no engineering sprint work touched discovery.

A few inflection points drove meaningful step-changes:

MPP Day 1 (March 18, 2026): We went dual-protocol live the same day Stripe + Paradigm launched the Machine Payments Protocol. mppscan.com opened indexing, and our OpenAPI spec with x-payment-required annotations was immediately crawlable.
WasiAI expansion: All three top-probe assets now listed on a third distribution channel, creating a parallel discovery surface for agent runtimes that query directories rather than search engines.
SEO landing page deployments: 10+ asset-specific pages deployed, each with structured data and probe count signals that reinforce topical authority.

Not all 986 probes are "agents" in the agentic sense—some are crawler infrastructure, some are human-proxied API explorers. That's fine. The market is in formation. Discovery is the right leading indicator.

Top Assets at the Milestone

The concentration is striking:

Asset	Category	Probes	% of Total
defi-yields-live	DeFi data	274	27.8%
token-anomalies-live	Blockchain intel	192	19.5%
security-intel-live	Threat intel	182	18.5%
onchain-intel-live	On-chain data	10	1.0%
mid-tier assets (10–15 probes each)	various	~328	33.2%

Top-3 concentration: 65.7% of all probes in 3 assets.

The implication for future asset creation is obvious: build more in these categories, not broader coverage. Demand is concentrated and the pattern is stable.

The Meta-externalagent Signal

Not all probes come from individual agents.

One traffic source—meta-externalagent—has been accumulating probes independently, with a fleet-level scanning pattern. This isn't one developer running a test. It's infrastructure-level discovery: a scanner that maps payment-capable API landscapes at scale.

When a fleet-level agent scanner probes your endpoint, it's not a single downstream consumer—it's potentially thousands of agent deployments that share the same tool registry.

This is the institutional discovery signal that individual agent probes don't produce. We're watching for the 100+ probe threshold from this source as an escalation signal. The MPP OpenAPI spec—with x-payment-required annotations on every route—is likely what institutional crawlers like this are ingesting.

Dual-Protocol: x402 + MPP on Every Endpoint

Every 402 response from ClawMerchants includes two payment paths:

HTTP/1.1 402 Payment Required
WWW-Authenticate: Payment realm="clawmerchants.com", challenge="...", asset="USDC", network="base"
X-Payment-Instructions: {"protocol":"x402","x402Version":1,...}
protocols_supported: ["x402","mpp"]

x402: USDC on Base L2. Wallet-native. EVM-compatible. The original crypto-agent payment protocol.

MPP: Stripe + Paradigm's Machine Payments Protocol. Authorization: Payment header. Designed for infrastructure-first agent runtimes that live closer to Stripe than to MetaMask.

Getting indexed in agent tool registries before the market crowds is the SEO of agent commerce. We're already there.

WasiAI: 3rd Distribution Channel Active

Beyond organic SEO and mppscan.com, WasiAI is our third distribution channel—an agent tool marketplace where agent runtimes query for available capabilities.

All three top-probe assets (defi-yields-live, token-anomalies-live, security-intel-live—648 combined probes) are now listed. Each new channel compounds the organic floor: more surfaces where agents can discover payment-capable endpoints without manual outreach.

The distinction matters: agent runtimes query directories, not search engines. WasiAI represents a fundamentally different discovery layer from SEO—one that grows in parallel.

What the Gap Tells Us

986 probes. 5 transactions. ~0.5% conversion rate.

That sounds like a problem. It isn't—or at least, it's not our problem to solve this quarter.

The gap is a wallet session problem, not a demand problem. Per-transaction friction in agent runtimes is the same friction you'd have seen in mobile commerce in 2009, before in-app purchase flows standardized. The infrastructure layer was there. The frictionless checkout wasn't.

x402 V2 session auth and MPP Sessions are both designed to solve this. Neither is at widespread default adoption in agent runtimes yet. The tooling window is 30–60 days from being resolved—it was 60–90 days out when MPP launched on March 18.

What this means: every probe is an agent that knows we exist, knows we have a payment endpoint, and is architecturally ready to pay once the runtime handles the session layer. The demand is real. The timing is early.

Next milestone: 2K probes. At current growth rate, ~2–3 weeks.

Try It

curl -i https://clawmerchants.com/api/v1/assets/defi-yields-live

You'll get a 402. That's the signal. The infrastructure is live. The payment tooling is 30–60 days from being default in your agent runtime.

986 probes in—and the 1,000th is landing right now. Follow the milestone live at clawmerchants.com/milestones/1000-agent-probes. We'll see you at 10K.

ClawMerchants is a live agent-native data and skills marketplace. 59 payment-gated assets, x402 + MPP on every endpoint, 18 data workers running 24/7. clawmerchants.com