The Shift in LLM Pricing Strategies: From Token-Based to Task-Based Valuation

From Price Wars to Value Anchoring: A Paradigm Shift in Pricing Logic

While the industry has been deeply entrenched in the mindset of acquiring users through aggressive low pricing, a recent pricing strategy announced for a new flagship Large Language Model (LLM) served as a wake-up call. The new API pricing sets the output cost at 100 RMB per million tokens, the input cost at 20 RMB, and the cache hit cost at just 1 RMB. Compared to the previous generation, the output price has increased fivefold. In a market saturated with price wars, this move stands out dramatically. However, if we only focus on the binary debate of whether it is “expensive” or “cheap,” we risk missing the deeper technical narrative and business model reconstruction behind this pricing revolution.

This is not a simple cost transfer, but a carefully designed “value anchoring” experiment. The signal is clear: in the second half of the generative AI era—where inference cost is the primary bottleneck—the traditional formula of metering by token is failing. It is being replaced by a cost-performance model based on task completion. For developers and enterprise architects, understanding this shift is far more meaningful than debating the absolute unit price.

The Cost Structure of Reasoning Models: Why the Output Side Has Become a “Gold Sink”

To understand this price increase, we must first look at the current trajectory of LLM technological evolution. New-generation models generally incorporate “Chain of Thought” (CoT) or similar long-range reasoning mechanisms. During the internal reasoning phase, the model must generate a large number of hidden reasoning tokens to break down the problem step-by-step, self-correct, and plan its approach. Although these tokens are not directly visible to the end-user, they still consume significant compute resources.

More critically, under standard API billing rules, this “thinking process” is classified as output tokens. This leads to a counterintuitive phenomenon: the more capable the model and the deeper it thinks, the larger the total output token volume, causing the actual cost of a single task to spike exponentially. The original pricing method—where input and output unit prices remain static—can no longer reflect the true ratio of resource consumption. Setting the output price at a premium of 100 RMB is essentially an acknowledgment of the physical reality that “intelligence is generated on the output side.” It no longer treats the input context as the primary cost driver; instead, it aligns the compute focus with generation quality and reasoning depth.

Task-Level Cost Calculation: The Relativity of Expensive vs. Cheap

Beneath the seemingly astonishing unit price lies an evaluation dimension more aligned with business logic: single-task cost. For deep reasoning models, users no longer care about the price per million tokens. What they care about is how much it costs to “complete a complex code generation” or “process a fifty-page contract review.”

Assuming the average token consumption for the model to complete a standard complex task is fixed, its single-task cost can be compared horizontally with mainstream high-end international models. Data shows that its single-task cost (around the $0.9 mark) is on par with top-tier global general-purpose models, and even outperforms some notoriously expensive closed-source competitors. This reveals a brutal competitive truth: in the old coordinate system of volume-based pricing, it appears expensive; but in the coordinate system of task-based pricing, it is actually competitive.

However, this logic only holds true in closed-source, high-end commercial scenarios. When compared horizontally within the open-source camp, the gap widens drastically. Open-weight models of similar size might cost only a tenth or even a fraction of a tenth of its price to complete the same task. This massive cost disparity forces us to re-examine the core target audience of this model: it does not serve price-sensitive general chat scenarios, but rather targets machine-to-machine (M2M), high-concurrency, high-value automated workflows.

The Paradox of Open Weights and High-Pricing Strategies: A Ten-Day Window Game

The most intriguing aspect of this model’s release is its combination of “open weights + premium API.” This breaks the conventional logic of global model releases: typically, a model is either closed-source and premium, or open-source and low-cost. Placing open weights alongside a high official API price seems contradictory, but it conceals a shrewd business calculation.

Following industry practice, weight files will permeate third-party inference providers shortly after release. Because these third-party platforms do not bear the heavy R&D amortization pressure, their API pricing based on open weights is often far lower than the official rate. This means the official price tag of 100 RMB might have an actual validity period of only ten days—the window between the release of the weights and the moment third parties list them at lower prices.

So, what is the point of this ten-day “high-price window”? The answer is to establish a price anchor. When third-party platforms subsequently launch services with identical specs for 30 RMB or less, the user’s first psychological reaction is not “this model is cheap,” but rather “I am getting a massive bargain, buying the official 100 RMB-valued intelligence at a 70% discount.” The high official price serves as a psychological yardstick, providing value endorsement for all subsequent derivative services based on those weights. This is a classic “price setting” behavior: the provider does not care how much they sell during those ten days; they care about how the market defines the value tier of this model over the next year.

Developer Strategies: Hybrid Routing and Cost-Aware Architecture

Faced with the drastic polarization of pricing systems, technical decision-makers should not simply take sides between “expensive” and “cheap.” Instead, they should build a cost-aware, hybrid routing architecture. Specific recommendations include:

1. Task-Tiered Routing: Establish a request prediction mechanism. Route simple queries and templated Q&A to lightweight or low-cost open-source models. Only route complex reasoning, deep code generation, and long-text structural deconstruction tasks to high-end reasoning models. By introducing a semantic routing gateway, enterprises can reduce overall API costs by 40%-60% without sacrificing quality in core scenarios.

2. Maximizing Cache Strategies: Pay close attention to the cache hit price in the new pricing system—1 RMB per million tokens, which is merely one-twentieth of the input price. This means prefix caching will become the lifeline of cost control. When designing prompts, developers should maintain the stability of fixed prefixes, such as system prompts and tool definitions, ensuring high cache hit rates in long-context scenarios.

3. Recalculating “Free Usage” Quotas: For specific development and testing scenarios, adjust your budgeting models. The traditional method of estimating costs based on token volume is no longer applicable. Shift to estimating costs based on “daily average task requests” and set a maximum token consumption limit per task (e.g., a max output cap per task) to prevent bill blowouts caused by the model overthinking.

4. Accepting the “Reasoning Tax” Reality: Since the cost center of reasoning models is on the output side, evaluate whether deep thinking capabilities are strictly necessary for business applications that require high-concurrency responses. Triggering a “rapid response” mode in certain scenarios—sacrificing some reasoning depth in exchange for a significant cost reduction—will be an ongoing strategic trade-off.

Conclusion: Price is Narrative, Cost is Reality

The diversification of LLM pricing signifies that the industry is moving from the “subsidy era” of reckless growth into the “value realization era” of fine-grained operations. This price increase is less about inflation and more about a revaluation of the model’s intelligence tier. It refuses to act as a shadow in the pricing dimension, aiming instead to delineate its capability coordinates through high-tier pricing.

For developers, the most critical habit to discard in light of this trend is the “unit-price-only” mindset. In an era where compute costs are increasingly transparent and model capabilities are converging, the winners will be the teams capable of precisely calculating the “cost per unit of intelligence acquired” and the “output value per unit of task.” Future competition will not be defined by which model you invoke, but by whether you can complete the most complex business loops at the lowest Total Cost of Ownership (TCO). Under the new pricing system, the average cost per task is the true metric of a model’s value.