Want People to Use Cheaper AI Models? Make Expensive Models Slower

August 11, 2026

Many companies struggle with exponentially growing AI costs.

The biggest savings usually come from one simple change: use a model appropriate for the task.

Reading the Databricks article on managing AI coding costs at scale inspired me to think about this. They describe moving work toward the efficiency frontier, using cheaper capable models, and adding progressive friction as spend increases.

It made me ask: what if the financial cost of a model could be felt immediately as time?

You do not need the heaviest model to summarize a document, write a product description, classify a support ticket, or make a small code change. But how do you make people choose the appropriate model?

Those people might be developers. They might be the marketing team. They might be anyone who sees a list of model names and naturally clicks the one at the top.

In GoModel, we came up with a simple idea grounded in behavioral psychology:

The more expensive the model, the longer you wait for it.

We call it cost-proportional delay.

Why could this work?

Today we have many amazing models. The difference in capability is often much smaller than the difference in price.

For example, Grok 4.5 costs $2 per million input tokens and $6 per million output tokens. Claude Fable 5 costs $10 and $50. Fable is stronger, but it is not five to eight times better for every task.

In one real coding benchmark, Fable 5 scored 92.8, while Grok 4.5 scored 81.1. But the full run cost $67.42 with Fable and $9.24 with Grok. GLM 5.2 showed a similar pattern against Opus 5.0: a smaller difference in the score and a much bigger difference in cost.

Benchmarks are not your production workload. You should test models on your own tasks. But the general pattern is clear: the best model is often only a little better and a lot more expensive.

For most tasks, the cheaper model is enough.

The problem with cost dashboards

Companies already show people token counts, model prices, and monthly budgets. That information is useful, but it does not change behavior quickly.

The cost is abstract. The invoice comes later. The small inconvenience of choosing a cheaper model happens now.

Waiting is different. People feel it immediately.

We already know this from websites. When a page loads slowly, people leave or try another path. The same behavior can work with AI models: if the expensive model always adds a noticeable wait, people start asking whether they really need it.

Add the delay at the AI gateway

The AI gateway or AI control plane is the right place to do this. It already knows which model was requested, who requested it, and how much it costs.

In GoModel, you can add a time penalty to any model. The slowdown is relative to the measured inference time of the model: a value of 0.5 adds 50%. For streaming responses, GoModel buffers the chunks and releases them on the slower timeline.

GoModel lets you configure extra inference time for each model. Here, 0.5 adds a 50% time penalty to Claude Opus 5.

You can try it in the live GoModel model list.

A simple policy could look like this:

The exact numbers are not important. Tune them for your team and your workflow. The point is to make the financial difference visible as a time difference. A relative slowdown also scales naturally: a longer inference gets a larger time penalty than a quick response.

This is mainly for interactive use. Background jobs need routing rules, budgets, and hard limits instead of artificial waiting.

You can also make cheap models genuinely faster

Sometimes you do not need to add a delay. You can remove work from the cheap path instead.

For example, if your gateway runs several slow guardrails, some of them may not be necessary for low-risk internal tasks. Skipping an unnecessary check can make the cheap model faster and more attractive.

Do this only when it makes sense for your use case. Do not remove security, privacy, compliance, or safety controls just to save a few seconds.

The goal is not to ban heavy models

Sometimes you need the best model available. A difficult architecture decision, a critical production issue, or a complex research task can easily justify the extra cost.

The goal is not to block those models. The goal is to add a small moment of friction before using them by default.

Make the cheap path fast. Make the expensive path deliberate.

That may be enough to change model selection - and the AI bill with it.

Transparency

I believe transparency is crucial to a healthy organizational culture. If you introduce cost-proportional delay, explain clearly and openly why it exists, how the rules work, and what the company is trying to achieve. It should feel like a shared efficiency goal, not a hidden punishment. You can even celebrate people who use AI efficiently and still deliver great outcomes - with a symbolic Vibe Coder of the Year award, for example. Reward the outcome and the smart use of resources, not low spending alone.