Agentic Billing

What It Is

Agentic billing is the metered, usage-based pricing model that applies when an AI system operates as an agent: taking actions, calling tools, iterating through loops, and maintaining context across multiple turns in pursuit of a goal. Cost is not a fixed monthly fee. It is a direct function of tokens consumed, and in agentic workflows, token consumption compounds in ways that flat-rate subscribers have no prior experience with.

The simplest version of the distinction: a $29/month GitHub Copilot seat was a predictable line item. A GitHub Copilot agent running autonomously on a multi-file refactor over 48 hours is a metered workload. The first is a subscription. The second is infrastructure spend. June 30, 2026 closed the first complete billing cycle since GitHub moved Copilot to usage-based pricing on June 1, and developers received invoices that confirmed what the math always implied: agentic billing is a different category of cost.

How It Actually Works

Every turn through an agent loop is a metered event. At each step, the model receives: the full contents of the context window up to that point, any retrieved documents or tool outputs appended to context, the current task state, and any instructions from the system prompt. The model processes all of it, produces a response or tool call, and the result is appended to context before the next turn begins. Every token processed on input and every token generated on output counts toward the bill.

Tool calls add cost in two directions. The call itself consumes tokens to describe what tool to invoke and with what parameters. The output returned by the tool is then added to context for the next turn, consuming additional input tokens. A tool that returns a 2,000-token document excerpt adds 2,000 tokens to every subsequent turn’s input cost for as long as that document stays in context. In a long-running agent session, the context window often grows toward its maximum, which means input token costs per turn escalate as the session runs.

Prompt caching and token budgets are the primary mitigation tools. Caching allows repeated context, such as a large codebase, a reference document, or a long system prompt, to be stored and reused without re-processing on every turn, cutting input costs significantly for stable context. Token budgets allow operators to set a hard ceiling on how many tokens an agent can consume before it is required to stop and check in. Neither is enabled by default in most developer environments. Both require deliberate configuration.

The Cost and the Tradeoff

Traditional SaaS pricing is legible: a seat costs what it costs, a user is a user, and finance can model headcount against spend. Agentic billing introduces a variable that did not exist before: task complexity. The same nominal workflow, run on a more complex codebase with longer files, deeper dependency chains, and more tool calls required, costs more. Not by a rounding-error margin: by an order of magnitude.

This is not a billing anomaly. It is structurally correct. The model is doing more work. The compute is real. The issue is that operators adopted agentic coding tools under a pricing model that did not surface the compute cost, and are now being shown the real number. The transition from subscription to metered billing is not a bait-and-switch. It is the pricing model catching up to the actual workload. The operators who experience it as a shock are the ones who did not run the math before the invoice arrived.

The secondary tradeoff is predictability. Capital expenditure is plannable. Metered API consumption tied to the behavior of autonomous agents is harder to forecast, because agent behavior is not fully deterministic. A task that took 30 turns last week might take 80 turns this week if the codebase changed or the task was stated less precisely. Operators who built on subscription models had no reason to develop cost-estimation disciplines for AI workflows. They need them now.

A Concrete Operator Scenario

A developer at a 10-person startup sets up a GitHub Copilot agent to handle automated code review across their main repository. In the first week, the repo is small and the agent runs clean 15-turn loops: read the PR, check for obvious issues, post a comment. Cost per run is negligible. The team is happy.

In week two, they add a background agent to handle dependency-update PRs: read the diff, retrieve relevant documentation, check compatibility across the dependency tree, propose a fix. The agent runs continuously on a backlog of 40 open dependency PRs. Each loop turn now loads a 50,000-token context window of current code, diffs, retrieved docs, and prior reasoning. It runs 60 to 80 turns per PR and calls three tools per turn. Forty PRs times 70 turns times 50,000 tokens per turn is 140 million input tokens, plus output. At standard token pricing, that run costs several hundred dollars.

The developer does not see the total until the invoice arrives. The line reads $750. They were expecting $29. Nothing broke. The agent did what it was asked. The cost is correct. The problem is that no one set a token budget before the agent started, no one defined a maximum loop depth, and no one estimated the run cost against the pricing sheet before approving the workflow.

How TWO Uses It

Scott’s Take: Agentic billing is an infrastructure cost masquerading as a software subscription, and operators who treat it like the latter will be surprised every billing cycle until they treat it like the former.

At TWO, any agent loop running for more than a few turns gets a token budget set before it starts. The discipline is the same one you apply to a cloud compute instance: estimate the workload, set a ceiling, monitor the burn rate, and do not let autonomous processes run unattended against metered resources. The math is not hard. The habit is the work.

For operators building on any usage-based AI platform: read the pricing sheet before you run the workflow, not after. Set token budgets as a default, not an afterthought. Treat the first run of any new agentic workflow as a cost-calibration exercise, not a production deployment. And wherever prompt caching is available, use it, especially for stable system prompts and reference documents that would otherwise be re-processed on every turn.

The developers receiving four-figure invoices after expecting two-figure subscriptions are not victims of a bad pricing model. They are learning the same lesson that every operator learned when cloud compute became metered: you are now responsible for understanding what your workloads cost before they run.