Coinbase Put Tavily Search on x402. The Pay Rail Shipped; the Discovery Rail Did Not.
Coinbase and Tavily announced this week that Tavily web search is live on x402, the open protocol for pay-per-request agentic payments. The pitch is the one the whole agent ecosystem has been waiting on: an AI agent discovers a service at runtime, pays for it from a Base wallet with no API key and no signup, and gets the result. Tavily is a sensible flagship for it. Its search API is wired into a large share of the agent stacks built in the last two years, so a credible web-search provider going pay-per-call on a public stablecoin rail is a real marker of where this is heading.
I spent twenty minutes with the live service instead of the announcement, because the interesting questions about agentic commerce are not in the press copy. They are in what an autonomous agent actually encounters when it tries to use the thing. Two findings. The payment rail is clean and works exactly as advertised. The discovery rail, the part that is supposed to let an agent find and evaluate the service before it pays, is not there yet. That gap is the story.
The pay rail works, and it is cheap
Send an unpaid request to the search endpoint and you get back a textbook x402 challenge: a 402 status, the canonical payment requirements, the exact scheme, Base mainnet as the network, USDC as the asset, and a per-call price. Advanced search runs $0.01 a request. That is the number worth sitting with. A penny a search, settled in USDC on Base, with the buyer signing an off-chain authorization and no card, no key, no account. For an agent that fires a few hundred searches assembling one answer, that is a few dollars, billed exactly, to the request, with no subscription to amortize and no human in the loop.
This is the part of the agentic-commerce thesis that is now plainly real. The economics that broke against card networks and SaaS seats work here, because the protocol does not carry their fixed costs. A penny-per-call web search is not a demo. It is a price an agent can actually pay at scale, and a credible vendor just put one in production. The payment layer of this market has converged: the 402 envelope, the EIP-3009 signed authorization, the Base settlement. A buyer SDK that handles one x402 endpoint handles this one.
The discovery rail did not ship
Now try to do the other half of the promise, the part where an agent finds the service on its own. This is where it falls down. The conventional places an agent or a crawler looks to discover an x402 service and read its terms before paying are all empty. There is no published payment manifest at the well-known path the ecosystem standardized on. There is no catalog or discovery listing on the service itself. There is no agent card. The service root returns a bare health check that says, in effect, the payment service is up, and nothing about what it sells, what parameters it takes, or what a result looks like.
So the only way an agent learns this endpoint exists, learns its path, its price, and its input shape, is by reading the Tavily announcement or its human documentation. That means a person has to put it in front of the agent. The launch solved how an agent pays. It did not solve how an agent finds. And finding is the harder, less glamorous half. Paying is a settled protocol problem. Discovery is a standards-and-incentives problem, and it is not converging at the same speed.
Why the gap is structural, not a Tavily oversight
This is not a knock on Tavily. They shipped a working pay rail on a tight timeline, which is the hard engineering. The gap belongs to the ecosystem. The x402 effort produced a clean, widely-implemented standard for the payment exchange, the 402 challenge and the signed settlement. It did not produce one equally-adopted standard for discovery. There are at least three competing answers in the wild: the well-known payment manifest, the hosted marketplace catalog, and the agent-card pattern borrowed from the agent-to-agent world. Publishers pick one, or none, or roll their own. A launch can be fully payment-compliant and completely invisible to an autonomous crawler at the same time, which is exactly what happened here.
That matters because the headline vision, the one in every x402 announcement including this one, is agents discovering and paying for services with no human involved. You cannot get there on a payment standard alone. If every service exposes its price and parameters differently, or only in prose a human has to read, then a human stays in the loop wiring each integration, and the autonomy is capped at the discovery step no matter how good the payments are. The pay rail is necessary. It is not sufficient.
Our take
The right read on this launch is bullish on the thesis and impatient with the plumbing. A top-tier search provider pricing autonomous access at a penny a call, settled on-chain with no key, is a genuine signal that pay-per-request is crossing from protocol demos into the services agents actually use. The capital and the credible vendors are arriving. What is lagging is the boring layer that makes the autonomy real: a discovery surface an agent can parse without a human, carrying the price, the parameters, and the terms in a machine-first shape.
Three signposts over the next ninety days. Whether Tavily and the next wave of x402 launches backfill a machine-readable discovery surface, or keep treating discovery as a docs-and-announcement problem. Whether one discovery convention starts to win, the way the payment envelope already did, or the field stays split across manifest, catalog, and agent card. And whether the marketplaces that index these services can keep up with publishers who ship pay rails without discovery rails, because an x402 endpoint that no crawler can find is, to the billion agents the announcements keep invoking, the same as an endpoint that does not exist. The pennies are flowing. The map is the part still being drawn.