Dora NodaIn February 2026, five Chinese cloud platforms launched nearly identical products in the same week. Alibaba, Baidu, ByteDance, MiniMax, and Kimi all called them "coding plans," and the name stuck as the category term across Asia's developer ecosystem. Alibaba's opening bid set the tone: a Lite plan at $3 promotional pricing and a Pro tier at $50 a month for 90,000 requests, usable inside Claude Code or Cline without changing a line of config. Western per-token pricing had just been undercut by 85 to 95 percent, and the undercut arrived as a subscription any developer could buy, not an API price sheet only procurement reads.
Seven months later the collapse completed from the other direction. In September 2026, OpenAI and Anthropic released cheaper coding models within roughly 90 minutes of each other. Anthropic's Opus 5.5 listed at $4 per million input tokens and $20 per million output, cut cache-read prices 60 percent from $0.50 to $0.20, and claimed 40 percent cheaper running cost per finished task — scoring 52.5 percent on CursorBench against GPT-5.6 Sol's 41.7 percent at about one-third the cost per task. Between those two bookends, the whole category repriced: Anthropic's April attempt to fence Claude Code behind a $100 plan collapsed within hours under developer backlash, and June brought a coordinated flip to usage billing — Cursor Teams moved to split usage pools with a $96 Premium seat, Cursor's Bugbot went from $40 per seat to $1 to $1.50 per run, GitHub made Copilot usage-based, and Anthropic pulled its Agent SDK out of flat subscriptions entirely.
The seat is dead. What replaced it is the accepted change — and that changes what a deploy platform must meter. Here is the model up front; the rest of this post earns each row:
| Tool call class | Meter as | Why |
|---|---|---|
| Reads (logs, status, file fetch) | Cheap or free, rate-limited by volume | Agents read 10–50x what they write; taxing reads punishes grounding |
| Preview builds and test runs | Metered compute, billed per run | This is the sandbox loop; the tenant sees it as CI minutes |
| Deploy and rollback | Priced per accepted outcome | Retries fold into the change's cost, not billed per attempt |
| Runaway-loop guard | Outcome budget, not call budget | Cap spend per change, so the fifth retry fails safe instead of billing |
The accepted change is the new unit
The market's new framing has a formula. Cost per accepted change equals the total cost of the attempt — model usage, tool and infrastructure cost, human review time, and rework — divided by the number of changes a reviewer actually accepts. The numerator must include failed attempts: if five cheap tries produce one accepted change, the four failures are part of that change's cost. The denominator must reflect actual acceptance, not a fluent final message from the agent.
This denominator beats cost per token because per-token pricing now routinely lies about task cost. Cursor's own Composer 2.5 matched Claude Opus 4.7 on coding benchmarks in May 2026 at one-tenth the cost — a model win measured in tokens that says nothing about which model finishes a real task in fewer attempts. A cheaper-per-token model that writes long outputs, retries often, fires extra tool calls, and creates review churn can cost more per landed change than a dearer model that finishes smaller and correctly. Anthropic's Opus 5.5 launch made the same point from the vendor side: the headline was not the token cut but the 40 percent saving per finished task, because the model uses fewer tokens to get there.
For a deploy platform, the shift matters because the thing generating billable activity is no longer a human clicking a dashboard. It is an agent loop: read the repo, spin up a sandbox, run tests, fail, retry, deploy, watch, roll back. Every step of that loop touches platform infrastructure — container sandboxes, build minutes, log egress, deploy pipelines — and bills like a compute job, not a subscription. Claude Code alone was doing $2.5 billion in annualized revenue across more than 300,000 business customers by early 2026. That is a lot of loops, each one spending someone's infrastructure budget one tool call at a time.
One deploy, three bills
Take a single agent-driven change — a dependency bump the agent proposes, tests, and ships — and price the platform side three ways. The numbers below are a worked model, not any vendor's price list, but the shape holds wherever agents drive deploys: retries dominate the bill, and the deploy itself is the cheapest line.
| Step | Clean run | Typical retries | Retry-heavy + rollback |
|---|---|---|---|
| Repo reads + log fetches | 40 calls, $0.00 | 120 calls, $0.00 | 300 calls, $0.00 |
| Sandbox + test runs | 1 run, $0.06 | 3 runs, $0.18 | 7 runs, $0.42 |
| Preview builds | 1 build, $0.12 | 2 builds, $0.24 | 4 builds, $0.48 |
| Deploy attempts | 1, $0.05 | 2, $0.10 | 3 + 1 rollback, $0.20 |
| Platform total | $0.23 | $0.52 | $1.10 |
The clean run costs less than a quarter. The retry-heavy run costs nearly five times as much — and the multiplier lives entirely in steps the agent chose, not the human. This is the sensitivity that matters: attempt count is the variable that drives the result, and any metering model that bills per call without an outcome frame will either overcharge the careful agent or undercharge the loopy one. Note also what the model prices at zero: reads. An agent that grounds itself in logs and file contents before acting is cheaper for everyone than one that deploys blind, and the price signal should say so.
The precedents are already live
Nobody has to invent this metering from scratch. Three live precedents already price agent-driven work at the tool boundary:
| Precedent | What it meters | Shape |
|---|---|---|
| Cloudflare Monetization Gateway (closed beta since September 30, 2026) | Per-request pricing for APIs, MCP tools, datasets, and sites via HTTP 402 and the x402 payment protocol | Agents discover the price and pay inside the request flow, no subscription |
| Salesforce Flex Credits | Every successful MCP or direct API call by a registered agent, metered as a headless platform interaction | Per-call credits with 30 days' notice before metering begins |
| Cursor Bugbot (June 2026) | PR review runs at $1 to $1.50 each | Seat replaced by per-outcome run price at renewal |
The pattern is consistent: meter at the boundary where the agent calls the tool, price the outcome rather than the chair, and make the unit legible enough that the agent's operator can budget for it. Cloudflare's version is the most agent-native — the price is discoverable in-band, so the agent itself can decide whether the call is worth it.
The full metering model
For a self-hosted deploy platform exposing MCP-driven deploy and rollback tools, the model has four rules.
Meter at the tool boundary. The cleanest place to count usage is where the agent calls the tool: a gateway or wrapper that turns every invocation into a ledger event with an idempotency check, a policy classification, and a quota counter. Metering anywhere else — inside the model provider's bill, in post-hoc log scrapes — loses the one attribution that matters: which change this call belonged to.
Price reads differently from mutates. Reads are grounding; mutates are commitment. Keep status checks, log fetches, and file reads cheap or free under a generous volume cap, and put the real price on sandbox runs, preview builds, deploys, and rollbacks. The platform's cost structure agrees: a log fetch is egress pennies, while a build is reserved compute minutes.
Charge retries to the change, not the call. This is the per-accepted-change rule applied to infrastructure. The deploy that lands on the third attempt costs the platform three deploys' worth of compute, but the tenant's bill should show one accepted change with its retry cost folded in — visible, itemized, and attributable. Per-attempt billing without an outcome frame reads as punishment; per-change billing with visible retries reads as a receipt, and it gives the operator the lever that matters: which agent configurations retry least.
Rate-limit by outcome budget, not call budget. A call-count limit stops the agent mid-change — the worst possible place, with a half-deployed system and a billed-but-useless attempt trail. An outcome budget ("this change may spend up to X of platform compute before it needs approval") lets the agent allocate across reads, runs, and retries however grounds best, and fails safe at the boundary: the fifth retry never starts, the rollback path stays funded, and the human gets asked before the loop spends real money. Under the three scenarios above, a \1.00 outcome budget auto-approves the clean and typical runs and pauses the retry-heavy one for review — exactly the triage a platform team would do by hand.
Monday morning
Three things a self-hosted platform operator can do this week. First, add a usage ledger at the MCP tool boundary that records every deploy-tool invocation against its change ID — no prices yet, just attribution, because you cannot meter what you cannot attribute. Second, publish a per-outcome price sketch using the four-row table above as the starting shape, with your own compute costs filled in, so agent operators can budget before they automate. Third, replace any per-call rate limit on mutating deploy tools with an outcome budget that fails safe, keeping the rollback path outside the cap so a spent budget can never strand a bad deploy.
The seat died because the agent does not sit in it. It loops, retries, and spends compute like a batch job with opinions — and the platforms that meter the accepted change instead of the chair will be the ones whose bills agent operators can read, budget, and keep paying.
Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Agent-driven deploys metered per outcome, not per seat, are exactly the shape self-hosted infrastructure does best. Star the repo on GitHub or deploy your first app today.
