Chinese Open-Source Models Capture Nearly 90% of Overseas Enterprise Open-Source Spending
Chinese open-source model families now absorb nearly 90% of overseas enterprises' open-source model spending, even as their share of token consumption nearly doubles while their share of revenue falls. This article explains the underlying "consumption-revenue scissors gap," clarifies four metrics that are easy to conflate, and walks through five commercialization paths — from tiered pricing and capability packs to on-premise deployment, dual-track licensing, and industry solutions. It also covers engineering practices for lowering inference cost: continuous batching, paged KV cache management, prefix caching, quantization, capacity planning, observability, and application-layer tiered routing (with runnable Python code). Practical checklists and an FAQ help developers and decision-makers turn market share into sustainable task value.
Introduction: Rising Share, Falling Unit Price
Open-source large language models have grown from a “cost-effective substitute” into a core component of enterprise AI infrastructure. According to the cited source, roughly 89% of overseas enterprises’ open-source model spending flows to Chinese model families, with the single leading family accounting for about 61%. Meanwhile, the share of open-source models in enterprise token consumption rose from about 11% to 19%, while their share of spending fell from about 6% to 4%. Consumption nearly doubled while revenue share declined — a classic “consumption-revenue scissors gap.”
A special note: because the source material provides no traceable link, this article treats the ratios above as illustrative trend data rather than precise statistics. Before citing them formally, verify the public reports — for example, the sampling period, scope, and methodology behind sources such as Stanford AI Index, Epoch AI, and Menlo Ventures Insight. Another key caveat: the 89% describes the internal structure of open-source model spending; it does not represent open-source models’ share of total enterprise AI spending.
1. Align the Metrics First: Don’t Mix Different Definitions
Before discussing open-source model cost, you need to separate four groups of metrics:
| Metric | Meaning | Notes |
|---|---|---|
| Token consumption share | Open-source model tokens / total tokens across all models | Reflects usage, not revenue |
| Enterprise AI spending | Total spend on AI services | Largest denominator, broadest scope |
| Open-source model spending | Spending flowing to open-source models | What the 89% measures |
| Chinese model spending | The portion of open-source spending flowing to Chinese models | Internal structure of open-source spending, not total AI spending |
Only by separating “token usage,” “total AI spending,” “open-source model spending,” and “Chinese model spending” can you understand why rising usage and falling revenue can occur at the same time.
2. Three Structural Shifts: Open-Source Models Are Now Production-Normal
1. Adoption Is Outpacing Monetization
Reading by the original definitions, nearly 1 in every 5 tokens consumed comes from open-source models; but of every 25 CNY an enterprise spends on AI, only about 1 CNY flows to open-source models. This shows open-source models have entered production in large volume, but per-request value, pricing models, and commercial packaging have not fully caught up.
2. Highly Concentrated Share
The draft notes that the top two model families together account for about three-quarters of overseas enterprises’ open-source model spending. This should be labeled a trend observation, as it lacks a specific report source and sampling period. Still, we can judge that a clear Matthew effect exists in the open-source model market: model capability, ecosystem compatibility, community activity, and deployment experience will keep amplifying the leaders’ advantage.
3. Call Popularity Is Migrating
The draft claims the leading open-source models reach weekly token call volumes in the trillions. Without a clear source, this figure should be treated as a trend observation, not a precise fact. Even without relying on that number, it is clear that open-source models are moving from “trial validation” to “stable invocation” — for example, web scraping, batch extraction, content classification, summary aggregation, ticket handling, and other agent-style tasks.
3. Three Causes of the Scissors Gap
Layer 1: Task Tiering Caps the Unit Price
Enterprise AI tasks are not homogeneous. A few leading closed-source models often handle complex reasoning, high-value generation, and critical business decisions; open-source models more often take on cost-sensitive tasks such as batch extraction, content cleaning, classification and tagging, summary aggregation, and rule-based review. These tasks are characterized by:
- Per-request token consumption may be large;
- They can run at scale in parallel;
- Latency and fault-tolerance requirements are relatively relaxed;
- Business value comes more from “replacing human labor” than from “directly creating high premiums.”
So even as call volume rises, the per-token price need not rise. What customers are willing to pay depends on how much cost the task saves and how much efficiency it improves — not the token count itself.
Layer 2: Open Weights Lead to Homogeneous Competition
Once an open-source model releases its weights, the same set of weights can be hosted on multiple platforms. Basic token-invocation capability quickly converges, differences are erased, and prices keep converging toward inference cost. This is not the problem of any single vendor but an inevitable result of the open-source model. A vendor that only sells a basic API falls into low-margin competition; to raise revenue, it must shift value from “the model interface” to “task delivery.”
Layer 3: Misaligned Measurement Definitions
“Pay per token” is not the only billing method. Revenue from subscription plans, annual or bulk packages, on-premise licensing, industry solutions, operations services, fine-tuning and evaluation, and agent orchestration is not necessarily reflected in the per-token price. If you measure commercial performance only by token call volume, you will systematically underestimate open-source models’ real revenue capability.
4. Five Commercialization Paths: From Selling Tokens to Selling Task Value
Path 1: Tiered and Differentiated Pricing
Basic calls can be cheap, but high-value tasks should be priced separately. Recommended task tiers:
- Batch standardized tasks: e.g., extraction, classification, tagging — use tiered pricing or volume discounts;
- High-value generation tasks: e.g., complex document analysis, code generation, contract review — use higher unit prices;
- Multi-tier model services: sell lightweight, standard, and high-capability models in combination so customers can choose by scenario.
Cost example: suppose a batch extraction task has a small-model input price of 0.002 CNY per 1K tokens and an output price of 0.004 CNY per 1K tokens, averaging 500 input tokens and 300 output tokens per task. The per-task cost is:
0.002 × 0.5 + 0.004 × 0.3 = 0.0022 CNY/task.
If the task saves the customer 0.05 CNY/task in manual review cost, inference cost is only about 4.4% of the value saved, leaving ample pricing room.
Path 2: From “Model as API” to “Model as Capability Pack”
When basic APIs become homogeneous, value migrates to the surrounding layer. Common capability packs include:
- Integrated RAG service: retrieval, chunking, vectorization, reranking, and generation delivered as a bundle;
- Agent workflows: tool invocation, multi-step planning, failure retry, and result validation;
- Fine-tuning and evaluation services: data governance, training, evaluation, and regression testing.
Pricing example: suppose a capability pack is priced at 2000 CNY per team per month. If underlying token cost is 10%–30% of revenue, the corresponding underlying cost is 200–600 CNY per team per month. The remainder comes from software, workflows, stability, and service premiums. This ratio is an illustrative assumption; actual figures must be calculated by call volume, cache hit rate, and manual service cost.
Path 3: On-Premise and Hybrid Deployment
Industries such as finance, healthcare, and government have strict requirements on data egress, making on-premise deployment an important direction. Common forms include:
- Private cloud deployment: vendor-hosted, with resource isolation;
- Customer on-premise deployment: model and inference framework delivered to the customer’s data center;
- Hybrid mode: sensitive data inferred locally, elastic traffic sent to the cloud.
Pricing example: an on-premise project can use “a one-time license fee of 300,000–1,000,000 CNY per project + an annual service fee of 15%–20% of the license fee per year.” For example, with a 500,000 CNY/project license fee, the annual service fee is 75,000–100,000 CNY/year. The license fee can cover delivery, adaptation, and basic operations costs, so falling token prices have relatively limited impact on it.
Path 4: Dual-Track Open-Source Ecosystem and Commercial Licensing
Open weights are a customer-acquisition tool, but commercialization requires balancing openness and protection. Common practices:
- Keep core weights open to grow the community and ecosystem;
- License enhanced editions, enterprise security, compliance auditing, and high-availability operations separately;
- Use permissive licenses to drive adoption and enterprise licenses to meet commercial distribution needs.
This is also a key reason the leading open-source model families quickly accumulated high share: openness lowers the adoption barrier while commercial licensing captures paying demand.
Path 5: Industry Packaging and Solutions
Embedding the model into specific industry workflows — for example contract review, ticket classification, marketing copy, QA reports, and customer-service assistance — converts one-time token calls into recurring subscription revenue. Revenue sources can include software licensing, implementation services, operations support, and industry adaptation.
| Commercialization Path | Revenue Form | Technical Focus | Suitable Stage |
|---|---|---|---|
| Tiered and differentiated pricing | Usage-based billing, volume discounts | Multi-tier models, batch inference optimization | Scaling invocation |
| Capability packs | Subscription, feature-based billing | RAG, agent orchestration, fine-tuning and evaluation | Platformization |
| On-premise and hybrid deployment | License fee plus service fee | Resource isolation, offline inference, version management | Strict-compliance industries |
| Dual-track licensing | Ecosystem license, enterprise license | License management, commercial-edition feature gating | Ecosystem expansion |
| Industry solutions | Software and implementation subscriptions | Industry data, domain adaptation, delivery systems | Vertical deepening |
5. Engineering Perspective: Inference Cost Reduction and Stability Optimization
Regardless of which commercial path is chosen, inference-side cost efficiency is the common foundation. The optimization directions below need to be validated by load-testing your own workloads; gains vary significantly across model sizes, hardware configurations, and concurrency scenarios.
1. Inference Service Optimization
- Continuous batching: replace static batching with iteration-level scheduling so new requests can join the current batch, improving GPU utilization.
- Paged KV cache management: borrowing the idea of OS virtual memory, manage the KV cache in blocks to reduce memory fragmentation.
- Prefix cache reuse: system prompts, few-shot examples, and repeated long-document fragments can reuse already-computed prefixes.
- Quantization and speculative decoding: INT8/INT4 quantization reduces memory and bandwidth pressure; speculative decoding uses a small model to predict multiple tokens for parallel verification by the large model.
2. Scheduling and Capacity Planning
- Pool interactive requests and offline batch jobs separately to avoid batch tasks slowing down online business;
- Scale elastically based on queue length, GPU utilization, and P95 latency;
- Deploy multiple replicas with health checks, timeout retries, and degradation/circuit-breaking.
Example baseline: for interactive workloads, start with P95 latency below 800 ms, GPU utilization between 60%–80%, and cache hit rate above 30%. These numbers are not universal standards; they must be calibrated by load-testing against model size, hardware, and business SLOs.
3. Observability and Cost Accounting
Recommend recording each call’s model, input/output tokens, cache hits, latency, and cost. Key metrics include:
- Time to first token (TTFT);
- Per-token generation latency;
- End-to-end latency;
- Throughput;
- Cache hit rate;
- Cost per task.
Also set token quotas and cost caps by tenant and project, with automatic degradation or circuit-breaking when exceeded.
4. Application-Layer Tiered Routing
Send simple tasks to small models and escalate complex ones to large models; pure format conversion and fixed-template filling can be handled locally; high-frequency repeated questions can use semantic-level caching. Below is a reproducible code example. The runtime is Python 3.10+. The code standardizes prices to “CNY per 1K tokens” and divides by 1000 in the cost formula; it also performs a budget check before the model call, degrading or rejecting the request when the limit is exceeded.
# Runtime: Python 3.10+from dataclasses import dataclassPRICE_IN = {"small": 0.001, "large": 0.01} # CNY per 1K input tokensPRICE_OUT = {"small": 0.002, "large": 0.03} # CNY per 1K output tokensCONFIDENCE_THRESHOLD = 0.85@dataclassclass Usage:# In a real implementation, usage should contain at least these fieldsprompt_tokens: intcompletion_tokens: inttotal_tokens: inttenant: str@dataclassclass ChatResponse:# The object returned by ModelClient.chat must contain content, confidence, and usagecontent: strconfidence: floatusage: Usagedef local_transform(task: dict) -> dict:"""Pure local format conversion, no model call"""return task["data"]def build_prompt(task: dict) -> str:"""Assemble the task into model input"""return task["prompt"]def estimate_tokens(prompt: str, max_output_tokens: int) -> int:"""Rough token estimate; in production, replace with a real tokenizer count"""return max(1, len(prompt) // 4) + max_output_tokensclass ModelClient:def __init__(self, endpoint):self.endpoint = endpointdef chat(self, prompt: str, max_output_tokens: int, tenant: str) -> ChatResponse:# Real implementation: call the model service and return a ChatResponse# The returned object must contain content, confidence, and usageraise NotImplementedErrorclass MockModelClient(ModelClient):"""Minimal implementation used only to reproduce the layered-routing logic"""def __init__(self, name):super().__init__(f"mock://{name}")self.name = namedef chat(self, prompt, max_output_tokens, tenant):if self.name == "small":confidence = 0.9 if ("classify" in prompt or "extract" in prompt) else 0.6content = f"small result for: {prompt[:32]}"else:confidence = 0.97content = f"large result for: {prompt[:32]}"prompt_tokens = max(1, len(prompt) // 4)completion_tokens = min(max_output_tokens, max(1, len(content) // 4))return ChatResponse(content=content,confidence=confidence,usage=Usage(prompt_tokens=prompt_tokens,completion_tokens=completion_tokens,total_tokens=prompt_tokens + completion_tokens,tenant=tenant))class BudgetGuard:def __init__(self, limits):self.limits = dict(limits)self.used = {}def _used(self, tenant):return self.used.get(tenant, 0)def can_consume(self, tenant, est_tokens):return self._used(tenant) + est_tokens <= self.limits.get(tenant, 0)def consume(self, tenant, est_tokens):# Budget check first: reserve the estimated tokens before the model callif not self.can_consume(tenant, est_tokens):raise RuntimeError("budget exceeded")self.used[tenant] = self._used(tenant) + est_tokensclass Metrics:def emit(self, name, value, tags):print(name, value, tags)small_model = MockModelClient("small")large_model = MockModelClient("large")budget_guard = BudgetGuard({"tenant-a": 100000})metrics = Metrics()def record_cost(call_id: str, source: str, usage: Usage) -> None:# Prices are in CNY per 1K tokens, so the formula must divide by 1000cost = (usage.prompt_tokens * PRICE_IN[source]+ usage.completion_tokens * PRICE_OUT[source]) / 1000metrics.emit("token_cost",cost,{"source": source, "call_id": call_id, "tenant": usage.tenant})def route_and_call(task: dict) -> dict:tenant = task["tenant"]# 1. Rule layer: pure format conversion / fixed templates handled locallyif task["type"] in ("format_convert", "template_fill"):return {"source": "local", "result": local_transform(task)}prompt = build_prompt(task)# 2. Lightweight model layer: check budget first, then callest_small = estimate_tokens(prompt, max_output_tokens=512)if not budget_guard.can_consume(tenant, est_small):return {"source": "budget_denied", "stage": "small", "result": None}budget_guard.consume(tenant, est_small)resp = small_model.chat(prompt, max_output_tokens=512, tenant=tenant)record_cost(task["id"], "small", resp.usage)if resp.confidence >= CONFIDENCE_THRESHOLD:return {"source": "small", "result": resp.content}# 3. Large model layer: check budget again before upgrading; fall back to the small result when exceededest_large = estimate_tokens(prompt, max_output_tokens=2048)if not budget_guard.can_consume(tenant, est_large):return {"source": "small_fallback","result": resp.content,"reason": "large budget exceeded"}budget_guard.consume(tenant, est_large)resp_large = large_model.chat(prompt, max_output_tokens=2048, tenant=tenant)record_cost(task["id"], "large", resp_large.usage)return {"source": "large", "result": resp_large.content}
The core points of this code are four. First, prices are in CNY per 1K tokens, so the cost calculation must divide by 1000. Second, the object returned by ModelClient.chat must contain content, confidence, and usage. Third, usage contains at least prompt_tokens, completion_tokens, total_tokens, and tenant. Fourth, the budget check must happen before the model call, rejecting or degrading directly when exceeded, to avoid producing the call first and deducting later.
6. Implementation Checklist
For Developers
- Establish task tiering: local processing, lightweight model, large model — three tiers, with defined escalation conditions.
- Set a unit-task cost baseline: use “cost per 1,000 business tasks completed” as a unified measure.
- Enable prefix caching and result caching to reuse system prompts and high-frequency Q&A.
- Constrain outputs structurally, such as with a JSON Schema, to reduce retry cost from parse failures.
- Complete capacity load-testing in a pre-production environment, confirming P95 latency and memory usage at peak QPS.
- Design a rollback mechanism: when a new model or new prompt behaves abnormally, switch back to the last stable version.
- Perform budget checks up front, automatically degrading or rejecting requests when exceeded.
For Enterprise Decision-Makers
- Evaluate closed-source and open-source options together during selection, using your own business samples for blind comparison.
- Establish cost allocation by team and project to avoid budget overruns.
- Prioritize on-premise or private cloud deployment for compliance-sensitive scenarios.
- Bring model versions into change management, completing accuracy, latency, and cost regression evaluations before upgrades.
- Pay attention to open-source model license terms; confirm boundaries for commercial use, distribution, sublicensing, and on-premise deployment.
7. FAQ: Common Questions
How do I choose an open-source model?
Use blind testing on your own business samples, focusing on unit-task cost, stability, structured-output capability, and engineering integration difficulty — not just parameter size or token price.
What are common cost-reduction mistakes?
Fixating only on token price, ignoring caching and routing, and using a single model for all tasks all lead to runaway costs. Effective cost reduction means tiering tasks, checking budgets up front, and building detailed observability.
What should I watch for in on-premise deployment?
Focus on hardware and inference-framework compatibility, version-upgrade paths, operational responsibility boundaries, license terms, and whether hybrid cloud is needed to handle elastic traffic.
How do I assess open-source model license and compliance risk?
Check four points: whether commercial use is allowed, whether distribution is allowed, whether sublicensing is allowed, and whether on-premise deployment is restricted. For enterprise scenarios, also retain the license text and version records to avoid future audit risk.
8. Conclusion
Chinese open-source models holding nearly 90% of overseas enterprises’ open-source model spending shows they have earned market recognition for engineering usability, deployment flexibility, and cost efficiency. But the scissors gap between token consumption and revenue reminds us: call volume is not revenue, and falling unit price is not falling value. The real turning point is shifting the business logic from “selling compute by token” to “delivering value by task.”
For developers, establish a unit-task cost baseline and keep reducing cost through inference optimization, tiered routing, upfront budget checks, and observability. For enterprises, treat open-source models as an orchestrable, measurable, replaceable infrastructure component rather than a one-time API purchase. Only by converting share into task value and call volume into recurring revenue can open-source models truly become a long-term pillar of enterprise AI infrastructure.
