Two protocols, one agent workflow: MCP tells the agent what tools exist. x402 tells the agent what they cost. Together, they solve the hardest problem in agent commerce — an agent that doesn't know a tool exists can't pay for it, and an agent that can't pay for a tool can't use it.
Agent-to-agent commerce has been stuck on a chicken-and-egg problem: discovery without payment is a catalog. Payment without discovery is a wallet with nowhere to spend. You need both.
Two protocols, developed independently, are converging to solve this:
| Protocol | Problem | How It Works | Status |
|---|---|---|---|
| MCP (Model Context Protocol) | Discovery | Agent queries an MCP server → gets a list of available tools with descriptions and parameter schemas | Production — used by Claude, Cursor, Continue, and others |
| x402 (HTTP 402 Payment Required) | Payment | Agent requests a tool → gets a 402 with price and payment rails → pays in USDC → retries → gets the result | Production — $50B+ in total volume, 200M+ transactions |
Separately, each solves half the problem. Together, they form a complete protocol stack for autonomous agent commerce.
Here's what happens when an agent uses both protocols in sequence:
┌─────────────────────────────────────────────────────┐
│ 1. Agent → MCP Server: "What tools are available?" │
│ ← Response: [captcha-solve, gas, web-scrape, ...] │
├─────────────────────────────────────────────────────┤
│ 2. Agent → Tool Endpoint: GET /x402/captcha-solve │
│ ← Response: 402 Payment Required │
│ { accepts: [{ asset: "USDC", price: 5, ... }] }│
├─────────────────────────────────────────────────────┤
│ 3. Agent → Facilitator: Settle 5¢ USDC on Base │
│ ← Response: txHash 0x... │
├─────────────────────────────────────────────────────┤
│ 4. Agent → Tool Endpoint: GET /x402/captcha-solve │
│ Header: PAYMENT-SIGNATURE: <proof> │
│ ← Response: 200 OK { solution: "..." } │
└─────────────────────────────────────────────────────┘Four steps. No API key. No monthly plan. No human approving a purchase. The agent discovers, negotiates, pays, and consumes — all programmatically.
minia2a.uk runs an MCP server that exposes 299+ x402-gated tools. In the last hour alone, the /mcp endpoint served 366 requests — more than any other path on the server, including the homepage and the stats API. The /.well-known/agent-card.json discovery endpoint is also getting traffic from agents looking for tool catalogs.
The usage pattern reveals something important: agents using MCP for discovery tend to make more calls. When an agent finds a tool through MCP, it already has the parameter schema, the description, and the endpoint — it doesn't need to read documentation. The path from discovery to first call is one step instead of six.
Across all 299 services, the top MCP-discovered tools are:
| Tool | Why Agents Need It |
|---|---|
| x402-captcha-solve | Agents hit CAPTCHAs on human websites — they need a bridge |
| x402-recall | Agents need persistent memory across sessions |
| x402-find | Agents search for other tools to compose into workflows |
| x402-gas | Agents transact on-chain and need current gas prices |
| x402-web-scrape | Agents need structured data from human-readable websites |
The pattern is clear: agents use MCP to find the tools they need, then x402 to pay for them. The two protocols are more complementary than competitive.
The traditional model for API monetization is an API key + monthly billing. This breaks for agents in three ways:
1. Agents can't sign up. An API key requires a human to register, verify email, and enter payment details. Agents can't do any of those things. MCP + x402 requires zero registration — the agent discovers the tool and pays per call.
2. Monthly plans don't match agent usage. An agent might make 10 calls one day and 10,000 the next. Per-call pricing matches the usage pattern. Monthly plans force agents into tiers that waste money at low volume and throttle at high volume.
3. API keys are bearer tokens with no payment semantics. If an API key leaks, the attacker gets free access until the key is rotated. With x402, every call is settled on-chain — a leaked credential can only spend the wallet balance, and the spending is auditable.
The MCP + x402 stack works today, but it's not yet standardized. Each marketplace runs its own MCP server with its own tool schema. An agent has to know which MCP server to query before it can discover available tools.
What's needed: a discovery standard that lets agents find x402 tools without knowing which marketplace hosts them. Two proposals are in play:
_x402._tcp.domain.com SRV records) — an agent resolves a domain and finds its payment endpoint/.well-known/x402) — an agent requests a standard path and gets back a list of available services with pricesBoth are being discussed in the x402 Foundation's discovery working group. Both are implementable today with zero protocol changes. The question is which one (or both) becomes the standard.
If you're building an API that agents might consume, the integration path is now straightforward:
/.well-known/x402 endpoint — returns your payment terms and available servicesThat's it. Three steps, zero API keys, and you're part of the agent economy.
MCP solved discovery. x402 solved payment. The combination solves the chicken-and-egg problem that's been holding back agent commerce since the first LLM called an API.
The infrastructure is done. The protocols are live. The agents are calling. The only question left is: what are you building that agents will pay for?
minia2a.uk runs the combined MCP + x402 stack in production: 299 services, free trials on every endpoint, USDC settlement on Base. Agents discover tools through MCP and pay through x402 — no human in the loop.