The Inference Economics Behind LLM Pricing Shifts: From Token Price to Task Cost

1. A Counterintuitive Pricing Phenomenon

A new version of an open-source large model recently published its official pricing: 20 yuan per million input tokens, 100 yuan per million output tokens, and 1 yuan per million cached tokens. Compared with the previous generation, the output-side price has increased fivefold. Against the backdrop of domestic models generally pursuing a “low price, easy to use” strategy, this number is quite striking—even higher than the current promotional price of a comparable product from an international vendor.

If the discussion starts only from the intuition of “expensive or not,” it easily remains at the emotional level. But for developers and technical decision-makers, the real question worth asking is: Under what cost structure is this price reasonable? Which customers is it targeting? How long is its validity period?

To answer these three questions, we need to return to the fundamentals of inference economics.

2. The Center of Gravity of Inference Cost Has Shifted from Input to Output

In traditional understanding, the bulk of a large model’s cost lies on the input side—after all, long text means longer context, larger KV Cache, and heavier attention computation. But this understanding is outdated in the era of reasoning models.

The core characteristic of a reasoning model is: before giving the final answer, it first generates a large number of intermediate reasoning steps. These thinking tokens are all billed as output. This means:

actual bill = input tokens × input unit price + (visible output + hidden thinking) × output unit price

When a model is set to “always run at the highest thinking level,” its output-side token consumption may be several times or even dozens of times the visible answer. Thus the cost structure undergoes a qualitative change:

• Input side: one-time encoding, cost relatively predictable;
• Output side: token-by-token autoregressive generation, with unpredictable thinking depth, becoming the main variable of cost.

This explains a key phenomenon: the list price rises fivefold, but the actual bill may rise even more. Because the unit price increase and the rising share of thinking tokens are additive effects, not independent events.

3. Who Is Paying for Hundred-Yuan-Level Output? The Answer Is Not Chat

A price of 100 yuan per million output tokens is unaffordable for any individual user doing daily conversation. Estimating thousands of tokens per conversation, a single deep dialogue round could cost several yuan.

So who are the real customers? Agents—machine-to-machine (M2M) token consumption scenarios.

In an Agent workflow, a single task call may include:

• planning and reflection across multiple tool calls;
• self-verification of intermediate results;
• long-chain reasoning steps;
• formatted output of the final result.

Stacked together, a single task’s token consumption easily reaches tens of thousands or even hundreds of thousands. At this point, comparing token unit prices has lost meaning, and the buyer’s algorithm has switched to:

How much does each task cost?

This is a paradigm shift. Just as cloud computing evolved from “billing per virtual machine hour” to “billing per function call,” the pricing unit of large models is migrating from “per million tokens” to “per task.”

4. Per-Task Pricing: The Relativity of Expensive and Inexpensive

Suppose one model averages $0.94 to complete a standard Agent task, another $1.04, and a third $1.88. On this dimension, the first model is not expensive—it is even in the mid-to-low range.

But if the comparison scope is narrowed to within the open-weight camp, the conclusion reverses sharply:

• For the same task, one competitor needs only $0.32;
• Another competitor is as low as 4 cents;
• Still another vendor has set a permanent price of 3 yuan input and 6 yuan output, while the model under discussion has an output list price more than 16 times that.

The same price yields diametrically opposite conclusions under different reference frames. This is exactly the most confusing part of pricing discussions—people often unconsciously switch reference frames while believing they are discussing the same question.

Therefore, when evaluating model costs, three things must first be clarified:

1. Unit of measurement: per million tokens, or per task?
2. Reference camp: closed-source flagship, or open weights?
3. Usage scenario: conversational interaction, or Agent automation?

5. Open Source + High Price: An Unprecedented Combination

In the history of global models, “open weights” and “high price” have almost never appeared simultaneously. Open source usually means price competition, commoditization, and profits approaching zero. But this time, the logic has been interrupted.

The strategy can be summarized as: before the weights are commoditized, stake a number on the model’s value first.

The official list-price window may last only about ten days. Once the weights are released, third-party inference providers will immediately list them at low prices. By then the market will be full of cheap instances of the same model, while the official list price still stands there. Its function is no longer the actual transaction price, but a value anchor:

When you see a price of 30 yuan on a third-party platform, your first reaction is “what a bargain,” because the official price says it is worth 100.

This is narrative pricing, not cost-based pricing. It does not reflect the true marginal cost of inference, but rather the model provider’s valuation claim about its own intelligence level.

6. How Developers Should Respond to This Pricing Strategy

Facing this “official high price + third-party low price” landscape, developers’ cost-optimization strategies need layered design:

Layer 1: Short term (within the window)

• Watch for the weights release timing and assess the listing pace of third-party inference services in advance;
• For cost-sensitive scenarios, avoid large-scale calls during the official high-price period;
• Build task-level cost monitoring, not just token unit price monitoring.

Layer 2: Medium term (after weights are commoditized)

• Compare same-model quotes from multiple inference providers and establish a dynamic selection mechanism;
• Evaluate the feasibility of self-hosted inference, especially for high-frequency, stable task loads;
• Abstract model calls into replaceable interfaces to reduce single-vendor lock-in risk.

Layer 3: Long term (architectural level)

• Route by task complexity: use small models for simple tasks, and call high-cost models only for complex tasks;
• Introduce caching and result reuse to reduce repeated inference overhead;
• Set token budgets for Agent workflows to avoid infinite thinking loops.

# Illustrative: pseudocode for routing by task complexity
def route_task(task):
    complexity = estimate_complexity(task)
    if complexity < THRESHOLD_LOW:
        return call_model("small", task)
    elif complexity < THRESHOLD_HIGH:
        return call_model("medium", task)
    else:
        return call_model("flagship", task, budget=MAX_TOKENS)

7. Conclusion: Pricing Is a Valuation Claim, Not a Cost Report

Back to the original question: is 100 yuan per million output tokens expensive?

For chat scenarios, too expensive to be sustainable; for Agent scenarios, it depends on task cost; for the open-weight camp, absurdly expensive; for the closed-source flagship camp, it is in the same range.

But more important than “expensive or not” is understanding the nature of this pricing: it is a narrative price, the model provider’s valuation claim about its own intelligence level, and a value anchor staked before the weights are commoditized.

For developers, rather than arguing about whether the price is high or low, it is better to build your own cost-evaluation framework:

• Clarify the unit of measurement;
• Lock in the reference camp;
• Budget by task rather than by token;
• Keep architecture flexible during the weights-commoditization window.

Models will iterate and prices will fluctuate, but the underlying logic of inference economics—cost center of gravity on the output side, pricing paradigm migrating toward tasks, open weights eventually commoditized—these structural trends will not change easily. Understanding them is more valuable in the long run than remembering any specific number.