Most AI cost advice collapses to one move: use a smaller model and hope it still works. That is the lever with the most quality risk, and it is the one people reach for first because it is the most obvious. It should be near the bottom of the list. Below it are six others that cut spend by removing waste or changing how the agent works rather than how well it works, and several of them carry no quality trade-off at all.
The ordering here is deliberate: waste reduction first, trade-offs last. For the failure that motivates all of it, see why your token bill keeps growing. And the meta-point before any of it: measure first, because the right lever is the one that targets your biggest concentration of waste, and that is specific to your system.
0. Measure before you cut
This is lever zero because skipping it makes every other lever a guess. You cannot cut what you cannot see, and "the bill feels high" tells you nothing about where the money actually goes.
You need per-agent cost attribution and a per-run token breakdown: which agent spends the most, which step inside a run dominates, how much of each prompt is stable prefix versus variable payload, what your retry rate is, what your cache hit rate is. With that, the biggest lever for your system is obvious. Without it, you will spend a week optimising a prompt that was 5% of the bill while a retry loop eats the other 40%.
1. Cap your retries
This is almost always the biggest pure-waste line, and it is the first real lever. An agent that retries on failure with no cap, carrying the full conversation history into each attempt, spends wildly more on its failing inputs than its successful ones. The structurally unrecoverable inputs are the worst: they retry until they hit the model's hard limit, turning a 6,000-token job into an 80,000-token one, and because each retry is a perfectly valid request, nothing flags it.
Cap the retries. Three attempts, then fail cleanly and record the failure. Check what context each retry actually needs, because dragging the entire history into a retry that only needs the last turn is paying for tokens that change nothing. This lever frequently removes a double-digit percentage of a bill, and it improves quality if anything, because a clean failure you can see beats a silent twenty-attempt loop.
2. Trim the context you drag around
Agents accumulate context the way garages accumulate boxes. A conversation history that grows unbounded, a retrieved-document block that includes ten chunks when three would do, a system prompt that nobody has pruned since launch: all of it is billed on every call.
Audit what the agent actually uses. Trim the history to the window that affects the output. Tighten retrieval to the chunks that earn their place. Prune the system prompt of instructions that no longer apply. None of this touches output quality, because you are removing tokens the answer did not depend on; you are just no longer paying to ship them on every request.
3. Cache your stable prefix
If your agent sends the same long system prompt, tool schema, and examples on every call, you are paying full input price for an identical prefix every time. Prompt caching bills that reused prefix at a steep discount instead.
This is close to free money for high-frequency agents with a large fixed prefix, and it asks for no quality trade-off whatsoever; the output is byte-identical, only the bill changes. The catch is keeping it working, because a prefix that shifts (a timestamp moved to the front, a reordered tool list) silently drops your hit rate to zero while the agent keeps running. The full treatment is in the prompt caching discount you are not claiming; the short version is: cache the prefix, then monitor the hit rate so a refactor cannot break it unseen.
4. Right-size the model per step
Now the trade-off levers begin, and the trick is to apply them selectively rather than across the board. A multi-step agent rarely needs its strongest model for every step. Classification, extraction, and routing are often handled identically by a cheaper model; only the genuinely hard reasoning step needs the expensive one.
Route by difficulty. Send the easy, high-volume steps to a small model and reserve the strong model for the steps that actually need it. A blanket downgrade trades quality you may need; a per-step routing captures most of the saving while protecting the cases that matter. This is where measurement pays off again: the per-step cost breakdown tells you exactly which steps are both expensive and simple enough to downgrade safely.
5. Batch and deduplicate
Two cheap structural wins. If your agent processes items one at a time when the work is naturally batchable, you are paying per-call overhead repeatedly; batching amortises it. And if the same input shows up repeatedly (the same document summarised, the same query answered), a cache on the result, keyed on the input, turns the second and subsequent occurrences into a lookup instead of a model call. Neither touches quality; both just stop you paying twice for the same work.
6. Kill the agents nobody uses
The cheapest tokens are the ones you never spend. Attribution by feature and by agent regularly surfaces a surface that costs real money and drives nothing: a feature behind a flag almost nobody enables, an internal agent still running after the project that needed it shipped, a debug path left on in production. This is not optimisation, it is cleanup, and it is pure saving with zero quality cost because the output was not serving anyone. You only find these with the per-feature breakdown; in the account total they are invisible.
7. Downgrade the model, last and measured
Finally, the lever everyone starts with. If after the six above the bill is still too high, then yes, consider a genuine model downgrade. But do it last, do it measured, and do it watching the quality score.
The discipline that makes this safe is continuous scoring. If a rubric and a judge are running on the agent, the downgrade and its quality impact land on the same chart, so a drop in the score distribution shows up exactly where you made the change and you can roll back before customers feel it. Cutting cost without a quality signal running is how teams save money and lose retention at the same time and never connect the two events. With the signal running, the model downgrade becomes a measured trade rather than a gamble.
The pattern across all seven: waste reduction is free, and trade-offs should be selective and measured. Most teams have more waste than they think and reach for the risky lever first. Flip the order, and you will usually hit your number before you ever have to touch quality. AgentPing gives you the per-agent and per-step attribution to find the waste and the quality scoring to keep the trade-offs honest. Get started and measure your most expensive agent before you cut anything.