Misreading Open-Source Model Cost Share: Check the Denominator Before the Percentage

    A high share inside model-call spend is easy to headline as “most of the AI budget.” This article explains why that reading fails: percentages only make sense once the numerator, denominator, cost layer, coverage, and rounding rules are fixed. It walks through four cost layers, how an 89% in-pool share can become a much smaller share of total budget, why small residuals are not strategy, why open weights are not zero cost, and how routing, unit economics, and reproducible usage events keep cost reports honest.

    Misreading Open-Source Model Cost Share: Check the Denominator Before the Percentage

    Model cost rankings are easy to turn into headlines. A figure such as “nearly 90% of call spend goes to one class of models” can sound as if the enterprise has handed most of its AI budget to a small set of suppliers. A stricter reading is often different: inside a limited—and sometimes shrinking—pool of model-call spend, that class accounts for close to nine-tenths. The gap between those two statements is the denominator, the statistical layer, and the cost structure.

    This is not wordplay. It changes how teams choose models, plan capacity, approve budgets, design routing, and manage supplier risk. Reading the number correctly means splitting the cost definition first, then checking it against a reproducible data path.

    1. Agree the metric dictionary: at least four layers

    Before discussing “how much was spent,” answer “which layer of spend.” In engineering terms, at least four layers should stay distinct.

    Usage. Request count, input and output tokens, GPU-seconds, tool calls, multi-turn rounds, successful tasks, and similar measures. More usage does not automatically mean higher cost year over year, because unit price, cache hit rate, context length, and retry policy all move.

    Direct model cost. Inference charges driven by call volume, compute and network consumed by self-hosted inference, cache and storage fees, and extra cost from failed retries. This layer is usually closest to the bill, but “estimated from list price” and “settled in finance” still need to be separated.

    Full application cost. Data cleaning, retrieval and vector storage, evaluation-set maintenance, human review, prompt and workflow upkeep, monitoring and alerting, security and compliance checks, integration work, and operations labor. Many teams treat layer-two call fees as layer three, or even as the entire AI budget, and then overstate the real share of model fees.

    Business total cost of ownership. Cost of failed launches, rework from quality regressions, business loss from latency, data exposure and compliance risk, lock-in, and replacement or migration cost. This layer is hard to monetize directly, but in critical workloads it often matters more than inference fees.

    A usable metric dictionary should at least state: what the numerator is, what the denominator is, the unit, the time window, whether retries are included, whether discounted prices are used, currency and tax treatment, which workloads and model classes are covered, and how unidentified spend is bucketed. Without those constraints, percentages are not comparable.

    2. How to read “89%”: multiply by the smaller denominator first

    When a report says a model class accounts for 89% of “model-call spend,” the first question is what share that call-spend pool is of the company’s AI budget. If call spend is only a small slice of full application cost, the share of the total budget can be far below 89%.

    A structured example, not tied to any real report, makes the arithmetic clear. Let annual AI budget be B, identifiable model-call spend be C, and spend tied to one model class be S. Then:

    1. Share of total budget = S / B
    2. = (S / C) × (C / B)

    S/C is the share inside the narrow spend pool. C/B is that pool as a fraction of the wider budget. If S/C is 89% and C/B is only 2%, then S/B is about 1.78%. Reading 89% as “89% of the enterprise AI budget” is an order-of-magnitude error.

    The same identity explains why “more people are using it, yet less money is being spent” can both be true. Let request volume be U and average cost per request be p, so call spend C ≈ U × p. If unit price falls faster than volume grows, total spend can fall. Higher cache hit rates, tighter context trimming, and more mature batch scheduling also lower average cost. Usage and active users can rise while the spend pool shrinks. A rising share inside that pool is not a rising share of the total budget.

    A more precise statement has three parts:

    1. Inside identifiable model-call spend, this class accounts for X%.
    2. That call-spend pool is Y% of full application cost, or of the enterprise AI budget.
    3. Against the total budget, the share is about X% × Y%, with the window, sample coverage, and unidentified portion stated.

    Only after those three layers are split can an in-pool share stop being mistaken for a share of the whole budget.

    3. Top shares, concentration, and residuals: do not infer strategy from two points

    Concentration metrics are useful, but only when bound to a definition. CRn is the sum of the top n category shares. HHI is the sum of squared shares. They help show whether spend is concentrated. They do not, by themselves, prove technical quality, supply safety, or a future trend.

    Residuals are the more common trap. If the top three integer percentages sum to 87% and the reported total is 89%, the two-point gap does not justify “someone else took the remaining 2%” or “a hidden trend exists.” More likely causes include rounding, overlapping category definitions, mismatched time windows, incomplete sample coverage, other or unknown sources, and mixing discounted bills with estimated cost.

    Reports should show the identity explicitly:

    1. Reported total = classified sum + other categories + unidentified sources + rounding adjustment

    “Unidentified sources” belong in a data-quality workflow, not in the conclusion. Engineering should reconcile raw event tables, bill rollups, and sample coverage first. In a review, label the two points as rounding, other, or unknown. Drawing strategy from a residual usually costs more than it returns.

    “A single supplier is over half” also needs more than one dimension. A cheap model can drive a large request share and a small cost share. A high-capability model can be called less often and still dominate cost through long context, multi-step reasoning, and tool use. Another model may be inexpensive and still dominate successful critical tasks. At minimum, watch call share, token share, cost share, successful-task share, human rework rate, and blast radius of failures together.

    4. Open models are not zero cost: decide on TCO, not unit price

    When teams “buy an open model” or run open weights, total cost of ownership is what gets undercounted. A public license is not the absence of cost, and self-hosted inference is not “just buy hardware.” Fixed cost includes compute, memory and storage, network, redundancy, data-center or cloud capacity, monitoring, security, upgrades, evaluation, and operations labor. Variable cost includes energy, egress, cache misses, failed retries, and elastic scale-up and scale-down. Re-evaluation, prompt adaptation, and regression tests after a model update are costs too.

    Comparing hosted calls with self-hosted inference only works after quality and SLA are brought to the same bar. The break-even volume is then:

    1. Self-host break-even request volume
    2. = fixed cost / (hosted unit cost − self-hosted variable unit cost)

    The formula is meaningful only when quality, latency, availability, and compliance are comparable. If a self-hosted cluster is underused, fixed cost is spread over fewer effective tokens or successful tasks, and unit cost can be much higher than a surface estimate. Steady, large load can make self-hosting cheaper, but it also means owning capacity planning and incident response.

    A metric closer to the business than “dollars per million tokens” is cost per successful task:

    1. Cost per successful task =
    2. sum(input-token cost + output-token cost + retry overhead
    3. + tool / storage / network cost + attributable compute cost)
    4. / number of successful tasks

    Retries, failed requests, multi-turn interaction, and tool calls must be inside the sum. Otherwise rework caused by weak outputs is left out. That matters especially for open models: a low inference price does not mean a low end-to-end cost. Unstable quality amplifies total cost through retries and human review.

    5. Routing and cost control belong on the call path

    With several models in production, the right move is not “switch everything to the cheapest model.” It is a model abstraction layer and a routing policy that jointly consider task type, risk level, data classification, latency budget, cost cap, and quality bar. The router should support timeout, retry, degradation, circuit breaking, and budget alerts, and it should keep a traceable record of each call.

    A neutral sketch:

    1. route(request):
    2. if request.data_class == "sensitive":
    3. candidates = candidates that meet data-residency and audit requirements
    4. else:
    5. candidates = all available candidates
    6. if request.task_type in {"classification", "extraction"}:
    7. preferred = a small or low-cost model
    8. elif request.quality_threshold is within the acceptable range:
    9. preferred = a general-purpose model
    10. else:
    11. preferred = a high-capability model
    12. if request.latency_budget < predicted latency:
    13. preferred = a candidate that meets the latency constraint
    14. if predicted cost > request.cost_budget:
    15. preferred = a degraded candidate, or queue the request
    16. result = invoke(preferred, timeout, retry_policy)
    17. if result.failed or result.quality_blocked:
    18. return fallback(candidates)
    19. return result

    Outside routing, caching, context trimming, output-length limits, batching, async jobs, quotas, and anomaly detection can all cut cost. Every cost cut still needs offline evaluation and an online gate, so savings do not buy a predictable quality regression. For complex reasoning, code generation, or high-risk decisions, keep a high-quality fallback. Do not rank models by unit price alone.

    6. Observability: make every percentage reproducible

    Cost conclusions are reproducible only if the event model carries enough attribution. A lean but complete usage event might look like:

    1. UsageEvent:
    2. trace_id
    3. task_id
    4. tenant
    5. workload_type
    6. model_tier
    7. source_type // neutral class, e.g. hosted call or self-hosted inference
    8. input_tokens
    9. output_tokens
    10. retry_count
    11. success
    12. latency_ms
    13. gpu_seconds
    14. unit_cost_estimate
    15. timestamp

    Aggregation should at least group by business unit, task type, model tier, source type, environment, success, and retry count. Finance bills and usage estimates should be reconciled on a schedule, with settled cost, estimated cost, and shared-resource allocations kept apart. Idle capacity, redundancy, and operations cost on a shared cluster need an explicit allocation rule. Otherwise one team will conclude “the model is cheap” and another “the model is expensive” from the same estate.

    The report layer should show three views at once: a usage view (who is calling), a cost view (where the money goes), and a value view (quality, latency, and rework per successful task). A single rolled-up percentage is an easy way to send engineers and budget owners to the wrong conclusion.

    7. How to brief management: denominator first, conclusion second

    A cost report that can be acted on can follow this order:

    1. State the object: model calls only, or also data, storage, evaluation, human review, and operations.
    2. Give totals and coverage: budget size, attributable amount, and the unidentified share.
    3. Show shares in layers: share inside the subclass, subclass as a share of full cost, and the product against total budget.
    4. Label the rules: time window, currency, discounts, tax inclusion, whether retries count, and rounding.
    5. Give unit economics: cost per successful task, P95 latency, success rate, and rework rate—not unit price alone.
    6. State risk and action: concentration risk, switching cost, room for cache and batching, expected gain from routing, and evaluation sets that are still missing.

    “89% went to one class of models” is weaker than: “In identifiable model-call spend this quarter, that class is close to nine-tenths. The call-spend pool is about Y% of full application cost, or about X% × Y% of the total budget. The gap between the top categories and the reported total is mainly rounding and unidentified sources, and is not treated as a trend.”

    Closing

    “More people use it, less money is spent, and nearly nine-tenths of the smaller amount goes to one class of models” is best read as an engineering statement: inside a defined call-spend pool that may be modest in size and falling in unit price, one class has a high share. That share is not 89% of the enterprise AI budget.

    Practical model-cost control means measuring call volume, direct cost, full cost, and business value in separate layers; comparing hosted calls and self-hosted inference on the same quality baseline; replacing a single unit price with cost per successful task and TCO; controlling spend with routing, cache, retry policy, and evaluation gates; and keeping the denominator, coverage, rounding, and unknown portion visible in the report. Only then do open-model cost figures support technical decisions instead of order-of-magnitude misreads.