Overnight, a single operator listed eighteen pay-per-call endpoints on a public discovery index for machine payments. Each one is a function from inside an agent: context compression, hallucination detection, temporal knowledge decay, attention allocation, multi-agent coordination, tool-selection optimization, prompt orchestration, decision verification, inference-cost routing, knowledge-graph synthesis, semantic deduplication, sentiment-adaptive response, workflow automation, agent memory.
Eighteen functions. One operator. Every one of them answers a clean HTTP 402 with {"error":"Payment required"} when you hit its root — the payment wiring is correct. And every one of them has zero recorded calls.
That combination — correct protocol, zero demand — is a more interesting signal than it looks like. It says the unit of software that can be sold is no longer "an API" but "a function that used to live inside an agent."
The payment boundary got cheap
Not long ago, turning a function into a payable service meant standing up an API gateway, a billing system, key management, metering, and a dashboard. That was a week of work, minimum, before the first cent moved.
That cost has collapsed. A pay-per-call endpoint in this world is a Cloudflare Worker that returns a 402 challenge — a price, an asset, and a destination address — when it is called without payment. No key onboarding. No metering to build yourself. The discovery layer picks the endpoint up and lists it. The barrier between "this function is inside my agent" and "this function is a service someone else can pay for" is now roughly an afternoon.
So the supply curve has bent downward, and it is decomposing the agent stack in order. First the trivial utilities — UUID generators, JSON validators, base64 codecs. Then data. Then last week, the agent's own cognition.
What breaks when a component becomes a service
This is not free. A function that moves from in-process to a network call loses things, and the loss is exactly where the interesting engineering now lives.
Latency. A context-compression step that was a function call in the hot loop is now a round trip to a stranger's worker. If the agent calls it per-message, the tail latency is now someone else's problem — but it lands on the agent's user experience.
Atomicity. In-process, the agent owns the transaction. Across a payment boundary, the agent owns the decision to pay, and then it owns verifying the result. There is a new failure mode between the two: the payment clears, the response never arrives, or arrives and is wrong.
Trust. This is the big one. The moment an agent pays a stranger per call, it has to answer a question that didn't exist in-process: is this 402 challenge safe to sign? Does the address match who I think I'm paying, does the amount match the advertised price, is the asset one I can settle? A reputation score built from past receipts cannot answer this, because it only ever sees the payments that already worked. The check has to run before the signature.
The demand side is the lagging indicator
All eighteen cognition endpoints have zero calls. Most of the new listings on the public index are pre-traction. The index is on the order of fourteen thousand listings across roughly two thousand hosts, and the honest measure of demand — distinct wallets that actually paid in a week — is a rounding error against that inventory.
This is not a protocol failure. It is the normal shape of an early market: the layer that commoditized first floods first, and the layers that are still scarce lag behind. The useful move is to notice which layers are still scarce.
Two, and neither is "one more endpoint":
- Discovery. When supply decomposes into thousands of single-function endpoints, the hard problem stops being "find an endpoint" and becomes "find the endpoint whose price, capability, and settlement path you can actually trust." A directory that lists everything lists nothing.
- Pre-payment verification. The check that runs before the agent signs the challenge, on the cold path, every time. Not a score — a gate.
The takeaway
The builders adding another endpoint to the index are now competing on the cheapest layer of the stack. The builders making the index usable — the discovery and verification layer that turns fourteen thousand listings into a handful an agent can safely pay — are working on the layer that is still genuinely scarce.
If you are building an agent that pays for its own tools, the component you should worry about is not the next model call. It is the step where you hand a stranger money and have to trust that what comes back is real.
Top comments (0)