TL;DR (July 2026): The unit of AI billing is changing under your feet. For years the meter was the token, and every cost model in your spreadsheet assumed it. In 2026 the leading coding agents are quietly switching to task and session quotas instead, because agents made token spend impossible to predict. Claude Code rate-limits by rolling 5-hour sessions - not by message count and not by a monthly token pool. Kimi Code meters 300 to 1,200 API calls per 5-hour window. This is not a pricing tweak; it breaks token-based cost tracking at the root. You can no longer forecast a session's token spend, because the thing being rationed is no longer tokens - it is your access to run tasks. When the unit of billing changes from tokens to sessions, your cost model and your meter have to change with it, or your dashboard is measuring a quantity nobody is billing on anymore.
Every finance model for AI spend built between 2023 and 2025 rests on one assumption: cost equals tokens times a per-token price. It is a clean equation, it is how the APIs bill, and it is why "count the tokens" became the whole discipline of AI cost tracking. That equation is now cracking - not because tokens got more expensive, but because the most-used AI products stopped rationing by tokens at all. The shift is easy to miss because the underlying API still prices per token. But the products people actually work in all day have moved the meter somewhere else, and if your tracking has not followed, it is measuring the wrong thing.
Two units of billing, and the switch between them
There are now two fundamentally different ways to ration AI, and they answer different questions.
- Token metering answers "how much text did you process?" It is precise, it is what the raw APIs bill on, and it is predictable per call - a fixed prompt costs a fixed number of tokens every time.
- Task or session quotas answer "how much work did you ask for?" A session is a block of time; a task quota is a count of calls or runs. It is predictable per session - you get five hours, or 1,200 calls - but it deliberately says nothing about the tokens underneath.
The 2026 move among coding agents is from the first to the second. Here is how the leading tools now draw the line, next to what the standard API still does.
| Tool / access | Rationed by | Window | What you can no longer forecast |
|---|---|---|---|
| Claude Code | Sessions (not message count) | Rolling 5 hours | Token spend inside a session |
| Kimi Code | 300 - 1,200 API calls | 5-hour window | Tokens per call, so total tokens per window |
| Standard token API (Anthropic Tier 4) | Tokens per minute (2,000,000 ITPM + 400,000 OTPM) | Rolling minute | Nothing per call - but agent task totals stay unpredictable |
July 2026 access models; the raw APIs underneath still price per token (see morphllm.com/llm-api and tldl.io). The point is that the products people work in all day no longer expose that token meter to the user - they expose a session or call quota instead.
Why providers are abandoning the token meter
This is not providers being coy. Token metering broke for a concrete reason: agents made token spend wildly non-deterministic. In the chat era, one message produced one response, and token cost tracked message count closely enough to forecast. An agent shatters that link. A single instruction can trigger a run that reads a whole codebase, calls a dozen tools, spawns sub-agents, retries failed steps, and reasons across hundreds of thousands of tokens - or it can resolve in one cheap round trip. The same prompt, issued twice, can differ by 100x in token cost depending on what the agent decides to do. When the variance between two identical requests is that large, a per-token price is honest but useless for planning, and a fixed token allowance either starves your heavy days or wastes money on your light ones. Rationing by session or task sidesteps the whole problem: the provider caps how much you can invoke the agent, which they can predict, instead of how many tokens the agent will burn, which nobody can. This is the same unpredictability that drove the upheaval in AI coding usage billing all year; session quotas are the providers' answer to it.
The switch that breaks your forecast
Look closely at the two concrete examples, because the way they break token tracking differs.
Claude Code's 5-hour session. Access is rationed by rolling five-hour sessions rather than by message count or a monthly token bucket. The consequence for cost tracking is direct: a session is a container of unknown token volume. You know you have a session; you do not know whether you will spend 50,000 tokens or 5,000,000 inside it, and the session cap does not care - it caps the clock, not the tokens. Any forecast of the form "we run N sessions a day, each costs X tokens" is now a guess with no stable X. The per-token-versus-per-month cost of Claude Code stopped being one number and became a distribution.
Kimi Code's 300-to-1,200 calls per 5-hour window. This rations the count of API calls, not the tokens in them. That is even further from a token forecast: two users who each burn exactly 1,200 calls in a window can have token totals an order of magnitude apart, because a "call" says nothing about prompt size or reasoning depth. The quota is legible - you can count calls - but it is deliberately decoupled from the token cost underneath, so knowing you used 800 of 1,200 calls tells you almost nothing about what you spent in tokens.
In both cases the thing you can measure (sessions used, calls used) is not the thing your old cost model was built on (tokens). That gap is the break. A token dashboard pointed at a session-quota product is still counting accurately - it is just counting a number that no longer maps to your access, your limit, or your renewal.
What changed in 2026
- Agents became the default interface, not the exception, so the non-determinism that broke token forecasting moved from an edge case to the main case.
- The flagship coding tools led the switch. When Claude Code moves to 5-hour sessions and Kimi Code moves to call-count windows, session and task quotas stop being a niche pricing experiment and become the pattern the rest of the market copies.
- The token price kept falling anyway, which makes the switch easy to overlook. With per-token rates spanning roughly 600x - from DeepSeek V4 Flash at about $0.14/$0.28 per 1M to GPT-5.5 at about $5/$30 - and model choice still swinging a monthly bill by around 10x, the raw token economics are as important as ever. But at the product layer, the number your users are rationed by is no longer the token.
| Model | Input $/1M | Output $/1M |
|---|---|---|
| GPT-5.5 | $5.00 | $30.00 |
| Claude Opus 4.8 | $5.00 | $25.00 |
| Gemini 3.1 Pro | $2.00 | $12.00 |
| GLM-5.2 | $1.40 | $4.40 |
| DeepSeek V4 Flash (cheapest) | $0.14 | $0.28 |
Approximate July 2026 per-1M-token API list prices. The tokens still cost this; the products just stopped billing you by them. Sources: morphllm.com/llm-api, tldl.io.
When the unit changes, your meter has to change too
This is metering's core beat, and it is why the shift matters beyond trivia. A meter is only useful if it measures the unit you are actually rationed and billed on. When that unit moves from tokens to sessions or task-calls, a token-only meter does not just lose precision - it loses relevance, because it can show a healthy token count while you are one session away from being locked out for the rest of a five-hour window. The fix is to meter both layers: the session or task quota that governs your access, and the token cost that still accrues underneath it. You want to answer two questions at once - "how close am I to my session or call cap?" and "what did those sessions actually cost in tokens?" - because the provider now only shows you the first and still charges (or your model provider does) on the second.
Practically, that means your usage events need a unit richer than a token count. Tag each agent run with its session, its task, and its token draw, and roll them up along all three, so a "task" becomes a first-class thing you can price - which is exactly the attribution discipline of tagging every call with its dimensions. The unit your customers care about is drifting toward cost per completed task rather than cost per token, and a meter built around tasks is what lets you quote and bill in the unit that survives the next pricing change. And because a session quota removes the natural brake that a token budget used to provide, you still want a hard cap and kill switch on the token spend underneath - the session cap limits your access, not your bill.
The honest take
Session and task quotas are not inherently better or worse than token metering - they are a different unit, chosen because it is the one providers can actually predict in an agent world. The mistake is not picking a side; it is failing to notice the unit moved. If your cost tracking still assumes cost equals tokens times a price, it is quietly measuring a quantity that Claude Code and Kimi Code have already stopped rationing you by, and the first time that gap bites will be a forecast that is confidently wrong or a team that hits a session wall your dashboard never saw coming. Meter the unit you are actually billed on - and in 2026 that increasingly means sessions and tasks on top of tokens, not instead of watching them, but layered over them. The meter that survives is the one that tracks whichever unit the provider decides to charge you in next.