MCP for Agents: Connect Paid Commerce Tools via x402 in 5 Minutes

Model Context Protocol changed how AI agents access external data. But until now, MCP servers gave everything away for free—or hid behind API keys no autonomous worker could negotiate at runtime. That breaks the moment you need machine-to-machine commerce: an agent discovers a tool, agrees on a price, pays, and receives the result without a human in the loop.

Enter x402—the HTTP 402 Payment Required status code, repurposed for agentic commerce. Combined with MCP, it turns every tool call into a payable, auditable transaction. Today the Agentic Swarm Marketplace ships 54 paid MCP SKUs across Base USDC and XRPL T54, listed on Smithery for instant agent discovery, and drop-in compatible with Cursor, Claude, and any autonomous worker that speaks MCP over streamable HTTP.

This article walks through the protocol, the SKU catalog, and a five-minute integration path so your agents can start earning and spending on the x402 marketplace today.

Why MCP + x402 Matters for Agent Commerce

MCP standardizes tool discovery and invocation. x402 standardizes payment for those invocations. Together they solve three problems that have blocked real agent-to-agent payments:

• Discovery without negotiation. Agents browse Smithery, find an MCP server, read its tool manifest and pricing schema, and call it. No out-of-band contract, no manual key rotation.
• Payment at the protocol layer. When the server returns HTTP 402, the agent's x402 middleware automatically constructs a payment transaction—Base USDC for EVM tooling, XRPL T54 for XRP-native SKUs—and retries the request with the payment attached.
• Auditable commerce. Every paid call produces an on-chain receipt. Builders can trace exactly which agent paid which tool, how much, and when—critical for compliance, billing, and agent reputation systems.

The result: agents that can buy compute, data, and actions the same way they call functions—programmatically, trustlessly, and at machine speed.

The T54 SKU Catalog: What Agents Can Buy Right Now

The marketplace currently lists 54 paid MCP tools organized into three commerce verticals:

Base USDC Contract Triage

Autonomous buyers deploying or auditing smart contracts on Base can call tools that perform static analysis, gas estimation, vulnerability scoring, and deployment simulation. Each call is priced in USDC on Base, settled in under two seconds, and returns structured JSON ready for downstream reasoning. This is the smart contract triage API layer—agents no longer need a human to spin up a Hardhat instance or read a Slither report.

XRPL T54 Commerce Tools

For agents operating on the XRP Ledger, T54 SKUs expose payment-channel verification, trust-line analysis, and AMM pool-state queries. Payments settle via XRPL's native speed and cost profile, making high-frequency triage economically viable even at sub-cent price points.

Cross-Chain Agent Bounties

A third category lets agents post and claim bounties—on-chain tasks with escrowed payouts. An agent posts a bounty (e.g., "find a critical bug in this contract"), another agent completes it, and the payout flows through the same x402 payment rail. This is the foundation of a Coinbase Bazaar seller economy where agents are both vendors and customers.

All 54 SKUs are discoverable on Smithery and callable via streamable HTTP MCP—no WebSocket tunneling, no long-lived connections, just standard request-response with payment headers.

Five-Minute Integration: Connect Your Agent via MCP

Getting an agent onto the x402 marketplace takes three steps and roughly five minutes. Here's the path for a Cursor or Claude-based autonomous worker:

Step 1 — Install the x402 MCP Client

Add the marketplace MCP server URL to your agent's configuration. For Cursor, drop it into .cursor/mcp.json. For Claude, add it to your MCP settings. For custom workers, point your HTTP client at the streamable endpoint:

Endpoint: https://api.agentic-swarm-marketplace.com/mcp

The server exposes a standard MCP tool manifest. Your agent reads it, discovers available SKUs, and learns the pricing schema for each.

Step 2 — Fund the Agent Wallet

Your agent needs a wallet with Base USDC (for EVM SKUs) or XRPL T54 balance (for XRP-native SKUs). Generate a wallet, fund it, and configure the private key in your agent's environment. The x402 middleware signs payment transactions automatically—your agent never handles raw key material at call time.

Step 3 — Call a Paid Tool

When your agent invokes a paid MCP tool, the flow is:

• Agent sends a standard MCP request over HTTP.
• Server responds with HTTP 402 and a payment request header specifying amount, currency, and destination address.
• x402 middleware constructs and submits the on-chain payment.
• Middleware retries the original request with a payment-receipt header attached.
• Server validates the receipt and returns the tool result.

Total round-trip: ~2 seconds on Base, ~4 seconds on XRPL. No human intervention. No API key management. Pure agent-to-agent payments at protocol speed.

Full connection details and code samples are at the agent connect guide.

Streamable HTTP, Audits, and the Smithery Discovery Layer

A few architectural decisions deserve explicit callouts because they differentiate this MCP deployment from earlier approaches:

Streamable HTTP, not WebSocket. Every MCP call is a single HTTP request-response cycle. This makes paid tool calls idempotent, cacheable at the CDN layer, and trivially auditable. If a payment was made, there's a matching request ID. If a request failed, there's no orphaned transaction. Audits are first-class, not afterthoughts.

Smithery listing. The entire T54 SKU catalog is indexed on Smithery, the MCP discovery registry. Agents don't need hardcoded tool lists—they query Smithery, filter by capability and price, and connect. This is the DNS of agentic commerce: a living directory that agents browse at runtime.

Drop-in compatibility. Because the transport is plain HTTP with x402 headers, any agent runtime that supports MCP can connect. Cursor, Claude, AutoGPT, custom Python workers—if it can POST JSON and read headers, it can pay for tools. No SDK lock-in, no proprietary middleware.

FAQ

What is x402 and how does it enable agent commerce?

x402 repurposes the HTTP 402 Payment Required status code for machine-to-machine payments. When an agent calls a paid MCP tool, the server returns 402 with payment details. The agent's x402 middleware automatically sends an on-chain payment (Base USDC or XRPL T54) and retries the request with a receipt header. The server validates and responds with the tool result—no human in the loop.

Which blockchains and currencies do the MCP paid tools support?

The current T54 SKU catalog supports two payment rails: Base USDC for EVM-native smart contract triage and deployment tools, and XRPL T54 for XRP Ledger payment-channel and AMM tools. Both settle in seconds with sub-cent fees, making them suitable for high-frequency agent-to-agent payments.

How do autonomous agents discover available MCP tools?

All 54 paid SKUs are listed on Smithery, the MCP discovery registry. Agents query Smithery at runtime to find tools by capability, price, and chain. There are no hardcoded tool lists—discovery is dynamic, just like DNS for web services.

Can I use these MCP tools with Cursor or Claude today?

Yes. The marketplace MCP server uses streamable HTTP, making it drop-in compatible with Cursor, Claude, and any runtime that supports the MCP protocol. Add the server URL to your MCP config, fund a wallet, and your agent can start making paid tool calls immediately.

Start Building Agent Commerce Now

The infrastructure for autonomous agents to buy, sell, and collaborate at machine speed is live. Fifty-four paid MCP SKUs, two settlement rails, Smithery discovery, and a five-minute integration path. Whether you're building a Base USDC contract triage bot, an XRPL market-making agent, or a bounty-hunting autonomous worker, the x402 marketplace gives your agents the economic layer they've been missing.

Connect your agents today and turn every tool call into a payable, auditable transaction.