LLM Pricing Doubled: The Technical Logic and Business Narrative Behind Premium Token Prices

15 hr ago0 views

A new-generation LLM has listed its prices at roughly RMB 20 for input, RMB 1 for cache hits, and up to RMB 100 for output per million tokens — several times its predecessor and level with leading international vendors' standard rates. This article breaks down the "intelligence premium" strategy behind the price tag, explains why the reasoning-model era shifts billing weight from input to output tokens, compares per-task costs from an agent's perspective against closed-source and open-weight alternatives, and outlines practical architecture patterns — hybrid model routing, prompt caching, and managed cloud inference — for keeping token spending under control.

The pricing strategy of a new-generation large model (hereafter “the model”) has recently drawn wide attention from developers. Its list price is several times higher than the previous generation’s: roughly RMB 20 for input, RMB 1 for cache hits, and up to RMB 100 for output per million tokens. This price breaks the unspoken “cheap and good enough” consensus of China’s LLM market and directly aligns with the standard pricing of same-generation models from leading international vendors. How should we read this high-price strategy, which departs from pure cost logic? And what far-reaching impact will it have on enterprise AI application development? This article takes a deep look from three angles: technical evolution, business narrative, and architecture adaptation.

The Ambition Behind the Premium: From Price War to “Intelligence Valuation”

For a long time, China’s LLM market has been stuck in a price war. Vendors have offered extremely low — even loss-making — prices in exchange for call volume, reinforcing a stereotype of domestic models as “shadow models”: cheap stand-ins for frontier systems. The pricing strategy of this new model is, at its core, an attempt to redefine how “intelligence” is valued.

In business terms, pricing is a direct statement about technical strength. The model skips past competitors’ temporary promotional prices and benchmarks itself against the standard list prices of leading international vendors. The core message: the intelligence this model delivers should command this price. Psychologically, it does shock users who have grown accustomed to cheap tokens, but from an industry perspective, this is the first time a Chinese LLM vendor has refused the price war at the pricing level, signaling an ambition to compete on technical premium.

Yet the RMB 100 output price is not a faithful reflection of R&D and compute costs. It is closer to a “narrative price.” With the open weights about to be released, the high price can only stay effective for a very short window — roughly ten days. Once the weights are open, third-party inference providers will quickly list cheaper versions built on optimized inference engines. The real purpose of maintaining the official high price is to establish a value anchor — a calibrated price for the model’s intelligence — before the weights are fully commoditized. When developers later see RMB 30 or lower for output on third-party platforms, the existence of the RMB 100 anchor makes their first reaction “what a bargain,” completing the mindshare play.

Reasoning Models Shift the Billing Center of Gravity: From Input to Output

Understanding the high price requires looking at the broader paradigm shift in LLM technology. In the early chatbot era, compute costs concentrated on the input side (prompt encoding and attention computation), so input tokens were usually the more expensive ones. In the reasoning-model era, the cost center has moved decisively to the output side.

This model runs in a high-intensity thinking mode, and its entire reasoning process is billed as output tokens. The more the model “thinks,” the more developers pay. For traditional consumer chat scenarios, this billing model is disastrous — no ordinary user can afford single conversations costing tens of RMB.

The following pseudocode illustrates typical token consumption in the reasoning-model era:

# Cost calculation example for a reasoning model task
def calculate_cost(input_tokens, thinking_tokens, final_output_tokens):
    # Input-side cost (including cache-hit scenarios)
    input_cost = input_tokens * 20 / 1_000_000
    # Core cost of a reasoning model: thinking is billed as output
    # Assume the thinking process is far longer than the final output
    output_cost = (thinking_tokens + final_output_tokens) * 100 / 1_000_000
    total_cost = input_cost + output_cost
    return total_cost
# Typical scenario: a complex code refactoring task
# Input context: 8k tokens
# Internal model thinking: 15k tokens (exploring multiple approaches)
# Final output: 2k tokens (the refactored code)
cost = calculate_cost(8000, 15000, 2000)
# The actual bill will far exceed expectations based on traditional chat models,
# because the output side accounts for the overwhelming majority

The real target customer of this pricing is therefore not human users but agents. In machine-to-machine token consumption, agents work toward goals, not processes.

Agent Economics: From Token Pricing to Task Pricing

Once LLMs are embedded in automated workflows, the way enterprises evaluate cost changes fundamentally. Under traditional pay-as-you-go billing, developers haggle over the price per million tokens; in the agent era, buyers calculate “how much per task.”

If a high-priced model delivers a higher single-task success rate, fewer error retries, and better code quality, then even with expensive tokens, its “total cost per task” can still be competitive.

Take the common case of code generation or complex logic tasks:

Traditional low-price models: consume fewer tokens per task, but weaker logical rigor means 3–4 rounds of human correction, or even full regeneration. The combined task cost — including human fixes and repeated calls — is actually not low.
The high-priced new model: with strong reasoning, it may produce a perfect result in one shot. If its average per-task cost (about $0.94) sits in the same tier as other top closed-source models (about $1.04 or higher), or is only half the cost of some top flagship models, it is not expensive in a per-task-pricing world.

Competition Within the Open-Weight Camp: Compute Optimization and Scheduling Strategy

Compared horizontally with closed-source commercial models, the model’s task-level cost has a certain advantage. But viewed within the open-weight (open-source) camp, a huge price gap emerges.

In the open-source ecosystem, the same level of intelligence is often available at extremely low prices. Some open-source models with equally strong reasoning capability can execute the same task for about $0.32, and some extremely optimized versions cost as little as 4 cents. The model’s output list price is a dozen to dozens of times higher than these ultra-cheap open-source options.

Faced with such a price gap, enterprise developers need more flexible architecture strategies:

Hybrid model routing: Do not bind a single model to a business flow; introduce an intelligent routing layer. Route core paths and complex planning tasks with near-zero fault tolerance to the high-priced new model, and send routine code completion, text summarization, or simple logic decisions to cheap open-source models.

// Routing policy configuration example
{
  "task_type": "complex_algorithm_design",
  "preferred_model": "high_price_reasoning_model",
  "fallback_model": "low_price_open_source_model",
  "max_task_budget_usd": 1.5
}

Caching and context reuse: Given the differential pricing between input and cache hits (RMB 20 vs. RMB 1), developers should aggressively optimize prompt structure. Hash stable content such as system instructions and long background documents to force cache hits. In multi-turn agent interactions, strictly trim dynamic context to avoid re-sending the full conversation history every turn.
Cloud-native high-availability services: For enterprises that want both low cost and high reliability, mature cloud-native LLM services are a practical option. Baidu AI Cloud’s model inference platform, for example, lets teams manage multiple open-source and closed-source models in one place. With its container platform and elastic inference nodes, enterprises can deploy open-source models at very low marginal cost for high-frequency simple tasks, switch to premium models when deep reasoning is needed, and use cloud monitoring and alerting to track token consumption in real time — preventing an agent stuck in a loop from producing a runaway bill.

Conclusion

Doubling the output price to the RMB 100 level looks, on the surface, like an aggressive market probe. At a deeper level, it reflects the vendor’s appetite for an “intelligence premium” and a precise bet on the agent era. Through the unprecedented combination of “open weights + high list price,” the model has completed its initial value anchoring.