China’s LLMs: Closing the Gap from Token Share to Value Share

1. The Structural Mismatch Behind Two Sets of Numbers

Recently, a third-party evaluation organization updated its composite intelligence index, introducing more private evaluation sets and real-world task scenarios. Top closed-source models led by a clear margin, Chinese models followed closely behind, and lightweight models with open weights occupied the mid-tier. Almost simultaneously, the IPO filings of a leading overseas lab revealed order-of-magnitude revenue growth during the reporting period, alongside soaring compute and infrastructure expenditures. Together, these two data points sketch a picture of overseas leaders building next-stage competitive moats through a flywheel of “technology–capital–compute–enterprise customer revenue.”

But another set of data presents a completely different picture. According to statistics from a model aggregation platform, within a roughly one-month window, Chinese models contributed about 65% of the platform’s token usage but accounted for only 29% of priced spend. Overseas models contributed roughly 25% of tokens but corresponded to 61% of spend. At the individual vendor level, one Chinese model supplied about 32% of tokens while corresponding to just 6% of spend; one overseas model, with only 7% of token usage, corresponded to 40% of spend.

The essence of these numbers is a severe divergence between call-volume share and value share. It is neither a simple case of “Chinese models aren’t good enough” nor “Chinese models have already won,” but rather a precise cross-section of an industry stage: Chinese models have captured “volume” through extremely high cost-effectiveness, but have not yet achieved parity in “value density per token.”

2. Understanding “High Volume, Low Price”: Three Explanations and Their Boundaries

Explanation 1: Price-War-Driven Share Expansion

The most intuitive explanation is pricing strategy. Chinese models generally adopt aggressive low-price strategies, with some even offering substantial free quotas, directly depressing the unit token list price. Under the aggregation platform’s “priced spend” methodology, low unit prices naturally correspond to low spend share. This explanation holds, but it only explains “why spend is low”—not “why usage is high.”

Explanation 2: Task Structure Differences Leading to Value Stratification

More noteworthy is task structure. High-frequency, low-value tasks—such as batch text cleaning, simple classification, format conversion, and conversation summarization—impose low demands on model capability but are extremely cost-sensitive, and this traffic naturally flows to low-price models. Meanwhile, high-value tasks like complex reasoning, long-chain agent workflows, and high-reliability code generation remain concentrated on more capable models. In other words, the distribution of token usage reflects task distribution, while spend share reflects task value distribution. Chinese models have largely captured the former.

Explanation 3: The Gap Between Benchmark Scores and Production Trustworthiness

Evaluations like composite intelligence indices measure a model’s capability ceiling on standardized tasks. But when enterprise customers select models, they look beyond scores to a whole set of “production trustworthiness” factors: stability, controllability, data compliance, service responsiveness, and ecosystem toolchains. Overseas leading models have accumulated more experience on these dimensions, so even with higher per-token prices, enterprises are still willing to pay a premium for “certainty.” This is the deeper reason for the value-share gap.

These three explanations are not mutually exclusive but progressively layered: price wars are the surface, task structure is the mechanism, and production trustworthiness is the root cause.

3. The Overlooked Risk: Three Hidden Costs of Trading Low Prices for Volume

Low-price strategies are not without cost. For Chinese model vendors, there are at least three hidden costs.

First, the mismatch between compute costs and revenue. Referencing data from leading overseas labs, compute and infrastructure expenditures account for an extremely high proportion of revenue. For Chinese models with lower unit prices and smaller spend share, maintaining competitiveness means compute investment cannot be proportionally reduced—training, inference, evaluation, and safety alignment all require sustained investment. The larger the volume, the greater the inference-side compute overhead, while unit revenue is lower, making the scissors gap more pronounced.

Second, ecosystem-building investment gets squeezed. What enterprise customers need is not a single model but a toolchain around it: fine-tuning capabilities, evaluation systems, observability, permissions and auditing, and cost governance. These all require long-term investment. Price competition compresses the space for this investment, creating the awkward situation of “models that run but engineering that struggles to land.”

Third, brand perception becomes locked in. Once “low price” becomes the primary label, breaking into high-value tasks encounters pricing anchor effects. Customers will ask: if the cheap one can also do it, why pay for the expensive one? Answering this question requires a generational capability gap, not minor price adjustments.

4. The Underestimated Opportunity: Three Opening Windows

Opportunity 1: Deployment Freedom from Open Weights

Models with open weights may be mid-tier on composite indices, but their strategic value lies not in scores but in deployability. Enterprises can deploy on their own infrastructure, achieving data that never leaves the domain, controllable inference costs, and lockable versions. For heavily regulated industries like finance, government, and healthcare, this freedom is difficult for closed-source APIs to replace. Fine-tuning, distillation, quantization, and inference optimization around open weights constitute a vast engineering practice space in themselves.

Opportunity 2: Scalable Deployment in High-Cost-Effectiveness Scenarios

