A Fivefold Price Hike to $14 per Million Output Tokens: What It Signals About AI Model Pricing Logic

1. A Rare Case of “Reverse Pricing”

For the past two years, the dominant theme in China’s LLM API market has been price cuts. The cost of one million tokens fell from tens of yuan to just a few yuan, or even less than one yuan. Cheap and good enough became the default label for domestic models.

Against that backdrop, a leading vendor’s newly released flagship model went in the opposite direction. Its API list price is roughly five times higher than the previous generation: 100 yuan per million output tokens, 20 yuan per million input tokens, and 1 yuan per million tokens for cache hits.

Even more striking is the reference point. The pricing is almost identical to the standard pricing of a top international closed-source model. The message is explicit: the vendor is publicly claiming that its capability is worth this price. For users accustomed to a low-price mindset, this is a significant shock.

2. Pricing as Valuation: Distinguishing Discounts from List Prices

To understand this move, it helps to separate two concepts:

• Discount: a short-term operating tactic for customer acquisition, competition, and cash flow.
• List price: a long-term value statement about the product’s intelligence level.

A telling detail is that the international model being benchmarked is still in a promotional period, meaning its effective price is lower than its standard list price. The Chinese model chose to align with the standard price, not the promotional one. As a result, calling this Chinese model can currently cost more than calling the benchmark model directly at its promotional rate.

The logic can be summarized in one sentence: “Your discount is your operating tactic. Your list price is your valuation of your own intelligence. I am matching the latter.”

Whatever one thinks of the choice, this is the first time a domestic model vendor has refused to be priced in the shadow of international leaders. Instead of defaulting to being cheaper, it has pinned its price at the same level and declined to follow the passive price war.

3. Narrative Pricing vs. Cost-Based Pricing: Racing Against Commoditization

The most intriguing part is that this model has open weights, and the vendor has already published a timeline for releasing them.

What does open weights mean? Once the weights are released, many third-party inference providers—who often have lower compute costs and more aggressive margin expectations—will quickly offer the same model at much lower prices. Based on the official timeline, the vendor’s exclusive pricing window may last only about ten days.

So what is the point of an official list price that will inevitably be surrounded by cheaper alternatives? The answer: it stamps a number on the model’s value before others can define it. Behavioral economics calls this anchoring. When you later see the same model at 70% off on a third-party platform, your first reaction will likely be “what a deal,” because the official price already told you it is worth 100 yuan per million output tokens.

At that moment, the official list price is not primarily a sales tool. It is a narrative tool.

The combination of open weights and a high official list price is highly unusual in the global LLM landscape. The conventional view is that open weights means trading revenue for ecosystem adoption, while closed-source APIs justify commercial pricing. That said, this strategy only works if the model can back it up—and in this case, its benchmark results do place it among the global top tier.

4. In the Reasoning Model Era, Costs Shift from Input to Output

A fivefold increase in list price often translates into an even larger increase in actual bills. The reason is that reasoning models have a fundamentally different cost structure:

• Traditional dense models incur most of their cost on the input side: long contexts, long system prompts, and large volumes of history all happen at input time.
• Reasoning models incur most of their cost on the output side: the model generates a large number of “thinking tokens,” and reasoning is almost always billed as output.

At launch, this model even offered only its highest reasoning setting—meaning it was configured to always think at maximum depth.

Now stack three facts together:

1. Output unit price has risen to 100 yuan per million tokens.
2. All reasoning tokens count as billable output.
3. The model is fixed at the strongest reasoning level.

The conclusion: the more the model thinks, the more you pay—and this model is designed to think as much as possible. This price structure naturally excludes casual human chat scenarios. Nobody chats at 100 yuan per million output tokens. The realistic customer profile is only one: agents—machines consuming tokens on behalf of other machines. In an agent workflow, a call is not experienced as “chat.” It is experienced as a task deliverable and its corresponding cost.

5. The Billing Unit Is Shifting: From “Per Million Tokens” to “Per Task”

In the agent era, the unit of cost is moving from “price per million tokens” to “price per task.” Buyers now calculate differently: a single task may call a model dozens of times and consume hundreds of thousands of tokens, but users only care about two numbers—how much the task cost and how often it succeeded.

Through that lens, the picture changes. According to public third-party evaluation data, the average cost of completing a typical agent task with this model is around USD 0.90. That is in the same range as a leading international closed-source model and about half the cost of that vendor’s top flagship. In a per-task world, it is not expensive.

