Every post in this series has led to one question, and it's a pricing question disguised as a technical one: once agents can call your API, what is a call worth? Because the answer changes when the caller is a tireless agent instead of a human. A human makes a handful of considered requests. An agent can make thousands in a loop, on your behalf, without a coffee break. The unit of value quietly shifts from the seat to the tool call — and that's a monetization decision you get to make on purpose or have made for you.
The tool call becomes the unit
Usage-based pricing isn't new, but agents make it the natural default rather than an exotic option. The industry has been drifting this way for years — a widely cited OpenView survey found usage-based pricing adoption climbing sharply among software companies, because it aligns what customers pay with the value they draw. [1] Agents accelerate that drift, because "value drawn" is now something concrete and countable: the tool call. You can meter it, you can tier it, and you can put a number next to it.
The two honest shapes are familiar. Per-call — pay for what the agent invokes, with the meter running — fits spiky, unpredictable agent traffic and lets a customer start at near-zero. Subscription with quotas — a tier that includes N calls a month, overage beyond — gives you predictable revenue and gives them a predictable bill. Most mature offerings end up with both: a subscription floor for commitment, per-call metering above it for value capture. The right split depends on how bursty your callers are, not on a rule.
A human buys a seat once and forgets it. An agent generates a thousand billable moments an hour — if, and only if, you built the meter before you built the loop.
Don't bet the company on day one — roll it out in three moves
The mistake is treating monetization as a single public launch. It isn't. The safe, high-learning path is a staged rollout where the same MCP surface changes audience, and only the keys and tiers change with it.
Internal first. Stand up the server for your own agents and teams. No pricing, just usage. You learn which tools actually get called, where the rate limits need to sit, and which descriptions the agents misread — the disambiguation lessons from post two, now with real telemetry. Internal keys, full visibility, zero revenue risk.
Enterprise next. Issue scoped keys to a handful of trusted customers or partners under a negotiated tier. This is where you validate that agent access is worth paying for, against a small, forgiving audience, before you expose it to the world. Enterprise keys carry their own limits and their own price, and you get real willingness-to-pay signal without a public commitment.
Public last. Once the tools, tiers and meter have survived internal and enterprise use, open a public tier with self-serve keys and published pricing. By now the descriptions are battle-tested, the limits are calibrated, and the billing has processed real invoices. Public launch is the graduation, not the experiment.
What the layer has to do so you don't have to
Every stage above needs the same machinery: keys segmented by audience (internal, enterprise, public), rate limits per key, tiers with quotas and overage, a meter that counts every tool call, and agent-readable descriptions so the calls you're metering actually happen. Build that yourself and you're back in post three, operating a gateway. This is precisely the seam Make Me An MCP is built for: you register a platform, bundle endpoints into task-shaped tool groups, set tiers and rate limits, get the "yellow pages" auto-drafted from your endpoint signatures, and issue internal, enterprise and public keys against the same surface — so the internal → enterprise → public rollout is a settings change, not three rebuilds.
The decision, finally
You started this series unaware that agents had become a buyer, and you're ending it deciding what to charge them. That's the whole arc: agents are calling, the tool call is the unit, and monetizing it well is a staged rollout, not a leap. Whichever path from the last post you chose, the concrete next step is the same and it's small — register a platform, wrap your first few endpoints as tools, and turn the meter on for your own agents. Internal traffic, no risk, real data. The public tier can wait until the internal one has taught you what it's worth. The one thing that can't wait is having a seat at the table at all — and now you know exactly how to take it.