---
title: "Model pricing isn't reliable anymore"
description: "Per-token price is a bad way to pick a model. Cost per finished task, cache, and routing matter more. Start cheap, then escalate only when you hit a wall."
author: "olaf"
author_name: "Olaf Sulich"
tags: ["agents","models","pricing"]
published_at: "2026-08-20T16:10:45.211Z"
canonical: "https://mega.dev/model-pricing"
---

Use the expensive models for demanding tasks and the cheap ones for simple work. Simple, right?

Except that stopped being true a long time ago.

It's time to rethink how we pick models to do the job.

## Boiling the frog slowly

The model ecosystem got a lot more complicated over the last few years. Plenty of new providers joined the game, including a wave of Chinese open-source alternatives like KIMI, DeepSeek and GLM. American labs don't ship one main model anymore. Every cycle they ship a whole family, and each model in it has completely different performance and its own pricing.

On top of that, we still live in the era of cheap intelligence. Mainstream providers offer affordable subscription plans, and the Chinese equivalents go for a fraction of that price.

The line is moving, though. Who would have thought a few years back that we'd be paying $200 for an AI subscription? It still works out in our favor, because the value of that subscription, counted in tokens, is several times higher than what we pay, sometimes an order of magnitude.

Nothing lasts forever. For a while now I've been watching corporations test how far they can push us. That goes for raising plan prices as well as 'experimenting' with what stays available. Anthropic did it a few months ago, testing the removal of the cheapest $20 subscription. Pulling Fable out of the plans and moving it to token-based pricing made a lot of noise too. Anthropic pushed the final date back several times, but eventually gave in. Probably a matter of heavy demand and compute constraints.

Right now it's one big shoving match between the top labs. Each one either tries to lure us in with something or makes it harder to leave their ecosystem. Limit resets keep landing, and they only encourage us to use more.

I'm convinced this won't last. We'll slowly get used to the changes and the price hikes. It won't happen overnight, you boil a frog slowly, and the competition is fierce enough to discourage sudden moves.

Until then we still have to work and pick the right tools. But how?

## Cheaper per token, pricier per task

When KIMI K3 launched, a lot of people couldn't get over how good a model the Chinese managed to ship. Benchmarks placed it between the Opus 4.8 and GPT-5.5 generation and the newer models like Fable 5 or GPT-5.6 Sol. In the [Artificial Analysis Intelligence Index](https://artificialanalysis.ai/evaluations/artificial-analysis-intelligence-index?eval-cost=cost-per-task&eval-token-usage=output-tokens-per-task), which pulls together several benchmarks, it did great and scored 57.

On top of that the model was cheap, $3 per million input tokens and $25 per million output. Roughly half of what OpenAI's best model cost at the time. GPT-5.6 Sol was $5 per million input and $50 per million output, and Anthropic's counterpart, Fable 5, $10 per million input and $50 per million output.

So did Chinese models finally catch up with the American competition, and can we move over to them for good? Not quite.

