Artificial Analysis launches cache hit rates and Cost per Task by provider

Artificial Analysis announced that provider-level cache hit rate and cost-per-task data is now live on its platform. This means the real spend of the same open-weight model across different endpoints is, for the first time, compared in a single table.

Each metric has a defined methodology. Cache hit rate is measured by running multi-turn agentic coding tasks and reading the cached token counts in each provider's usage response; it is defined as the share of cacheable input tokens that were served from cache. Cost per task is calculated from each provider's input, output, cache-hit and cache-write prices combined with its measured cache hit rate; to standardize across providers, the same model's input, output and cacheable token counts from its Intelligence Index run are used throughout.

This is worth measuring separately because agentic workloads resend the full conversation history on every turn, so most input tokens are cacheable. Cache pricing and cache hit rate thus become the dominant variables in the cost structure, not peripheral parameters.

GLM-5.3 (max) cost per task spans roughly 9x across providers, from $0.92 at Makora to $8.68 at Nebius. That figure is striking on its own, but what is genuinely informative is why it happens.

First, rule out two common explanations. On cache hit rate, Makora and Nebius sit at 98% and 100% respectively, so nearly all cacheable input is served from cache for both, and the gap is not large enough to explain 9x. On output price, the two charge the same $4.40 per 1M tokens for GLM-5.3 (max).

The remaining variable is input pricing. Makora charges $0.10 per 1M cached input tokens; Nebius offers no cached-input discount on its shared serverless endpoint and bills all input at $1.40. In agentic scenarios input tokens are the overwhelming majority, so this single pricing difference is amplified into an order-of-magnitude gap in cost per task.

From this one can infer: when cache hit rates are similar, provider-to-provider differences in cost per task are driven mainly by cached-input pricing rather than output pricing or cache hit rate. This is an inference drawn from the data above, not a statement from Artificial Analysis.

Cache hit rates range from 41% to 100% across 21 providers (25 endpoints). The distribution is uneven: 15 of the 25 endpoints reach 98% or above, of which 8 reach 100% — Modal, DeepInfra, Parasail, Together AI, DigitalOcean, Nebius, Novita and Z AI's first-party API.

The tail is equally clear. Multiverse Computing has the lowest cache hit rate at 41%, followed by Bitdeer at 50%.

Putting these two sets of numbers together with the cost case above yields a useful judgment: for most mainstream endpoints, cache hit rate is no longer where the differentiation lies — what actually separates costs is cached-input pricing. The significance of hit rate shows up more in the few low-hit endpoints, and in stability when a workload or framework changes the cache prefix.

To be clear, the data above comes from a single source, Artificial Analysis, and reflects provider self-reported measurements with no independent third-party verification. Cache hit rate and cost per task cover only the tracked model endpoints, and cost per task is currently provided by provider only for open-weight models.

The measurement method itself carries dependencies. Cache hit rate is measured from multi-turn agentic coding tasks, so results depend on the specific test harness and task design; Artificial Analysis did not disclose the specific composition and scale of the agentic coding tasks used. In addition, cache hit rate is defined as the share of cacheable input tokens served from cache and does not cover non-cacheable input.

The cost calculation relies on each provider's published input, output, cache-hit and cache-write prices, but the source does not provide the specific value of the cache-write price, only stating that it was used in the calculation. The source also does not state the specific value distribution of the remaining endpoints among the 21 providers that fall below a 98% hit rate, nor the magnitude of provider-to-provider cost-per-task differences for models other than GLM-5.3 (max).

Whether the data is updated over time or as provider configurations change is likewise not addressed by the source. These numbers are therefore better treated as a cross-sectional snapshot at a point in time than as a long-term stable pricing conclusion.

Under Artificial Analysis's release, one commenter pointed out that the test harness matters as much as the provider for cost figures: anything that rewrites earlier context (such as a timestamp in the system prompt, or an edit to a compressed earlier turn) breaks the cache prefix, making the same model look several times more expensive under different agents.

This comment is worth recording, but its evidence level must be flagged. The claim has not been confirmed by Artificial Analysis and no quantitative evidence was given, so it can only be treated as a source claim and not placed on equal footing with the measurement data above.

It does not, however, conflict with the confirmed mechanism: since cache hit rate is defined as the share of cacheable input tokens served from cache, any behavior that breaks the cache prefix directly lowers that share and thereby raises cost per task. This is an inference from the existing definition, not a confirmation of the commenter's claim.

For teams building agentic applications on open-weight models, this release makes something previously fuzzy comparable: the same model's cost per task across providers can differ by roughly 9x, and the difference comes mainly from one contractual term — cached-input pricing — rather than model capability or output price.

This means the focus of procurement judgment needs to move earlier. Among the endpoint group where cache hit rates generally reach 98% or above, comparing output prices or hit rates has limited value; what is more worth checking is whether a provider offers a discount on cached input, and whether that discount applies under specific forms such as shared serverless endpoints.

At the same time, keep some wariness about the measurement methodology. Cost per task is a standardized result calculated under a uniform token-count assumption from each provider's published prices and measured hit rate; it describes comparability, not the actual bill a given team would see under its own workload. Real cost will also vary with framework, context management and task shape.