Anthropic has released two new model variants: Claude Fable 5.2 and Claude Mythos 5.2. The most important point at first glance is the lower price. The second point deserves at least as much attention: anyone who wants to use faster outputs pays double for it.

This turns a factor that was previously regarded more as a technical property into a cost item in its own right. Response speed is no longer a by-product of model choice, but an option that becomes visible in the bill.

What is confirmed – and what is not

The reporting is thin: there are the two new versions, an overall cheaper base price and a surcharge for speed amounting to double the amount. Nothing can be seriously derived from this about specific rates, context sizes or performance differences between the two models.

For planning purposes, that is no disadvantage, as long as you ask the right question. It is not: Which model is the best? It is: What proportion of our requests actually needs a fast response – and which does not?

Why latency is not equally valuable everywhere

Latency, i.e. the time until a response, has very different effects in different scenarios. In interactive situations, it directly affects usage: when a developer waits in the editor for a code completion, every second interrupts the workflow. The same applies to chat interfaces, support assistants or web search functions where people are waiting immediately for a reaction.

The situation is quite different for background processes. Whether a nightly run translates product texts, adds metadata, classifies tickets or evaluates log files makes no difference to how users perceive it – as long as the result is available in the morning. Paying a speed surcharge for such tasks burns budget with no noticeable return.

In the practice of many companies, a considerable share of token volume falls precisely on these asynchronous tasks. That is the lever that a tiered pricing structure can lift.

Questions for budget planning

Before an organisation introduces new model versions, a sober assessment of its own usage is worthwhile:

  • Which use cases run interactively, which in the background – and how is the volume distributed across them?
  • Is there a defined target for response time in interactive cases, or is speed only assessed by feel?
  • Which processes could be switched from synchronous to asynchronous without users experiencing it as a deterioration?
  • What is the share of recurring, nearly identical requests that can be cached?
  • Who in the organisation sees the actual costs per use case – and not just a monthly total?

Without this transparency, any price change by a provider becomes a shot in the dark. With it, however, it is possible to decide by calculation where a surcharge is justified.

Quality, speed, cost: a triangle of objectives

A cheaper base price tempts you to expand volume. That is precisely where a silent cost trap lies: if more requests are made because the individual request has become cheaper, the total can still rise. It therefore makes sense not to consider price changes in isolation, but together with the expected usage volume.

There is also the quality dimension. A quickly delivered but unsuitable result creates rework – and that costs developer time, not tokens. Anyone comparing model variants should therefore not only measure throughput and price, but also how often a result can be adopted without correction.

Architecture: keep model choice interchangeable

The most important technical consequence of such announcements is independent of the specific provider: the decision for a particular model and a particular speed tier belongs in the configuration, not in the application code.

An intermediate layer that receives requests and forwards them to the appropriate variant depending on the use case has proven its worth. Interactive tasks go to the fast tier, batch processing to the cheap one. If a provider changes its prices or a new version appears, an adjustment in one place is enough.

A second component is part of this: clean recording of consumption and response times per use case. Only then can assumptions about user behaviour be substantiated – for example, whether a slower variant in a form assistant actually leads to drop-offs or whether nobody notices the difference.

Assessment for web and software projects

For ongoing projects, the announcement above all means: operating AI-supported functions becomes a calculation task with several variables, and speed is now one of them. Anyone who separates their use cases into interactive and asynchronous can benefit from cheaper base prices without saving where users would feel the delay. And anyone who treats model choice as an interchangeable configuration rather than a fixed commitment in the code can react to the next price change without rebuilding the application.

Sources