Deep Reasoning Model Pricing Explained: The Logic Behind 100 RMB per Million Tokens and Agent Cost Optimization

Introduction: From Single Chats to Complex Tasks, a Paradigm Shift in LLM Pricing

A leading AI lab recently released the latest reasoning-enhanced version of its flagship model, and its pricing quickly became a hot topic in developer communities: output is priced at 100 RMB per million tokens, input at 20 RMB per million tokens, and cache hits at just 1 RMB per million tokens. At first glance, the output price is five times higher than the previous generation. Many developers’ first reaction is shock: for ordinary chat interactions or simple Q&A, such output costs would be unaffordable for almost any individual user. Notably, at launch the model offered only a single “high-intensity thinking” tier, with all internal reasoning and chain-of-thought tokens billed as output.

However, judging this price purely from a “chatbot” perspective misses the core logic behind the pricing strategy. In the reasoning-model era, the cost center has shifted irreversibly—a shift that not only changes developers’ bills but also reshapes the business loop of the entire LLM application ecosystem.

The Cost Center Shifts: From Input Perception to Output Thinking

In past LLM applications built on basic models, developers focused mainly on prompt length and input-side costs. Under a native reasoning model architecture, however, the model constructs extensive internal chains of thought before producing the final answer. In other words, the more the model thinks, the more you pay.

1. Visible Thinking Inflates the Bill

Traditional models perform a one-shot forward pass, while reasoning models generate large volumes of internal reasoning tokens before emitting the final response. Although these tokens are invisible to end users, they genuinely consume compute resources and incur charges. Because new-generation reasoning models are designed to “think as deeply as possible on complex tasks,” average output token counts have risen dramatically. As a result, while the sticker price increased 5x, actual bills often rise even more once the surge in output volume from the thinking process is factored in.

2. The Nature of Output-Side Compute Consumption

The decode phase of an LLM differs fundamentally from the prefill phase in compute intensity. Prefill can process the input matrix in a highly parallel manner, whereas decode must generate tokens autoregressively, one step at a time, and is bounded by memory bandwidth. When a reasoning model generates its internal chain of thought, it is operating in this energy-intensive decode phase. The high output price is, to a large extent, a faithful reflection of the underlying GPU compute and memory bandwidth consumption.

Rethinking the Pricing Unit: From “Per Million Tokens” to “Per Task”

When a model’s price reaches the 100-RMB level and its core value lies in deep thinking, its target audience has already shifted from consumer chat users to B2B agent applications. In machine-to-machine token consumption scenarios, the traditional pricing evaluation framework is breaking down.

1. Why Per-Token Pricing No Longer Works

For developers building complex workflows, “how much per million tokens” has lost its guiding significance, because different models require vastly different token counts to solve the same problem. A model with weaker reasoning ability may need multiple rounds of prompt steering and repeated retries to reach a correct result, while a powerful native reasoning model may hit the mark with a single long chain of thought.

2. The Economics of Per-Task Cost

Developers are increasingly adopting “cost per task” as the new yardstick. Take a top-tier reasoning model as an example: running a typical complex code refactoring or logical reasoning task costs about $0.94 on average; a comparable closed-source model version runs about $1.04 per task; and some general-purpose flagship models can exceed $2 per task.

From a per-task perspective, if the 100-RMB model can replace multiple calls to other models with a single deep-thinking pass, while also reducing the maintenance burden of surrounding glue code, then in the per-task world its price is not expensive at all—it delivers remarkably high ROI.

Open-Weight Models and the Strategic Value of Cache Hits

When we switch perspective to the open-weight and self-hosted camp, the cost balance looks different again.

1. The Cost Advantage of Open Models

On identical tasks, many strong open-source LLMs deliver impressive cost-effectiveness. Some deeply optimized open models run at roughly $0.3 per task, and ultra-lightweight variants can compress that to just a few cents. Earlier, a well-known open-source model permanently cut its API prices to 3 RMB for input and 6 RMB for output. By comparison, the closed-source 100-RMB output price is more than 16 times higher. This enormous price gap is pushing enterprises to adopt hybrid routing strategies across tasks of varying complexity.

2. The Strategic Meaning of the 1-RMB Cache Price

Back to the original price list: input at 20 RMB, cache hits at 1 RMB. That 5% cache price is no arbitrary figure—it is designed specifically for Agent workflows.

In multi-agent collaboration or long-horizon tasks, system prompts, tool definitions, and historical context often span thousands or even tens of thousands of tokens, and they remain unchanged across multiple calls. By properly leveraging context caching, developers can dramatically reduce input costs. Below is a generic Agent invocation example showing how prefix reuse can hit the cache:

# Generic agent invocation example: emphasize prefix reuse to hit the cache
class AgentRunner:
    def __init__(self, system_prompt, tool_definitions):
        # System prompt and tool definitions act as a fixed prefix, highly likely to hit the cache
        self.static_prefix = system_prompt + "\n" + tool_definitions
    def execute_task(self, user_query, history_logs):
        # Build the request: static prefix + dynamic history + current query
        messages = [
            {"role": "system", "content": self.static_prefix},
            {"role": "user", "content": history_logs},
            {"role": "user", "content": user_query}
        ]
        # Call the API; the provider automatically matches the prefix cache
        response = llm_client.chat.completions.create(
            model="advanced-reasoning-model-v1",
            messages=messages,
            # Enable deep thinking mode, allowing the model to generate long internal chains of thought
            reasoning_depth="max"
        )
        # Cost estimate: the static prefix hits the cache at 1 RMB per million tokens, far below the 20 RMB real-time input price
        return response.choices[0].message.content

Enterprise Practices: Building High-Performance Applications Under High Token Costs

Facing output prices at the 100-RMB level, enterprise developers need to introduce cloud-native and engineering best practices at the architecture level to keep costs under control.

1. Dynamic Model Routing Based on Task Complexity

Do not throw every task at the most expensive reasoning model. In an enterprise architecture, you should introduce a lightweight “intent recognition and task routing layer”:

• Simple Q&A and information extraction: route to low-cost open-weight models (output at around 6 RMB per million tokens).
• Complex code generation and multi-step logical reasoning: route to high-end reasoning models (output at 100 RMB per million tokens).

With this tiered strategy, the average per-task cost of the overall system can be kept within a reasonable range.

2. Use Logging and Alerting to Optimize Chain-of-Thought Length

The least controllable aspect of reasoning models is that they “think too much.” Sometimes a model spends hundreds of tokens self-correcting on irrelevant branches. Developers can use comprehensive logging services to persist and analyze the model’s internal chain-of-thought process. Once monitoring and alerting systems detect abnormal spikes in chain-of-thought length for a certain type of task, they should immediately review the prompt design and add constraints (such as “think briefly and give the conclusion directly”) to cut off unnecessary output tokens.

3. Asynchronous Tasks and Peak Shaving with Message Queues

For Agent tasks that do not require real-time interaction, message queues can be used to process requests asynchronously. This not only avoids LLM API rate limiting under high concurrency, but also takes advantage of potential off-peak compute scheduling from cloud providers. Combined with elastic scaling of Agent worker nodes on container platforms, this further reduces overall operating costs at the infrastructure level.

Conclusion

A 5x output price increase to the 100-RMB level looks like a price surge on the surface, but it is essentially a reconfiguration of how AI compute consumption is measured. As models shift from “chatting” to “getting work done,” the yardstick for evaluating their value moves from token unit price to task completion quality and per-task cost. For developers, understanding this shift in pricing logic—and mastering context caching, dynamic model routing, and cloud-native observability tools—is the key to building Agent applications that are both intelligent and economically viable in the reasoning-model era.