Open-Source LLM Usage Is Rising While Revenue Pressure Grows
Enterprise adoption of open-source LLMs is increasing token consumption, yet spending and unit revenue do not necessarily rise in tandem. This article explains how to separate consumption, spend, and unit revenue; why the usage-revenue gap appears; and how teams can move from selling API calls to delivering accountable, renewable business outcomes through hybrid deployment, workflow integration, transparent metering, and outcome-based pricing.
A recurring pattern in the industry is that open-source large models have already moved deeply into enterprise R&D, customer support, knowledge processing, and process automation. Token consumption is rising as a share of usage, but the corresponding share of spending does not necessarily rise with it—and may even fall. Public observations often show that enterprise spending related to open-source models is highly concentrated among a small number of suppliers. At the same time, aggregated call volume is increasing, while the amount paid per token is being pushed down by price competition and free quotas. This gap between usage and revenue shows that “selling calls” does not automatically turn into profit. The core question for the next stage is not to prove again that models can be called, but to turn market share into business results that are measurable, renewable, and deliverable.
Align the Definitions First: Spend, Consumption, and Unit Price Are Not the Same
To discuss the usage-revenue gap, at least three separate accounts need to be distinguished.
The first is the consumption account: input tokens, output tokens, cache hits, multi-turn context, and tool-call returns all count toward usage. Long context, multi-step agent reasoning, and batch offline tasks can make the consumption curve rise sharply, while what users perceive is often simply that “the task was completed.”
The second is the spend account: contract prices, tiered discounts, reserved capacity, free quotas, and internal settlement prices determine how much an enterprise actually pays. Once open-source weights can run locally, some traffic shifts from metered APIs to self-hosted inference. Visible spending on cloud or aggregation platforms may then decline even if business calls have not decreased.
The third is the unit revenue account: if a supplier prices only by token, price wars, low-cost Flash-class models, cache discounts, and substitute competitors all push down revenue per million tokens. Consumption can rise while unit price falls, so total revenue may stagnate or even decline.
Therefore, “leadership in calls” cannot be read directly as “commercial leadership.” When technical teams plan capacity and finance teams review gross margins, they must look at consumption, settlement price, cache hit rate, and self-hosting share together. Otherwise, it is easy to mistake free or low-priced traffic for the core business.
Where the Usage-Revenue Gap Comes From
Price anchors move down. Open-source weights reduce switching costs. Buyers can compare vendors horizontally using benchmark sets, sampled test sets, and latency budgets, and low-cost models can easily become the default route. As long as quality remains within an acceptable range, routing policies will send traffic to cheaper endpoints.
Task structure becomes “heavier.” Retrieval augmentation, code agents, and multi-document review amplify context and tool turns. A single user request may sit on top of dozens of model calls. If pricing is still based on a single conversation, cost is amplified while revenue remains capped by the old package.
Value occurs outside the model. What enterprises actually pay for is accuracy, latency, permissions, auditing, data residency, and integration with existing systems. A pure API does not carry these constraints, so the premium remains with integrators, platforms, or customer self-hosted teams, while the model supplier captures only the thinnest layer.
Metering and product design are misaligned. Token-based billing is useful for getting started, but it is poor at expressing “a ticket was closed” or “a compliance report was produced.” When usage rises, customers become more sensitive to the bill than to business outcomes, so price pressure becomes a rational choice.
Move from Selling Calls to Selling Deliverable Capabilities
Without inventing vendor-specific interfaces for any model, the following discusses only common, verifiable industry practices.
Use hybrid deployment rather than choosing one side. For batch processing that is not latency-sensitive but is data-sensitive, place inference in the customer’s private network or self-hosted environment. For elastic peaks and experimental traffic, retain metered endpoints. Routing switches based on data classification, queue depth, and cost budget. This preserves usage while avoiding having all revenue locked to the lowest unit price.
Embed the model in the workflow instead of stopping at the chat window. A typical chain is: object storage holds source text, a message queue smooths peaks, a container platform runs inference and post-processing, and logs and monitoring alerts record latency, refusal rate, and cost. The model is only one link in the chain. If a team uses a cloud platform such as Baidu AI Cloud, it should still build orchestration on these generic capabilities rather than turn the business story into an evaluation of a single model brand.
Reprice around outcome metrics. Internally and with customers, keep both a token cost account and a business outcome account in parallel—for example, “first-contact resolution rate,” “extraction field accuracy,” and “reduction in manual review hours.” A contract can combine a base capacity fee with outcome-based incentives, with tokens treated as a transparent cost item rather than the only unit of sale. The following illustrative configuration does not depend on any vendor’s syntax:
route:default: low_cost_endpointwhen:- if: data_class == confidentialthen: private_inference- if: task == high_stakes_extractionthen: higher_quality_endpointbudget:daily_token_cap: 200000000on_exceed: degrade_to_cache_or_queue
Govern quality and cost together. Establish fixed sampling sets, regression sets, and online shadow traffic; cache system prompts and retrieval results; summarize before inference for very long context; and limit agent steps. Without these controls, low-cost models shift rework and human fallback costs to the business side. The visible bill may fall while total cost of ownership rises.
A Checklist for Enterprise Implementation
Procurement and architecture should jointly answer several questions: How much traffic can be privatized, and how much must remain elastic? Is sensitive data kept out of public endpoints by default? When routing fails, is degradation handled by cache, rules, or human review? Can the bill be split by application, tenant, and task type? Will quality regression automatically switch back to a higher-spec endpoint and trigger an alert?
Suppliers should answer: Beyond tokens, do they provide auditable deployment forms, evaluation baselines, and capacity commitments? Do they turn integration, permissions, and observability into reusable modules rather than starting from zero for every project? If market share cannot map to these deliverables, then even high concentration is only concentration of low-priced traffic.
Conclusion
Open-source models entering enterprise workflows is already a fact, and rising call volume alongside declining unit payment is not contradictory. Narrowing the gap depends not on telling another version of the parameter-scale story, but on transparent metering, hybrid deployment, workflow embedding, and outcome-based pricing. Technical teams should first calculate the three accounts clearly, then decide which traffic is worth keeping on metered APIs and which must become operable system capabilities. Only then does market share have a chance to become profit.
