Why Next-Generation LLM Prices Are Rising: Pricing Logic, the Real Cost Math, and How to Control It
As a new generation of large language models moves to a roughly RMB 100 per-million-token output price, many developers see only a price hike. This article explains what is actually changing: the billing center of gravity is shifting from the input side to the output side, list price is functioning as a value anchor rather than a cost-plus markup, and buyers are starting to calculate cost per task and cost per valid result instead of price per million tokens. It covers how reasoning models, agents, tool calls, and retries reshape the bill, why official high pricing can coexist with open weights and cheaper third-party hosting, and which engineering practices actually contain cost: model tiering and routing, cache and context reuse, output constraints, per-task budgets with fallback, task-level evaluation metrics, and an observable, traceable cost governance stack built from full-link logging, monitoring and alerting, and gradual rollout.
Why Next-Generation LLM Prices Are Rising: Pricing Logic and the Real Cost Math
1. A Single Price Change Reflects a Shift in How Models Are Priced
A recent price revision for a next-generation model API is a clear step up: output is now in the neighborhood of RMB 100 per million tokens, input around RMB 20, and cache hits around RMB 1. Compared with the previous generation, this is not just a change in numbers. It reflects a meaningful turn in how the LLM industry thinks about pricing.
For a while now, domestic model services have competed on a “low price, easy to use, easy to integrate” strategy, using low invocation costs to attract developers and small and mid-sized businesses. Against that backdrop, an output price in the hundreds of RMB per million tokens is a real shock. Many developers see the price table for the first time and immediately compare it with the previous generation, with open-weight models, or with cheap managed hosting, and start asking whether they can still afford it.
But once you widen the lens to reasoning models, agent applications, and complex multi-step task execution, the issue stops being “it got more expensive” and becomes “the billing center of gravity moved.” Input price went up, but cache-hit price stayed low, which means the platform wants reusable input to stay cheap. Output price went up sharply, which means generation, reasoning, reflection, and tool calling are now positioned as higher-value capabilities.
Put differently, this revision is not the old price multiplied by some factor. It is a redefinition of what “intelligent output” is worth.
2. A High List Price Is Not Cost-Plus — It Is a Value Anchor
Discussions of model pricing tend to reach for cost: what inference costs, how much compute is consumed, what the margin is. That framing was common in the traditional software era, but it does not fully apply to the LLM era.
Model price carries at least three layers:
- The cost layer: infrastructure spend on inference, storage, bandwidth, and operations.
- The business layer: promotions, discounts, bundles, and channel subsidies.
- The value layer: model capability, task completion quality, reliability, positioning, and long-term worth.
A next-generation model’s high price mostly expresses the third layer. The official list price is not a restatement of a temporary promotional price, and it is not a simple continuation of the previous generation’s price. It is a self-assessment of the ceiling of the model’s capability.
This is an easy distinction to miss: discounts are a business action; the list price is the product positioning.
If a vendor keeps promoting its discounted price as the effective price, the signal it sends is that its capability can be substituted cheaply. If instead it aligns the list price with high-end intelligence, the signal is that the capability is worth a high price.
From a developer’s perspective, this means the previous generation’s price can no longer be the only reference point. In the past, judging whether a model was expensive meant looking at price per million tokens. Now the question is whether the model can complete work that previously required human effort, a process, or a multi-step system assembled from several parts. If a model materially raises task success rate, cuts rework, and shortens the pipeline, its per-token price may be higher while its cost per task is not.
So a high price is not a numbers game detached from reality. It is a value narrative that moves the model from “cheap API” to “high-value intelligent service.”
3. Reasoning Models Move the Cost Center From Input to Output
In traditional conversational AI, the cost structure skews toward the input side. System prompts, knowledge base fragments, and conversation history all generate large volumes of input tokens, while outputs are usually short. That is why input caching, context compression, and retrieval augmentation are so effective as optimizations.
In deep reasoning, agents, multi-step tasks, and tool calling, the cost structure changes noticeably.
The reasons are straightforward:
- The model no longer answers one question; it thinks across multiple rounds.
- The thinking process, intermediate conclusions, self-checks, and tool call parameters can all be counted as output.
- An agent may repeatedly plan, execute, inspect, and correct.
- Retries after failures, format validation, structured generation, and code generation all lengthen output.
- The more complete and reliable the output, the higher the token consumption tends to be.
So in the reasoning model era, cache hits mainly optimize the input side, while the output side is the harder part to compress and the part that most easily drives the bill.
A simplified cost formula captures this:
task cost ≈ uncached input tokens × input unit price+ cached input tokens × cache unit price+ output tokens × output unit price+ retry tokens × output unit price+ tool calls and post-processing
When a model is configured for deep thinking, the thinking process generally turns into output-side consumption. The user appears to have asked one question, but the actual bill may include the full reasoning chain, structured output, call details, and the final answer.
Consider a complex task. If the model only emits the final answer, a few hundred tokens may be enough. If it first decomposes the problem, compares approaches, analyzes risks, drafts code, and then summarizes, output tokens can multiply. On a cheap model that difference might amount to a few cents; on an expensive model, every thousand output tokens can meaningfully amplify cost.
That is why evaluating a next-generation model’s price cannot stop at “how much per million tokens.” The question that matters is “how many tokens does a task actually consume.”
4. From Price per Million Tokens to Cost per Task
For ordinary chat, an output price of RMB 100 per million tokens is genuinely hard for daily users to accept. Chat is high-frequency, low-value, low-complexity interaction, and users will not pay heavy inference fees for casual conversation.
But the real customers for these high-priced new-generation models are not casual chat users. They are task-oriented scenarios: agents, automated workflows, code generation, data analysis, development assistance, customer service quality review, and knowledge work assistants.
In those scenarios, the way buyers calculate has changed:
- It used to be “how much per million tokens.”
- Now it is “how much to complete one task.”
- Next it becomes “how much per valid result.”
- Eventually it becomes “how much per hour of human labor replaced.”
That is the task-level cost perspective.
Assume average cost per task for one class of complex work looks roughly like this:
| Model type | Average cost per task | Typical characteristics |
|---|---|---|
| High-end reasoning model | ~USD 0.9–1.0 | Strong on complex tasks, but a higher unit price |
| Open-weight mid-tier model | ~USD 0.3 | Balanced value, suited to routine work |
| Low-cost lightweight model | ~USD 0.04–0.10 | Suited to simple classification, extraction, summarization |
The numbers themselves are not the point. The point is that the axis of comparison changed. A model with a high task success rate, little rework, and minimal human intervention can be more expensive per call and still cheaper for the project overall.
Take a complex data processing task:
- A low-cost model may need multiple retries, manual verification, and rule-based patch-ups.
- A high-priced reasoning model may finish it in one pass and produce a verifiable execution plan.
- If a single successful pass saves tens of minutes of human work, the cost per task can still work out favorably.
So expensive models are not expensive in every scenario. They can be the more economical choice in high-value tasks. Their real competitors are not cheap chat models, but the complex tasks that otherwise require human effort, custom processes, scripts, or an assembly of several models.
5. Open Weights and a High Official Price: The List Price Becomes the Anchor
When a new-generation model combines open weights with a high price, the result is an interesting market structure.
On one side, releasing weights means the technology spreads, and third-party hosts can offer the model at lower prices. On the other side, the official list price stays high. These do not contradict each other; together they form a new pricing structure.
The high official price serves at least three purposes.
1. Value anchoring
The official price tells the market how to value the model’s capability. Even if third parties later offer similar service at lower prices, users encounter the official list price first and form a mental anchor.
When a developer sees a lower price on a third-party platform, it is easy to feel like they found a bargain rather than concluding the model was only ever worth the low price.
2. Backing from the official channel
Open weights do not mean all services are equivalent. Official hosting usually means a more stable model version, more complete compliance processes, clearer service levels, a more disciplined update policy, and fuller engineering support.
Low-cost third-party services may be a good fit for experimentation, batch offline jobs, and cost-sensitive applications. But in production, organizations still need to consider:
- Whether the model version is stable;
- Whether inference quality is consistent;
- Whether monitoring and alerting exist;
- Whether data isolation and security policies are in place;
- Whether continuous upgrades are supported;
- Whether usage is auditable;
- Whether enterprise compliance requirements are met.
The official high price and third-party low prices are therefore not simple competition. They are a division of labor across service tiers.
3. Suppressing shadow pricing
If a vendor shows low prices for a long time, the market gradually treats the low price as the real value. By contrast, once the official list price establishes a certain perception, actual procurement can still be lowered through promotions, bundles, resource packages, or third-party deployment while users continue to recognize the model’s inherent value.
That is what is distinctive about pairing open weights with high pricing: it keeps the technology usable while keeping the value from being pushed down too easily.
6. Cost Governance for Expensive Models: Engineering Practice
Facing expensive models, developers should not simply avoid them. They should use engineering means to keep cost within a reasonable range. The core idea: do not send every task to the most expensive model; match each task to the most appropriate cost tier.
1. Build tiered model routing
A mature AI application rarely relies on a single model. It maintains a set:
- Lightweight models: classification, extraction, short summarization, simple Q&A.
- Balanced models: routine writing, code completion, structured generation.
- Reasoning models: complex planning, code debugging, data analysis, long-chain agent tasks.
- Backup models: high availability, gradual rollout switching, and failure fallback.
Routing decisions can factor in task complexity, user tier, business value, and budget.
Illustrative code:
def choose_model(task):if task.complexity <= 2:return "lightweight_model"if task.budget_low:return optimize_and_route(task, "balanced_model")if task.requires_deep_reasoning:return "reasoning_model"return "balanced_model"
The value of routing is this: not every request deserves the most expensive model. Only when task complexity, business return, or risk level is high enough should the expensive reasoning model be called.
2. Strengthen caching and context reuse
Cache-hit pricing is usually far below normal input pricing, so raising the cache hit rate directly lowers cost.
Areas worth optimizing:
- Keep system prompts fixed.
- Reuse long-lived background knowledge.
- Structure high-frequency documents, standards, and code templates as a stable prefix.
- Compress context across multi-turn conversations.
- Use summaries instead of full history.
- Deduplicate and chunk retrieved content.
- Write reusable results into a cache layer.
For example, a customer service assistant that carries the entire product manual on every call becomes expensive fast. A better approach is to split the manual into stable knowledge blocks and make the same blocks hit the cache as often as possible.
3. Control output length and output structure
The output side is the main cost source for expensive models, so output must be constrained deliberately.
Common methods:
- Cap maximum output tokens.
- Have the model produce a structured draft first, then confirm with a human or a program.
- Define summary levels for final answers.
- Split long output into multiple stages.
- Generate code, tables, and reports in segments.
- Degrade low-confidence tasks to a lower-cost model.
For example, instead of asking the model to produce a complete long document in one shot, have it output an outline first and then generate section by section. That improves controllability and avoids wasted one-pass output.
4. Add budget controls and fallback on failure
For agent applications, a single successful call is not the whole story; retry cost matters too. Without budget control, a complex task can retry repeatedly after failures and end up costing far more than expected.
Recommended per-task limits:
max input tokensmax output tokensmax retry countmax total budgettimeoutfallback strategy
Illustrative logic:
def run_task(task):budget = estimate_budget(task)if budget <= 0:return fallback(task)result = call_model(task)if not validate(result):budget -= estimate_retry_cost(task)if budget <= 0:return fallback(task)return run_task(task)return result
Budget control is not about limiting capability. It is about keeping high-capability models inside a sensible range of use.
5. Establish task-level evaluation
Whether an expensive model is worth it cannot be settled by feel. It has to be settled with task-level metrics:
- Task completion rate;
- First-pass success rate;
- Human rework rate;
- Average elapsed time;
- Average token consumption;
- Cost per task;
- Error rate;
- User satisfaction;
- Business conversion rate or improvement in engineering efficiency.
A model with a high per-call cost can still have a cost advantage if it sharply reduces manual review and rework.
7. Enterprise Adoption: From Calling an API to an Observable AI Cost System
When model prices go up, enterprises cannot manage cost on individual developers’ experience alone. They need an observable, traceable, governable AI cost system.
In cloud environments such as Baidu AI Cloud, enterprises can typically combine general cloud capabilities — logging services, monitoring and alerting, message queues, object storage, container platforms, cache services — to build a complete governance chain for model invocation.
1. Full-link logging
Each model call should record at least:
- Request time;
- Business scenario;
- Task type;
- Model tier;
- Input tokens;
- Cache-hit tokens;
- Output tokens;
- Total elapsed time;
- Whether it succeeded;
- Whether it was retried;
- Failure reason;
- Final business outcome.
With logs, you can determine which tasks are genuinely expensive and which only look expensive per call while delivering large overall gains.
2. Monitoring and alerting
For expensive models, watch closely for:
- Abnormal token consumption per task;
- Sudden increases in output length;
- Declining cache hit rate;
- Rising retry rate;
- Abnormal share of a particular request type;
- Model invocation cost exceeding the budget threshold.
The purpose of monitoring and alerting is not merely to save money, but to surface architecture problems early. If an agent suddenly starts calling the expensive model frequently, it may mean the upstream task classification logic has broken rather than anything wrong with the model itself.
3. Gradual rollout and version management
Model prices and capabilities change, so enterprises should not switch everything at once. A steadier approach is:
- Roll out to a small share of traffic first;
- Compare task success rates between the old model and the expensive model;
- Observe cost changes;
- Observe user feedback;
- Decide whether to widen traffic based on evaluation results;
- Keep a rollback path.
This minimizes the business risk introduced by a price change.
4. Link cost to business value
AI cost governance cannot look only at the bill. It has to look at the business value behind the bill.
Two metrics are worth defining:
cost per task = total token cost / tasks completedcost per valid result = total token cost / valid results
If an expensive model raises the number of valid results substantially, cost per valid result can actually fall.
This is also why it is wrong to assume expensive models are always uneconomical. What is genuinely uneconomical is using an expensive model for low-value tasks, or running without budget control until retries get out of hand.
8. The Real Signal Behind the Price Increase
The shift of next-generation output pricing into the hundreds of RMB per million tokens looks like a price adjustment on the surface. At a deeper level, it is a restructuring of how the industry prices models.
It sends at least three signals.
First, model services are moving from “cheap API” to “high-value intelligent service.” Developers need to rethink the relationship between input, output, caching, and task cost.
Second, the cost center of the reasoning era is moving from the input side to the output side. Caching can optimize repeated input, but it cannot substitute for the output consumption that deep reasoning produces. Cost governance therefore has to shift from unit token price toward task structure, output constraints, and budget control.
Third, open weights and a high official price can coexist. The official price becomes the value anchor, while low-cost third-party deployment serves cost-sensitive demand. The market will end up with tiered supply rather than a single price competition.
For developers, the real question is not “a model generation got more expensive.” It is “how do I use engineering methods to put an expensive model on the tasks that most deserve it.”
Future model competition will not be fought only on price per million tokens. It will be fought on task completion rate, stability, cost controllability, observability, and business value. Whoever converts model capability into stable, low-cost, reusable task outcomes will earn the real engineering dividend in the era of expensive models.
