Chinese LLM Pricing Shifts from Cost per Million Tokens to Cost per Task

1. The Signal: A Price Increase That Goes Against the Grain

When a Chinese model’s output price jumps several times over its predecessor — reaching the hundred-yuan-per-million-token range — the developer community’s first reaction is predictable: that’s expensive.

The reason is straightforward. Over the past two years, the dominant posture in China’s model market has been “cheap and capable.” Vendors priced far below their international counterparts to win API call volume and developer mindshare. Against that backdrop, a model that suddenly lists at international first-tier pricing shocks not only budgets, but also the default expectation that domestic models should be cheap.

But stopping at the emotional level of “prices went up” misses what makes this pricing move worth examining. Price is never just an arithmetic result of cost plus margin. It is also a signal: how a vendor evaluates its model’s capability, how it positions itself in the market, and which customers it intends to serve. Viewed within the technical evolution of reasoning models, this adjustment looks less like cost pass-through and more like a deliberate pricing narrative.

2. Pricing Alignment: Benchmarking Against Standard Pricing, Not Promotional Pricing

The first key to understanding this adjustment is the reference point it aligns with.

A common industry practice is to compare one’s own prices with the promotional prices of leading international vendors, making one’s offering appear cheaper by contrast. But promotions are operational tactics — limited-time discounts — whereas standard pricing reflects a vendor’s assessment of its model’s intelligence level. What makes this adjustment notable is that it aligns directly with the latter: the standard price tier that international vendors restore after promotions end, not the discounted rates currently in effect.

This reveals an easily overlooked fact: during a promotional window, calling this new model may actually cost more than calling an international model that is currently being discounted. From a pure cost-performance standpoint, that seems unwise. But from a signaling standpoint, the logic is internally consistent — promotional pricing is a business strategy; list price is a statement about model value. This move aligns with the latter.

It also marks a rare shift in posture for a Chinese model company: no longer positioning itself as the “close in capability, half the price” shadow option, but directly claiming parity at the price level. Whether the market accepts that claim is another question. What matters is that competition has moved from “who is cheaper” to “who dares to price themselves.”

3. Narrative Pricing: The Real Function of the List Price Is to Set an Anchor

The second key point: this hundred-yuan list price is very likely not a faithful reflection of cost.

An observable pattern in the open-weight ecosystem: once model weights are released, third-party inference providers quickly follow with the same model at significantly lower prices. If weights are published around late July, the official list price may enjoy true market exclusivity for only about ten days. After that, cheap inference services for the same model will flood the market.

So what role does the official list price still play? The answer: before the weights are fully commoditized, it sets a value anchor for the model.

This is a rather elegant market operation. When users see the same model on a third-party platform at one-third of the official price — or even lower — their first reaction is not “this third party is cheap.” It is “the official price says this is worth a hundred, and here it is at thirty. I’m getting a deal.” The official price becomes the anchor. The third-party price becomes the “discount.” User price perception is anchored by the official number, while actual transaction volume flows to cheaper distribution channels. The official list price’s function degrades from “revenue collection” to “pricing benchmark” — itself a new form of model commercialization in the open-weight era.

The combination of “open weights + high list price” has rarely been attempted in past model commercialization practice. The confidence to do so can only come from the model’s own benchmark scores. If the scores are high enough, the list price holds. If the list price holds, the anchor effect works.

4. The Cost Center Shifts: Why Reasoning Models Make You Pay More for Thinking

The third key point is the change in billing structure itself.

In the traditional chat model era, input and output pricing did not differ dramatically. The cost of a request was mainly determined by context length. But in the reasoning model era, the cost center has shifted from the input side to the output side. Before producing a final answer, the model generates a large volume of intermediate reasoning — and these reasoning tokens count toward output billing. The longer the model “thinks,” the faster the bill grows.

The model behind this price adjustment initially offered only the highest-intensity reasoning tier, with all reasoning tokens billed as output. This creates an underappreciated consequence: the list price rose several times over, but the actual bill rises even more. Because while the unit price increases, the composition of billed tokens also tilts toward the more expensive side.

For pure chat scenarios, this price is indeed hard to justify — no one uses a model costing a hundred yuan per million output tokens for casual conversation. But that is exactly the point: the target customer for this pricing was never chat users. It is agents — machine-to-machine token consumption. A single agent task can generate tens of thousands or even hundreds of thousands of output tokens across reasoning and tool-call traces. Unit price multiplied by large token volume is the real shape of the bill.

5. The Unit of Measurement Shifts: From Cost per Million Tokens to Cost per Task

When the customer becomes an agent, the buyer’s calculation changes too. Nobody compares token-by-token anymore. Everyone calculates cost per task.

Under task-based pricing, the conclusion may be completely different. Suppose a given reasoning model’s average cost to complete a typical task is around one US dollar — roughly the same tier as leading international flagship reasoning models, and about half the cost of the most expensive top-tier models. In that coordinate system, it is not expensive. It may even be reasonable.

But switch coordinate systems, and the conclusion inverts. Within the open-weight camp, the same task may cost thirty cents with one model and just a few cents with another. When a vendor permanently lowers its flagship model’s output price to single-digit yuan per million tokens, a hundred-yuan output price is more than ten times higher.

This illustrates a simple point: “expensive or not” has no absolute answer — only a question of reference frame. For users of closed-source flagship models, task-based pricing may look reasonable. For developers accustomed to the low-cost open-weight ecosystem, it is significantly more expensive. Model selection must begin by clarifying which reference frame you are operating in.

6. Practical Guidance for Developers

Faced with this pricing strategy divergence, teams should build their own evaluation framework rather than being led by unit price numbers.

First, build a task-level cost model. Do not make decisions based on per-million-token unit prices. Instead, sample real business tasks and measure average input tokens, average output tokens (including reasoning tokens), and average task duration. Calculate cost per task. A sample evaluation script structure:

def cost_per_task(tasks, price_in, price_out):
    total = 0.0
    for t in tasks:
        in_tokens = count_tokens(t.prompt)
        out_tokens = count_tokens(t.response) + count_tokens(t.reasoning)
        total += in_tokens / 1e6 * price_in + out_tokens / 1e6 * price_out
    return total / len(tasks)

Note that the reasoning field must be included — it is the most commonly overlooked cost item in the reasoning model era.

Second, distinguish reasoning tiers by task type. High-intensity reasoning suits complex inference and multi-step tool calls. Simple classification, extraction, and format conversion tasks should be routed to lower reasoning tiers or smaller models. Running all tasks through a single tier is the most common cause of runaway bills.

Third, separate official list price from actual transaction price. In the open-weight ecosystem, the same model may be available from multiple inference service providers at significantly different prices. When selecting a provider, evaluate inference service stability, latency, context length support, and price — do not assume the official channel is automatically optimal. The official list price is better treated as a capability reference anchor than as the sole procurement basis.

Fourth, pay attention to billing detail differences. Cache-hit pricing, whether reasoning tokens are billed, volume discount rules, and tiered pricing for extended context — these differences get amplified into order-of-magnitude cost variations under high-frequency agent workloads.

7. Conclusion

This price increase is, at its core, an experiment in how model value gets measured. It pushes the industry conversation from “how much per million tokens” to “how much per task,” and from “who is cheaper” to “who dares to price themselves.”

For developers, the important thing is not an emotional reaction to a price number. It is understanding the billing structure change behind the price, and building cost evaluation capabilities based on task units and real business sampling. In an era where model capabilities converge rapidly and inference costs continue shifting toward the output side, teams that can do task-level cost accounting are the ones that truly hold the initiative in model selection.