Cloudflare just made it trivial to charge an agent for anything. That solves the seller's problem. It creates yours.

Last week Cloudflare opened the waitlist for its Monetization Gateway: a way to put a price on any page, API, dataset, or MCP tool and collect payment from whoever calls it. No billing stack, no signup flow, no prior relationship with the buyer. Write a rule, name a price, get paid per request.

If you sell an API, this is great news. The hard part of usage-based billing (metering, collecting, settling sub-cent amounts from strangers) moves off your origin and becomes someone else's problem.

If you operate agents, read that last sentence again. You are the stranger. You are the buyer being charged per call, across every endpoint your agent touches, whether or not you were ready for it.

The transaction has two sides

Every metered API call is a transaction. Transactions have two sides.

The sell-side is the vendor deciding what to charge and collecting it. That's the Cloudflare piece, and increasingly it's a solved problem. The tooling is arriving fast and it's good.

The buy-side is your agent, spending your money, in a loop you didn't write, across five vendors who each bill you separately. It's the side you're on.

Here's what the buy-side actually looks like for a voice agent doing one outbound call:

• Speech-to-text meters by the second

• The LLM meters by the token, and retries cost tokens too

• Text-to-speech meters by the character

• Telephony meters by the minute

• A search or enrichment call meters by the request

Five meters, five vendors, five bills, one call. Multiply by a few thousand concurrent calls. Now imagine a prompt regression that sends every agent into a retry loop over a weekend. In the old world, that burned prepaid credits and your agents eventually went dark. In the metered world Cloudflare is accelerating, that same loop is spending settled dollars in real time, per call, with nothing standing between the runaway agent and your balance.

The sell-side got a gateway. The buy-side got a bigger blast radius.

Why your existing tools don't cover this

The instinct is: "I already have a way to see my LLM spend." You do… for your LLM spend. A token router like OpenRouter shows you exactly what you spent on models. It shows you nothing about the STT, the TTS, the telephony minutes, or the enrichment call, because those never went through it.

That's the trap. The one vendor you can see clearly is the one you were already watching. The bill that actually surprises you is the sum across vendors you were watching separately ie the number no single tool in your stack holds. Your economic record is real, but it's fragmented across five dashboards and locked inside each vendor's platform. Nobody holds it as one object. Which means nobody can bound it, and nobody can act on it before the money's gone.

Cloudflare's own post is honest about this from the seller's vantage point ie they can see the calls hitting their gateway. What they can't see, and aren't trying to, is the operator standing behind an agent that's calling forty different priced endpoints. That's a different job. That's the buy-side.

What the buy-side needs

Three things, in order. None of them are exotic. All of them have to happen before money moves, because after the money moves you're just reading a receipt.

One key across every vendor. Not one dashboard that aggregates five accounts after the fact — one integration point that every paid call routes through, so there's a single place where spend is visible and a single place where it can be stopped. If control lives in five vendor consoles, you have no control; you have five obituaries.

Budgets enforced at the transaction, not the invoice. A per-agent, per-task, per-vendor limit that gets checked when the call is about to be paid for — and blocks it if it's over. This is the whole game. A budget you discover you blew is an accounting entry. A budget that stops the call is a control. The runaway retry loop over the weekend doesn't end when someone notices Monday morning; it never starts, because agent #47 hit its task budget on attempt three and got shut off.

A cost signal the agent can actually read. When the agent knows mid-task that it's near its limit, it can behave differently — finish the current job instead of starting three more, or stop and hand off. Awareness isn't the same as automatic optimization, and we're careful about that line: today Floe surfaces the budget signal to the agent and enforces the ceiling. The agent decides what to do with the room it has left. That's real, it ships today, and it's already enough to turn "found out Monday" into "handled Friday night."

Where Floe sits

Floe is the buy-side layer. One key across your voice-agent vendor stack (STT, TTS, LLM, telephony, search) settled through a single integration, with the cost of every call visible in real time. Per-agent, per-task, and per-vendor budgets enforced before the payment clears. A hard stop when an agent runs away. Walletless onboarding, so a developer who has never touched stablecoins can sign up with an email and set a spending limit in the same sitting.

We are not the gateway charging your agent. We're the reason you can let your agent loose on a world full of gateways without it emptying your account by Sunday.

The sellers are getting their tooling. This is ours, and yours.

Floe gives voice-agent operators one key for multi-vendor billing and spend control, with per-agent budgets enforced before money moves. Start free, no card. Reference build and the open-source floe-guard budget guardrail on GitHub.