The great AI cost crunch is already here

For years the AI market trained teams to treat every request as free. Spin up a prototype, fire off as many calls as you like, never look at the bill. That habit is starting to hurt.

This is not one dramatic price rise you can point at. It shows up as token budgets, premium request allowances, model multipliers, usage-based billing, context limits, slower cheap tiers and team quotas. It shows up as a finance person asking why the prototype now has a monthly burn rate.

The crunch is already landing in invoices, tool limits and product decisions. Some AI products will get sharper because of it. Plenty only ever worked while nobody was counting.

Frontier models are expensive for a reason

The best models are doing more work. Larger context windows, deeper reasoning, vision, code execution, tool use, agent loops, search, file parsing, long-running tasks. Somebody pays for that compute, and lately it’s you.

As of mid-June 2026, OpenAI’s API pricing page lists GPT-5.5 at $5 per million input tokens and $30 per million output tokens, with cheaper cached input and cheaper smaller models available. Anthropic’s Claude Fable 5 page lists Fable 5 at $10 per million input tokens and $50 per million output tokens.

Those prices can be perfectly sensible for hard work. They’re far too high to spray across every autocomplete, classification, rewrite, draft and support reply your product makes.

So the question stops being “which model is best?” and becomes “which model is good enough for this part of the job?” We dug into that judgement in choosing the right AI model for business use. The cost crunch just made it harder to skip.

Tool vendors are already rationing access

Watch the coding tools, because they got there first.

GitHub Copilot’s request-based billing docs lay out premium requests, monthly allowances, model multipliers and extra request pricing. Advanced models and features eat more of a user’s allowance. From June 1, 2026, GitHub says Copilot code review uses a multiplier of 13. One review is no longer one unit.

Cursor’s pricing page says the same thing in different words. Plans include a set amount of model usage, and once you burn through it, on-demand usage keeps going and gets billed later.

These are responses to expensive inference. “Unlimited” becomes a marketing line with footnotes, and before long the footnotes are the product.

Enterprises will copy this internally. Teams get monthly budgets. Reaching for the expensive model needs a reason. High-effort agent runs get reserved for high-value tasks, background jobs drop to cheaper models or batch processing, and a product manager starts asking what a feature costs per active user rather than whether the demo lands.

Cost becomes architecture

The lazy AI product throws every request at the strongest model with the full conversation, all available context and a vague nudge to be helpful. The cost-aware product actually routes the work.

Simple classification can go to a small model. Extraction from a fixed format often doesn’t need a frontier model at all. A support reply can pull the right policy first, then ask a mid-tier model to draft from those sources. A hard reasoning task can escalate to a stronger model only after the cheaper checks fail.

Architecture starts to include:

• model routing by task difficulty
• prompt caching for repeated system instructions and source material
• context trimming before long conversations become expensive by habit
• short outputs by default, with expansion only when needed
• batch processing for work that can wait
• per-feature token budgets
• per-user and per-tenant quotas
• logging that ties model spend to product actions
• circuit breakers for tool loops and retry storms
• fallbacks when a premium model is unavailable or over budget

OpenAI’s pricing page already steers developers toward batch processing, cheaper cached input, lower-cost flex processing and spending controls. The cost optimisation docs make the same point from the build side. Cost is a design problem you handle up front, not a surprise on the invoice.

The hidden cost is output

Teams tend to watch input tokens because the context window is right there in front of them. Output tokens often hurt more.

Long agent traces, verbose explanations, generated reports, repeated self-checks, tool summaries. All of that is output, and when the output price is several times the input price, a chatty system bleeds money even when the input is tidy.

Production prompts need to be stricter than demo prompts. Ask for the answer the user needs, not a lecture. Ask for structured output when a system is going to read it. Store the evidence separately rather than making the model retell every step. Summarise history where it helps, but stop resending a bloated transcript just because that is easier than designing the state properly.

For agents, set hard limits. Cap the tool calls, cap the retries, cap the output per status update, and decide the point where the agent stops and asks a human. The expensive failure is not always a wrong answer. Sometimes it is an agent looping confidently for twenty minutes while the meter runs.

AI features need unit economics

Save a staff member ten minutes and a few cents of model spend is a bargain. Rewrite a sentence the user would have typed themselves and that same few cents is waste.

Useful questions:

• What does this model call replace?
• How often will it run per user?
• What is the average input and output size?
• Which calls happen in the background?
• Which calls are triggered by bots, retries or abandoned sessions?
• What is the cost at ten times current usage?
• Which model would we downgrade to if the budget tightened?
• What answer quality would we lose?

Some teams will slash model spend blindly and wreck the product. Others will route carefully and barely feel it. Cost control and cheapness aren’t the same thing, and the difference is whether you measured before you cut.

The product should show restraint

The better AI products feel less clever in the architecture and more useful in the result.

They know when to skip AI entirely, which we covered in when not to use AI. They retrieve the right source instead of stuffing everything into the prompt. They cache the public or repeated work. They use plain deterministic code for rules, calculations and validation, and they save the premium model for the work that needs judgement, ambiguity, vision, deep reasoning or code-level synthesis.

At Rangefront Labs this is already baked into how we approach applied AI, AI agents and SaaS MVPs. Running cost sits in the design from day one, next to security, data boundaries and maintenance.

The teams who come through the crunch in good shape won’t just spend less. They’ll know exactly what each model call is buying them. Count the tokens, then count what the call actually changed.