Loomal

The agent economy: how MCP and x402 work together

MCP gives agents hands; x402 gives them a wallet. Neither protocol alone produces an economy — together they close the loop from discovery to invocation to payment.

An economy needs two things: a way to find and use what's for sale, and a way to pay for it. For AI agents, those two things arrived as separate protocols. The Model Context Protocol standardized how an agent discovers a service's tools and calls them; x402 standardized how an HTTP service demands and receives payment from a machine.

Each is incomplete without the other. This guide walks through what each protocol contributes, why the combination is more than the sum, and what the closed loop looks like in practice.

What MCP solved — and what it left open

Before MCP, connecting a model to an external capability meant a bespoke integration per pair: this agent framework to that API, again and again. MCP replaced that with a universal socket — a server describes its tools in a standard schema, any compliant client can list and call them, and transports cover both local processes (stdio) and remote services (Streamable HTTP).

What MCP deliberately doesn't address is money. The protocol assumes access is either free or sorted out-of-band with keys and OAuth. That works for a developer wiring up their own tools; it fails for an open market, because the people running good servers have hosting bills and upstream costs, and 'free forever, maintained by goodwill' is not infrastructure.

What x402 solved — and what it left open

x402 made HTTP itself payable. A service responds 402 Payment Required with a machine-readable price; the caller pays in USDC, settlement clears on Base in about two seconds, and the retried request executes. No account, no invoice, no card form — and the $0.01 minimum makes single-call purchases economically sane, where card rails would drown them in fees.

What x402 alone lacks is a storefront. A payable endpoint is just a URL; nothing in the protocol tells an agent that the endpoint exists, what it does, or whether the price is competitive. Payment rails without discovery is a shop with no street.

The closed loop

Put them together and a complete transaction becomes possible with no human in it. An agent queries an index for a capability — say, parsing a filing or geocoding an address. It gets back an MCP server's URL, tool schemas, and per-call price. It connects, calls the tool, receives the 402, pays from its wallet, and the payment settles before the handler runs. The result comes back with an Ed25519-signed receipt; the agent's operator gets a verifiable record of what was bought and for how much.

Notice the division of labor: MCP carries the what (tools, schemas, invocation), x402 carries the how much (price, payment, settlement). Neither protocol had to grow features outside its lane.

Why the payment properties matter at machine speed

Agents transact at a frequency and anonymity that human billing infrastructure was never built for. Per-call USDC payment means no credit relationship needs to exist before the first call. Two-second settlement means the purchase fits inside an agent's working loop. No chargebacks means a seller can serve ten thousand anonymous callers without fraud-ops headcount. And signed receipts mean the whole history is auditable after the fact — which is what lets operators give agents budgets and trust the accounting.

Where Loomal sits in this stack

Loomal is the index layer: a machine-queryable catalog where every listed MCP server and API endpoint carries its price and payment endpoint alongside its tool list, so the discovery step and the payment step use the same record. For builders, that's the practical on-ramp to the agent economy — list a server, set a per-call price from $0.01, and the fee is 5% on settled transactions, currently waived.

If you're starting today: build or claim your MCP server, gate the expensive tools with x402, and list it. The loop described above then runs without you in it — which is the point.

FAQ

Are MCP and x402 competing standards?

No — they don't even cover the same layer. MCP standardizes tool discovery and invocation; x402 standardizes payment over HTTP. A server can implement either without the other, but the agent economy use case needs both: something to call and a way to pay for the call.

Does using x402 mean my MCP server stops working with normal clients?

No. Discovery and free tools keep working for every client. Paid tools return a 402 that x402-capable clients handle automatically; clients without payment support simply can't invoke those specific tools, the same way a client without an OAuth token can't invoke OAuth-protected ones.

Why USDC on Base rather than card payments?

Granularity and autonomy. Card rails carry fixed fees that make a $0.01 transaction absurd, require a billing identity agents don't have, and allow chargebacks that don't fit machine-to-machine commerce. Stablecoin settlement on an L2 gets per-call payments down to cents, cleared in seconds, final on arrival.

Is anyone actually paying this way yet?

The protocols are live and the tooling exists end to end — wallets for agents, facilitators for verification, indexes with priced listings. As of mid-2026 volumes are early-stage, which cuts both ways: the rails work today, and sellers who list now are positioned ahead of the call volume rather than behind it.

See the loop running.

Browse the index where every listing is discoverable and payable.

Explore the Loomal Index