But when compared within the open-weight camp, the gap becomes obvious. Other open-weight models can complete the same task for around USD 0.30, or even a few cents. Even more striking is the pricing table: a competitor in the same open-weight category announced a permanent price cut in May to 6 yuan per million output tokens. This new flagship lists its output price at more than 16 times that figure.

For the first time, the open-weight camp has visible price stratification. Some players continue to play the role of “cost-performance disruptor.” Others are trying to sit at the same table as closed-source flagships.

6. What Developers and Enterprises Should Do: A Practical Cost Evaluation Framework

Whatever one thinks of this pricing experiment, what matters more for actual users is building a reliable cost accounting system.

6.1 Use List Prices for Worst-Case Estimates, and Benchmarks for Real Bills

List prices give you the upper bound. Real bills depend on task shape. Using the price structure from this article as an example (in yuan per million tokens), here is a simple estimation function:

def estimate_task_cost(
    input_tokens: int,
    output_tokens: int,
    cached_ratio: float = 0.0,
    pricing: dict = {"input": 20, "cached": 1, "output": 100},
) -> float:
    """Estimate the cost of a single call in yuan.
    output_tokens must include all reasoning tokens."""
    fresh = input_tokens * (1 - cached_ratio) / 1e6 * pricing["input"]
    cached = input_tokens * cached_ratio / 1e6 * pricing["cached"]
    out = output_tokens / 1e6 * pricing["output"]
    return round(fresh + cached + out, 4)
# Example: a medium-complexity agent task
# 80,000 input tokens (90% cache hit rate), 20,000 output tokens including reasoning
print(estimate_task_cost(80_000, 20_000, cached_ratio=0.9))
# ≈ 2.23 yuan, with output accounting for nearly 90% of the cost

This estimate reveals the core fact of the reasoning model era: the output side determines the bill. Any engineering method that reduces output length, including reasoning length, is the most direct form of cost optimization.

6.2 Treat Cache Hit Rate as a First-Class Metric

With input priced at 20 yuan and cache hits at 1 yuan per million tokens, the 20x gap means that cache design directly determines cost magnitude for agent workloads—which tend to be multi-turn, prefix-heavy, and template-driven.

Practical recommendations:

• Keep stable system prompts, tool definitions, and domain knowledge at the beginning of the prompt, byte-for-byte unchanged.
• Put dynamic parameters at the end of the prompt to maximize the cacheable prefix length.
• Monitor cache hit rate on an ongoing cost dashboard.

6.3 Establish a “Cost per Task” Baseline with a Fixed Task Set

Do not rely on price tables alone. Run a baseline using real business tasks: record average input, output, and reasoning tokens per task, plus success rate and manual review rate. Then compute a “cost per task” metric. When switching models, reasoning levels, or providers, rerun the baseline for an apples-to-apples comparison.

A model that is several times cheaper per token but causes a much higher retry rate is not necessarily more cost-effective.

6.4 Use Hybrid Routing: Different Tokens, Different Paths

Route high-difficulty planning, reasoning, and coding tasks to a flagship reasoning model. Send simple extraction, format conversion, and routing decisions to cheaper models. For latency-insensitive batch workloads at high volume, evaluate third-party inference services for open-weight models or self-hosted options.

Routing by task type at the model gateway has become standard engineering practice for agent platforms. In production, it is also worth using general-purpose model services, logging, and billing monitoring capabilities—such as those available through Baidu AI Cloud—to attribute token-level usage back to specific tasks and call chains. This helps prevent runaway reasoning from turning into runaway bills.

6.5 Set a Reasoning Budget

If the model provides reasoning intensity levels or output length limits, set an explicit budget on the engineering side. For long tasks, decomposing work into “short reasoning plus verifiable intermediate outputs” is more controllable—and cheaper—than letting the model run long reasoning chains unchecked.

7. Conclusion: Pricing Is Narrative, Cost Is Choice

This move to 100 yuan per million output tokens is really three actions in one.

Internally, it is a value statement about the vendor’s own capability. Externally, it is a price anchor stamped before the weights are commoditized. For customers, it is an explicit filter—shifting the intended audience from human conversation to machine consumption.

Whether it works depends on two variables. First, can the model’s capability really support the narrative of benchmarking against a top-tier closed-source model? Second, once the weights are open, can the official service hold its differentiation through stability, compliance, tooling, and SLAs amid a wave of cheaper third-party inference offerings?

For developers and enterprise users, taking sides matters less than adopting a method: build a task-level cost accounting system so every model selection decision is backed by numbers. In the reasoning model era, knowing how to count costs is itself an engineering capability.