In the [Cost per Intelligence Index Task](https://artificialanalysis.ai/evaluations/artificial-analysis-intelligence-index?eval-cost=cost-per-task&eval-token-usage=output-tokens-per-task) test, which measures what a given task cost to complete, KIMI K3 came out worse than the much more expensive GPT-5.6 Sol.

What we often forget is that the cost of finishing a task isn't just input and output price. Reasoning tokens count too, and so do writing and reading the cache.

With subscriptions the question is how far a given plan gets you, how fast you hit the limit. Staying with Kimi, plenty of users [complained that the limits only cover a handful of tasks](https://x.com/LLMJunky/status/2078014545977573467).

It's hard to judge objectively, because a lot depends on your working style, your harness, and how often providers reset the limits.

Don't get me wrong, KIMI K3 is an awesome model that challenged the top mainstream ones. But it shows nicely that the input/output price doesn't translate directly into the total cost of getting the work done.

The same thing happens with other models. The latest loud case is the Sonnet 5.0 launch. It doesn't look bad on paper, $2 per million input tokens, $10 per million output. That's still almost twice as expensive as OpenAI's GPT-5.6 Luna, but next to other Anthropic models it looked like a good deal.

In reality the model burns a lot of output tokens, ends up only slightly cheaper than Opus 4.8 (and still pricier than OpenAI models that are theoretically more expensive), and on top of that it takes the longest to finish a task in the [Time per Intelligence Index Task](https://artificialanalysis.ai/evaluations/artificial-analysis-intelligence-index?eval-speed=time-per-task) eval.

Maybe it has to do with the tokenizer change Anthropic writes about:

<Callout kind="definition" label="Sonnet 5 tokenizer">
Sonnet 5 is an upgrade to Sonnet 4.6, but it uses an updated tokenizer that changes how the model processes text to improve performance. The tradeoff is that the same input can map to more tokens: roughly 1.0–1.35× depending on the content type. The introductory pricing is set so that the transition to Sonnet 5 is roughly cost-neutral.
</Callout>

For us, the end users, that doesn't change anything. If someone picked Sonnet 5.0 as their only model, going purely by the input/output price, they'd probably pay more and get worse results than with the more expensive models.

## Two models, one task

What if we used the bigger, pricier model for the demanding work and handed the implementation itself to a cheaper one? Then, in theory at least, we get the best of both: reasoning from the expensive model, speed and price from the cheap one.

The pattern has been around for a while and a lot of people use it daily. Just remember that switching models during one session resets the cache, which can push the cost up.

At the Fable 5 launch Anthropic [shared two patterns](https://x.com/ClaudeDevs/status/2074606058128224365) for getting very good results at a much lower price.

The Advisor Tool Pattern is exactly that: a cheaper executor model, while generating its answer, consults a smarter advisor for strategic guidance. The advisor reads the conversation and prepares or corrects the plan the executor works from.

The executor decides on its own, through a tool call, when to ask the advisor for input. Anthropic mentions that Sonnet 5 + Fable 5 in this setup gets 92% of the Fable 5 score while costing only 63%.

The Orchestrator Pattern works on a similar principle, where the main model plans the work and then delegates it to cheaper workers. The Fable 5 orchestrator achieves 96% of Fable 5 performance at 46% of the price.

Both patterns are built on sub-agents, which keep their own cache, so repeat calls don't pay in full for the same context twice.

## Smart routing

The next milestone would be picking the model for a task automatically. The harness could judge how advanced a task is and decide on the most optimal approach from there.

We've already seen 'auto' modes in various tools, but so far they left a lot to be desired. Cursor recently showed its new Router, which is an interesting direction.

What's the idea? Cursor noticed that 60% of users run every single task through one model. Even very simple tasks pulled in the more expensive model for no reason, which drove the costs up.

So they built a mechanism that matches the best model to a given task. From the data they collect and their own evaluation they can point out which model works best for building UI, which one to use for the most demanding reasoning work, and which one handles long-running tasks.

Users get three options: Intelligence, Balance and Cost. Each comes with its own tradeoffs. Feedback shows the solution works very well. Intelligence mode reaches user satisfaction close to Fable at around 60% lower cost, while raising satisfaction by ~15% over Opus 4.8 at almost the same price. Balance beats Opus 4.8 on satisfaction at about 36% lower cost.

In early access, a few large accounts with thousands of users saved 30-50% on requests routed through the Router compared to sending everything to Opus 4.8, with no noticeable drop in quality.

The Router is still early in development, so there will be rough edges. It's a very interesting way to help developers pick a model, though. Cursor takes the research off your hands and figures out which model fits a given task best.

## How I choose

There's no single good answer. The problem has many layers and depends on a lot of factors. Here's what I try to go by.

Let's start with the fact that every case is different. Your project and your needs can be completely different from those of someone declaring that one model is the best and the competition can't touch it. If you're working on an app where UI skills matter and the current "best" model is mediocre at that, it won't serve you well. Pick the model for the work you actually do, for what gives you the best results.

Start cheap, escalate when you hit a wall. I've noticed people jumping on the newest, best and most expensive model even when they don't need it at all. Try the cheaper one, see if it meets your expectations, whether the quality of the answers is good enough. If not, bring a stronger and smarter model into your process.

Patterns like the Advisor Tool Pattern or the Orchestrator Pattern can help here. If you work in a structured way, it's usually easy to draw the line between where you want the smarter model (hard thinking, analyzing, discussion) and where the cheaper one does the job (implementation based on plan, testing, etc.). New things like Cursor Router can be useful too, where the harness suggests which model to use for your case.

Try different subscriptions and plans. Some of them will last you longer. Even if one provider currently has a slightly better model, overall another subscription can pay off more. Keep an eye on the resets though, one day they'll be gone.

Look at benchmarks, but take them with a grain of salt. There are a lot of problems with them. Some are unreliable or full of holes in how they score models. Some test things that have nothing to do with your real work. And model providers optimize for them, while the model itself often knows it's being tested and can behave differently than it would in the wild. They're not worthless, though, especially the higher-quality ones. They help us see how models handle different situations (DeepSWE, FrontierCode), or what it costs to get a task delivered with them (Artificial Analysis). Treat the data as rough guidance, a picture of where a model roughly sits against the competition.

Everything keeps changing, so picking a model isn't a one-time decision. What's the sweet spot today won't be in a few months. Test new things, check what they give you and at what price.