How Reasoning Model Pricing Is Shifting: From “Most Expensive Open-Weight Model” to a New Billing Logic

An Unusual Price Adjustment

A reasoning model that supports long-context input, file understanding, content generation, and data analysis recently updated its official pricing: approximately ¥100 per million output tokens, ¥20 per million input tokens, and about ¥1 per million tokens for cache hits. Compared to its predecessor, the output price has increased roughly fivefold.

In the current domestic Chinese market, this number stands out. Over the past year or two, local model services have generally followed a “low price, good enough experience” approach, and user expectations have been trained to assume that large model calls should be cheap. When a ¥100-per-million-token output price suddenly appears, the instinctive reaction is often, “Why should this cost so much?”

But when placed in a global pricing context, the logic becomes clearer: the new pricing aligns with the standard price of leading overseas closed-source models after their promotional periods — around ¥20 for input and ¥100 for output per million tokens. In other words, the price setter is sending a clear signal: I believe my model’s intelligence is worth this standard price.

There is an easily overlooked detail here: the overseas model being referenced is still in its promotional period, so its actual charges are far below the standard price. That means, based on today’s actual bills, calling this domestic model could cost more than calling the overseas model. The pricing does not match the competitor’s discount price — it matches the price the competitor believes it should be worth.

That choice is telling. Discounts are operational tactics; pricing is a valuation of one’s own intelligence. Aligning with the latter reflects ambition — and it marks the first time a Chinese model company has refused to act as a shadow at the price level, declining to engage in an endless price war.

The ¥100 Price Is a Narrative Price, Not a Cost Price

It is important to recognize that the ¥100 output price is not a faithful reflection of cost. It functions more like a narrative price — its purpose is to set a value marker for the model before its weights become commoditized.

The logic chain is as follows:

1. Weights are opened first. Open weights mean that any third-party service provider with inference capability can obtain the weights, deploy them independently, and set its own pricing.
2. Low-priced third-party offerings will inevitably appear. Once weights are released, third-party inference providers will quickly offer similar services at lower prices. This is an inevitable outcome of an open-weight ecosystem.
3. The official price has a short effective window. From the release of weights to the proliferation of low-cost third-party services, there may only be a window of about ten days.
4. After the window, the official price becomes an anchor. When a marketplace fills with cheaper versions of the same model, the official ¥100 price remains standing. Its role shifts from an actual transaction price to a value anchor.

This creates a subtle psychological effect: when users see a third-party platform selling the same model at one-third the official price or less, the first reaction is not “That seems suspiciously cheap” but rather “I’m getting a bargain” — because the official price says the model is worth ¥100. This is the anchoring effect applied directly to model pricing.

The combination of “open weights plus a high official price” is rare in the global model landscape. It only works if the model’s benchmark scores are high enough to support the anchor. Without strong scores, the price looks ridiculous; with them, it becomes a successful value declaration.

Real Bill Increases Are Steeper Than the Sticker Price

The nominal price rose fivefold, but actual usage costs often increase even more. The reason lies in a structural shift in cost allocation for reasoning models.

In traditional model calls, the cost burden sits on the input side — you pay for how much context you feed in. Reasoning models, however, perform extensive internal deliberation before producing an answer, and that thinking process is typically billed as output tokens. This means:

• The more the model thinks, the more you pay.
• These models are often configured to “always think maximally,” with the highest reasoning depth enabled by default.
• If there is only one reasoning level available at launch, users have no option to reduce it.

The result is an awkward situation: using this model for everyday chat is nearly unaffordable. At ¥100 per million output tokens, casual conversation becomes a pure luxury expense.

So the real customers for this price point are not human conversational users but agent scenarios — machine-to-machine token consumption. In this context, buyers switch their calculations: no one asks “how much per million tokens” anymore. Instead, they ask, “how much per completed task.”

Task-Based Pricing: The Relativity of Expensive

Once you switch to a per-task measurement, the conclusion flips entirely.

To illustrate: suppose a reasoning model consumes an average of about $0.94 per typical agent task. That places it in the same tier as a mid-to-high-end overseas model (about $1.04 per task), and at roughly half the cost of a flagship overseas model (about $1.90 per task). In a per-task world, this price is not expensive.

But compare within the open-weight camp, and the picture changes again:

• A Chinese open-source model handling the same task type costs about $0.32.
• Another Chinese open-source model known for extreme low pricing costs about $0.04.
• The latter recently set its permanent price at roughly ¥3 for input and ¥6 for output per million tokens.

By that comparison, a ¥100 output price is more than sixteen times higher. That is where the “most expensive open-weight model” label comes from.

So “expensive” is never an absolute judgment. It depends on three things: who you compare against, what unit you use, and in what scenario.

Reference Point	Pricing Unit	Relative Position
Overseas leading closed-source model (standard price)	Per million tokens	Roughly aligned
Overseas leading closed-source model (promotional price)	Per million tokens	Actually more expensive
Overseas mid-to-high-end model	Per task	Same tier or slightly lower
Overseas flagship model	Per task	About half
Domestic low-priced open-source model	Per million tokens	Several to more than ten times higher

What This Means for Developers

Given this pricing strategy, developers and enterprise users should take several steps:

First, distinguish between “list price” and “actual transaction price.” The official price is an anchor, not what you must pay. Open weights mean you always have alternatives: third-party deployment, self-hosted inference, or hybrid routing. When budgeting, do not treat the official price as the only input.

Second, switch the billing unit from tokens to tasks. For agent-based applications, the per-token price has almost no decision value. What matters is: how many tokens does a complete business task consume on average, how much does that cost, and what is the success rate. Run a business-level benchmark during model selection instead of reading the price page.

Third, pay attention to output-side controllability. In reasoning models, the cost driver is the thinking process. If the service provider offers configurable thinking depth, thinking budget limits, or cache reuse mechanisms, actual costs can drop by an order of magnitude. Confirm whether these controls exist before committing.

Fourth, accept that “anchor pricing” is here to stay. As more high-performance open-weight models appear, the pattern of official high prices plus third-party low prices will repeat. Understanding this dynamic matters more than memorizing any specific number.

# Pseudo-code: evaluate cost per task, not per token
def cost_per_task(model, task_suite, avg_output_tokens, avg_input_tokens):
    input_cost = avg_input_tokens / 1_000_000 * model.input_price
    output_cost = avg_output_tokens / 1_000_000 * model.output_price
    return (input_cost + output_cost) / task_suite.success_rate
# Compare cost_per_task, not output_price

Conclusion

A single price adjustment looks like a numeric change on the surface, but underneath, three shifts are happening simultaneously: the cost center of reasoning models is moving from input to output; open weights are accelerating the divergence between list prices and transaction prices; and agent scenarios are shifting the billing unit from tokens to tasks.

The ¥100 output price is less about selling tokens and more about setting a value marker for the model. Ten days from now, cheaper versions of the same model will appear in the market, but the anchor will already be in place. For developers, the question is not whether it is expensive in absolute terms. It is this: in your own business scenario, how much does it actually cost to complete one task? That number is the only answer that matters.