How to Cut AI Agent Costs Without Downgrading Your Product

Key takeaways

• On BrowseComp, GPT-5.5 at Extra High scored 84.36% at a total cost of $33.27. GPT-5.6 Luna at Extra High scored 84.04% at $1.33, and prices have been cut further since.
• Reported production results include 98% of prior extraction accuracy at one-eighteenth the cost, and 78% of hard browser tasks completed for about $14 against 80% for roughly $235.
• Reasoning effort is the cheapest lever nobody re-tests: low effort on the new generation beat high effort on the previous one in OpenAI's reported evaluation.
• Architecture beats model choice at scale. Programmatic tool calling cut input tokens 21% in one reported case, and deterministic cache breakpoints cut uncached input 28% in another.
• These levers compound rather than add, which is why most teams underestimate the total saving available to them.

Why should you re-run model selection right now?

Because the default habit is now expensive.

For a long time the safe move was to reach for the flagship model at the highest reasoning setting, because cost-optimised models struggled with long context and heavy tool calling. OpenAI's own builder guide says that has changed, and it puts a number on it.

On BrowseComp, a search benchmark for finding obscure facts, GPT-5.5 at Extra High scored 84.36% for a total cost of $33.27. At launch, GPT-5.6 Luna at Extra High scored 84.04% for $1.33. Essentially the same answer quality for roughly one twenty-fifth of the spend, with further price cuts since.

The uncomfortable implication: if you have not re-benchmarked since your last upgrade, your defaults are probably a rounding error away from free money.

What are teams actually reporting in production?

The guide collects a few operator numbers worth quoting exactly.

• Hypha reports Luna keeping 98% of GPT-5.5's extraction accuracy at one-eighteenth the cost.
• Browser Use ran 106 hard browser tasks: Luna completed 78% for about $14, while the current state of the art reached 80% for roughly $235.
• PlayerZero moved a code exploration task to Luna and reports 64% lower inference cost, 90% faster responses, and five points of F1 improvement.

The pattern is not that small models are good enough. It is that the accuracy gap has narrowed to a couple of percentage points while the cost gap stayed an order of magnitude wide. That is a very different tradeoff to the one most cost models were built on.

How do you find the cheapest lever first?

Start with reasoning effort, because it costs nothing to test.

OpenAI reports that on Agents' Last Exam, GPT-5.6 Sol at low reasoning outperformed GPT-5.5 at high reasoning with the harness held constant. Most teams carry forward the reasoning defaults they set for a previous model generation and never revisit them. That is a config change, not an engineering project.

Then work down this order:

1. 1Reasoning effort. One config value. Test low before you assume you need high.
2. 2Model selection per step. Not per product. A legal-tech flow that parses handwritten memos before analysis can run extraction on a cheap model and reserve the frontier model for the judgement.
3. 3Prompt caching. One team reports adding deterministic cache breakpoints and workspace-specific keys to a shared 29,000-token prompt and cutting uncached input by 28%. The cache window is now at least 30 minutes, which makes reuse across runs realistic.
4. 4Architecture. Programmatic tool calling lets the model orchestrate tools in code and process outputs outside its context window. One reported evaluation matched rubric quality with 21% fewer input tokens.

What is the observation the benchmarks miss?

That these savings multiply, and almost every founder models them as if they add.

If you cut input tokens 21% with programmatic tool calling, then cut uncached input 28% on what remains, then move a step to a model that is an order of magnitude cheaper, you are not stacking three separate discounts on one baseline. You are applying each one to the shrunken output of the last. The difference between additive and multiplicative math here is the difference between a plausible plan and a surprising one.

The second thing benchmarks miss: the real boundary in an agent is not model choice at all. It is the line between work that needs judgement and work that only needs data filtered, joined and moved. Every token you spend reasoning over an intermediate result that a three-line script could have produced is pure waste, and it is waste that scales with your usage rather than your headcount.

What should you actually do this week?

Pick your single highest-volume agent step. Log its real token profile: input, output, cached, reasoning. Then run one experiment per lever, in the order above, and record the cost per successful task rather than the cost per call. Success rate is what makes a cheap model expensive.

The takeaway: the cheapest agent is not the one on the cheapest model, it is the one that only spends frontier tokens on decisions a script cannot make.

If you want to see what these levers do to your monthly bill before you rebuild anything, model your token costs per step with the Calcaas LLM cost calculator.