Cost Governance & Token Budgeting for Claude, Explained

Model cost per request, before you ship

You cannot govern a cost you have not modeled. Before a feature ships, estimate its per-request cost: input tokens times the model's input price, plus output tokens times the output price, multiplied by expected request volume. Prices differ by roughly an order of magnitude across the model tiers, so the model you pick is the dominant term. Count tokens against the actual model you will use rather than guessing — a token estimator built for another vendor will be wrong for Claude.

Model routing: an expensive orchestrator over cheap workers

The single most effective pattern is to stop running your most expensive model on every step. Reserve the top-tier model for the work that genuinely needs it — planning, hard reasoning, coordinating an agent loop — and route the mechanical subtasks to cheaper models. An Opus-class orchestrator that delegates extraction, classification, and summarization to Haiku- or Sonnet-class workers can cut spend dramatically while keeping quality where it matters.

• Right-size per subtask: classification and extraction rarely need the top model; give them the fast tier.
• Orchestrator plus workers: the expensive model decides and delegates; cheap models do the bulk token work.
• Escalate, don't default: start requests on a cheaper model and escalate to a stronger one only when a check fails.
• Match effort to difficulty: for models with an effort control, run routine work at low or medium effort and reserve high effort for hard tasks.

Prompt caching economics

When many requests share a large chunk of context — a system prompt, a document, a tool list — prompt caching lets you pay to process that prefix once and then read it back cheaply on later requests. A cache read costs roughly a tenth of full-price input; a cache write costs a bit more than full price. The catch is that caching is a strict prefix match: any byte change anywhere in the prefix invalidates everything after it, so stable content must come first and volatile content last.

• Order matters: put the frozen system prompt and deterministic tool list first, and the per-request question after the last cache breakpoint.
• Break-even is fast: at the default short TTL a cache write plus one read is already cheaper than two uncached requests, so caching pays off after about two hits.
• Silent invalidators kill it: a timestamp, a UUID, an unsorted JSON dump, or a per-user id in the prefix means nothing ever caches — verify with the cache-read token count.
• There is a minimum prefix size: prefixes below the model's threshold silently do not cache, with no error.

Message Batches for work that can wait

For any workload where no human is waiting on the answer — evaluations, bulk classification, dataset labeling, offline generation — the Message Batches API processes large sets of requests asynchronously at roughly 50% of standard token cost. Most batches finish within an hour and the maximum is 24 hours. It supports the full Messages API feature set, including tool definitions, vision, and prompt caching, so the batch discount stacks with cache savings on a shared prefix.

• About 50% off standard input and output pricing on every request in the batch.
• Results usually within an hour, always within 24 hours — never put a user's live request on this path.
• Full feature support: tools, vision, structured outputs, and multi-turn histories all work in a batch request.
• Stacks with caching: a large shared prefix cached across batch requests compounds the discount.

The cost trap: subagent prompt caching is off by default

Multi-agent and subagent setups are where caching quietly stops working. Prompt caching for subagents is commonly off by default — each subagent spins up its own model calls, and unless caching is explicitly configured on those calls, every subagent pays full price to re-process context the parent already cached. Because subagents fan out, the cost multiplies silently: you see the aggregate bill, not the missed cache reads on each child.

• Assume subagent calls are uncached until you have verified otherwise with cache-read token counts on those calls.
• A fork or subagent must reuse the parent's exact system prompt, tools, and model to hit the parent's cache — any difference misses it entirely.
• Switching models mid-flow invalidates the cache, because caches are model-scoped; keep the main loop on one model and delegate to a subagent for cheaper work.
• Adding or reordering tools mid-conversation also busts the cache; keep the tool set stable, or use tool search which appends rather than swaps.

Token budgeting

Unbounded requests are unbounded costs. Token budgeting caps how many tokens a request or an agent loop is allowed to consume, so a single runaway interaction cannot quietly cost 100x its neighbors. There are two distinct ceilings: the hard per-response output cap, and — on models that support it — a task budget the model is aware of and paces itself against across a whole agentic loop.

• Set max output tokens deliberately: too low truncates and forces a costly retry; too high lets a verbose turn run away.
• Trim the input side: bloated system prompts and un-pruned conversation history are pure recurring cost on every turn.
• Use a task budget where available to cap cumulative spend across an agent loop, distinct from the per-response cap.
• Use context editing or compaction on long-running agents so stale tool results and history do not inflate every subsequent request.

Chargeback and cost SLAs

Governance only holds if spend is attributable and someone owns a target. Chargeback tags each request with the team, feature, or customer that caused it, so the bill can be split and each owner sees their own line. A cost SLA — or SLO — sets an explicit budget target, such as a cost-per-request ceiling or a monthly cap per feature, and alerts when a change breaches it. Together they turn cost from a surprise at month-end into a metric teams manage like latency.

• Tag every request with owner metadata (team, feature, environment) so cost is attributable, not a single opaque bill.
• Set a cost-per-request or monthly-cap SLO per feature and alert when a deploy pushes spend past it.
• Track cost as a first-class metric alongside latency and quality, so a regression that doubled token use is caught in telemetry.
• Prerequisite: without per-request cost accounting, none of the other levers are measurable — instrument cost first.