Low price is not a disadvantage but a core competitive strength in specific scenarios. In high-frequency, low-value tasks like document processing, content moderation, customer service assistance, and log analysis, Chinese models already offer “good enough and cheap” advantages. These scenarios are characterized by high volume, high fault tolerance, and grayscale rollout capability. Doing them well accumulates real call data and engineering experience, providing ammunition for upward breakthroughs.

Opportunity 3: Value Migration from “Model” to “Model + Engineering”

A large portion of the value-share gap lies not in the models themselves but in engineering support. Whoever can turn evaluation, fine-tuning, inference acceleration, cost governance, and observability into a reusable set of capabilities can convert “cheap tokens” into “trustworthy productivity.” This is a path that does not rely on simply stacking parameters, and it is where developers can contribute most.

5. Engineering Path: Converting Cost Advantage into Value Advantage

Here is an actionable engineering path, organized into four layers.

5.1 Task Tiering: Understand Your Traffic Structure First

Before any optimization, tier your existing calls by task. A simple approach is to label along two dimensions: “value density” and “fault tolerance”:

# Task tiering illustration (pseudocode)
tasks = load_call_logs()
def classify(task):
    value = estimate_business_value(task)   # Business value: high/medium/low
    tolerance = estimate_error_tolerance(task)  # Fault tolerance: high/medium/low
    complexity = estimate_reasoning_depth(task) # Reasoning depth
    return (value, tolerance, complexity)
tiers = group_by(tasks, classify)
# Typical output:
# tier_A: high value + low tolerance + high complexity  -> prioritize strongest model
# tier_B: medium value + medium tolerance + medium complexity  -> cost-effective model + human fallback
# tier_C: low value + high tolerance + low complexity  -> low-price model or small model

The point of tiering is: don’t use one model for everything. Reserve high-price tasks for high-price models and route low-price tasks to low-price models. The overall spend structure will improve significantly, while avoiding “sacrificing critical task quality to save money.”

5.2 Routing and Degradation: Automatically Match Calls to Models

Dynamic routing at the gateway layer is the core mechanism for cost governance. Routing strategy can be based on three signals: task tier, real-time load, and budget level:

def route(request):
    tier = classify(request)
    if tier == "A":
        return call_strong_model(request)
    if tier == "B":
        # Try cost-effective model first; escalate on failure or low confidence
        resp = call_cost_effective_model(request)
        if resp.confidence < THRESHOLD:
            return call_strong_model(request)
        return resp
    return call_cheap_model(request)

Supporting degradation and retry strategies are essential: timeout degradation, rate-limit degradation, budget-exhaustion degradation. Degradation is not failure—it is directing limited budget where it matters most.

5.3 Caching and Reuse: Eliminate Duplicate Tokens

Many enterprise calls involve repeated or highly similar questions. Semantic caching can significantly reduce actual token consumption:

def handle(request):
    key = semantic_hash(request.prompt)
    cached = cache.get(key)
    if cached and cached.similarity > 0.95:
        return cached.response
    resp = route(request)
    cache.set(key, resp)
    return resp

Additionally, prompt reuse, system prompt compression, and structured output constraints can all reduce tokens without sacrificing quality.

5.4 Evaluation and Observability: Prove “Worth the Price” with Data

To break upward in value share, you must be able to demonstrate capability. Build internal evaluation sets covering real business tasks, continuously tracking quality, latency, and cost:

metrics = {
    "quality": eval_on_internal_set(model, golden_set),
    "latency_p95": measure_latency(model, traffic_sample),
    "cost_per_task": total_cost / task_count,
}

Observability must extend to every call: record model version, input length, output length, latency, whether degraded, and user feedback. These data serve both as the basis for cost governance and as evidence to prove to business stakeholders that “expensive has its reasons.”

6. Enterprise Selection Advice: Four Questions to Determine Strategy

Facing the “high volume, low price” landscape, enterprise model selection can ask four questions:

1. How high is the task value? For high-value, low-tolerance tasks, prioritize capability ceiling and stability; price is secondary.
2. Can data leave the domain? For scenarios where it cannot, prioritize open-weight models that support private deployment.
3. What is the call volume? For high-volume, simple tasks, low-price models plus caching and routing are the right answer.
4. Is engineering support in place? Without evaluation, routing, and observability capabilities, even the cheapest model is hard to convert into productivity.

These four questions have no standard answers, but they help teams avoid two extremes: blindly pursuing the strongest model leading to runaway costs, and low-price-only thinking leading to quality collapse on critical tasks.

7. Conclusion: The Share Battle Will Ultimately Return to a Value Battle

Chinese models capturing 65% of token usage is a genuine milestone, demonstrating that they have established a firm footing on both “usable” and “affordable” dimensions. But the 29% spend share reminds us that call-volume share does not equal industry influence—value share does.

Closing this gap requires neither simply raising prices nor continuing to pile on low prices, but filling in engineering capabilities: task tiering, dynamic routing, caching and reuse, internal evaluation, and observability. This work is not glamorous, but it determines whether cheap tokens can become trustworthy productivity. For developers and enterprises alike, this is both the most pragmatic optimization space today and the necessary path for Chinese models to move from “volume” to “value.”