How to Reduce AI Token Usage Across the Company

A company's token usage climbs when its AI moves from chat to agents. In Anthropic's own data, agents use about 4 times the tokens of a chat interaction, and multi-agent systems use about 15 times.

But using fewer tokens isn't the right answer either. In the same evaluation, token usage alone explained about 80% of the performance variance, so cutting tokens blindly cuts quality.

The useful question is which tokens are wasted: the context that gets re-explained every session, the model that is overqualified for the task, the loop that keeps running after the work is done.

This guide covers where a company's tokens go and 7 ways to cut the waste without cutting the work.

• Waste, not usage: Agents legitimately use more tokens, so cut the repeated, oversized, and unneeded tokens and keep the useful ones.
• Know the drivers: Context read, output written, the cached share, model choice, and steps taken set the bill.
• Measure per task: Cost per completed task and token yield show waste that cost per call hides.
• Reuse before you shrink: Shared context, caching, and batch work cut repeated spending with no change in quality.
• Set limits and incentives: Budgets, step caps, and rewards for outcomes keep usage from drifting back up.

Before cutting anything, it helps to know what the bill is made of. Usage depends on 4 things and agents add a fifth, the number of steps they take. Let's check them out:

• Context read: Everything sent into a call counts as input, including the system prompt, tool definitions, conversation history, retrieved documents, and pasted data. In an agent session, each step re-sends what came before, so input often grows faster than output.
• Output written: Everything the model generates, including reasoning and long answers. Output is usually priced several times higher per token than input.
• Cached share: Cached input costs less than fresh input, so the same prompt can cost very different amounts depending on how much of it is reused.
• Model choice: Prices differ by an order of magnitude or more between small and flagship models. On PromptQL's pricing page, for example, the models range from 0.08 to 2 times the cost of its Opus 4.6 baseline.
• Steps taken: Each step in an agent loop is another call carrying all the earlier context, so a task that takes 30 steps costs far more than the same task done in 5.

The 7 actions below run from finding the waste to keeping it from coming back. The first 2 measure usage and stop the most common repeated spend, the next 3 shrink what each call carries and costs, and the last 2 cap runaway usage and set the incentives. Let's explore them one by one:

1. Measure usage by team, task, and model

You can't cut what you can't see. Break usage down by team, task, and model, and record input, output, and cached tokens separately, so you can see which workloads spend the most and why.

Then pick measures of success that aren't raw volume: token yield, the useful output per token, and cost per completed task, not just cost per call.

Remember, a cheap call that needs 5 retries isn't cheap, and a high-volume workload producing real work isn't waste.

2. Stop paying twice for context

The most common repeated spend is context: the definitions, rules, and corrections that people and agents re-explain in every session.

Write them down once and keep them somewhere shared, such as a context layer, and keep company facts in one source that is updated there, instead of editing copies buried in many system prompts.

PromptQL, for example, suggests context that should be persisted in the wiki or restructured to cut token use on context search and exploration.

3. Send less in each call

Every token sent is paid for on every call, so trim what the task doesn't need. Retrieve only the relevant documents instead of pasting whole files, summarize long conversation histories, and remove unused tool definitions and bloated system prompts.

The biggest saving is often to stop sending data at all.

For example, a model asked about a 50,000-row export in its context pays for every row and can still miscount, while code run over the data returns a small result that the model only has to describe.

4. Match the model to the task

Most work doesn't need the most capable model. Make a small, cheap model the default for simple, high-volume work such as classification, extraction, and summaries, and promote a task to a larger model only when it demonstrably fails.

LiteLLM reports a customer that rolled out automatic routing to 450+ users and saved 51% against an all-flagship baseline across 272,876 requests, with the saving rising from 42.9% to 60.7% as the tier map was tuned.

For decisions with fixed answers, such as labels and yes/no gates, a decision model like Jev can cost less than a general model.

5. Reuse work you've already paid for

3 kinds of reuse cut spend without changing the answer:

• Cache the stable part of every prompt: Providers charge much less for input they have already processed. Anthropic charges about 10% of the normal input price for cache reads, and OpenAI caches automatically, with discounts that differ by model. A PwC study of agent sessions found caching cut API cost by 41% to 80% across 4 models.
• Batch work that can wait: Nightly reports, bulk classification, document processing, and evaluation runs rarely need an answer in seconds. Sending them through a batch API, which runs requests asynchronously, takes 50% off on Anthropic. Schedule these jobs for off-hours so results are ready when people need them.
• Turn repeated workflows into programs: A report or analysis that runs every week shouldn't be planned from scratch each time, because every fresh plan spends tokens exploring the data and reasoning through the steps. PromptQL can help by converting a repeated workflow into a reusable program, so the plan isn't regenerated on every request.

6. Cap loops and output

Agents can keep working long after the task is done, so put limits on them. Set a maximum number of steps per task, a maximum output length, and a reasoning effort suited to the task, and define a stop condition so the agent can end once it has the answer.

Use multi-agent setups only where the task's value justifies their cost. Anthropic's data puts them at about 15 times the tokens of a chat, and it found they excel at valuable tasks that involve heavy parallelization, information beyond a single context window, and many complex tools.

7. Set budgets, limits, and the right incentives

Usage drifts back up unless someone owns it. Give each team a budget, alert on sudden spikes, and charge usage back to the team that causes it, so the cost sits next to the decision.

Be careful what you reward: token leaderboards, the tokenmaxxing trend, reward volume and not results, so measure outcomes per token instead.

Start with what you can already see. Pull last month's usage by team and model, pick the 3 workloads that spend the most, and apply the cheapest fixes first: cache the stable system prompt, move anything that can wait to batch, and try a smaller model on the simplest task. Set a token-yield target for each workload, and review the numbers monthly so the savings hold.

If your teams already work in PromptQL, its spend visibility shows where the tokens go, and its wiki holds the context that stops them being paid for twice.

Should a company reduce token usage at all?

Reduce waste, not useful work. Agents legitimately use more tokens than chat, and in Anthropic's evaluation token usage explained about 80% of the performance variance, so cutting usage across the board can hurt quality. Target repeated context, oversized models, and runaway loops instead.

How much can a company save?

It depends on the workload, so measure before promising a number. Published figures include 41% to 80% from caching in a PwC study of agent sessions, 50% off for batch work on Anthropic's batch API, and 51% from routing in 1 LiteLLM customer's production traffic, which is vendor-reported. These don't simply add up, and your results will differ.

Does cutting tokens hurt quality?

It can when you cut useful work, such as reasoning or retrieved evidence. Cuts that remove repetition, such as caching, batch processing, and shared context, don't change what the model sees. Test any change that does, such as a smaller model or a shorter context, on your own tasks before rolling it out.

How do you track token usage across teams?

Record input, output, and cached tokens by team, task, and model, then track cost per completed task and token yield, not only total spend. Review it monthly, and alert on sudden spikes.

1. Why PromptQL works - promptql.io
2. OpenAI releases GPT-6 Sol and Luna models, slashing API costs 50% or more | VentureBeat - venturebeat.com
3. Managing costs | OpenAI API - developers.openai.com
4. Business Pricing | OpenAI - openai.com
5. 20% price reduction for GPT 5.6 Sol: API, Codex credits and ChatGPT Work - Announcements - OpenAI Developer Community - community.openai.com
6. Don’t Break the Cache: An Evaluation of Prompt Cachingfor Long-Horizon Agentic Tasks - arxiv.org
7. Prompt caching | OpenAI API - platform.openai.com