Model Pricing Up 5x: Narrative Pricing and Per-Task Costing Logic
A next-generation model raised its official pricing to 20 CNY per million input tokens, 100 CNY per million output tokens, and 1 CNY per million cached tokens—roughly a 5x increase on the output side. This article analyzes the pricing logic behind the move: value anchoring versus cost-plus pricing, the shift of inference costs toward output tokens, the price-anchoring window before open-weight release, and why enterprises should evaluate per-task cost instead of per-token price. It includes a simplified cost model in Python and a practical evaluation framework for multi-model routing.
A next-generation model raised its official pricing to 20 CNY per million input tokens, 100 CNY per million output tokens, and 1 CNY per million tokens for cache hits—an increase of roughly 5x on the output side compared with the previous generation. This price signal has triggered two typical reactions: one holds that it breaks with the long-standing low-price norm of domestic model services; the other sees it as using price to express a valuation of model capability. From a techno-economic perspective, this is not a simple “price hike” but a composite case involving pricing anchors, open-weight commoditization, the migration of inference cost centers, and agent-based costing. This article avoids naming specific brands and instead abstracts the pricing logic and engineering selection methodology.
1. From Cost-Plus to Value Anchoring: Price Is First a Signal
Traditional model service pricing follows a cost-plus logic—roughly “compute cost + operations cost + reasonable margin.” In a phase of homogeneous competition, low prices are the most direct way to win call volume. But once model capability enters the territory of complex reasoning, long context, tool use, and task execution, pricing purely by token cost undervalues differences in task completion quality. At this point, the official list price plays a dual role: covering inference costs, and signaling to the market “which capability tier I belong to.”
By aligning its official list price with the standard pricing tier of a leading overseas closed-source flagship model, this model is effectively saying: it wants to be compared within the same capability tier, not treated as a low-cost substitute. Note that list price and promotional price are not the same thing. If a competitor is running a promotion, its actual transaction price may be below its list price; when the new model charges at list price, users will perceive it as more expensive. “Benchmarking against list price” is therefore a value-anchoring move, but users compare bills based on actual transaction prices. Enterprises must distinguish three prices when selecting models: the official list price, the channel transaction price, and the effective cost converted per task. Looking only at per-million-token unit price leads to misjudgment; looking only at promotional prices ignores the regression risk when promotions end.
2. Output Becomes the Cost Center: Price Multiplier ≠ Bill Multiplier
In the era of reasoning models, the cost structure is shifting from the input side to the output side. Input—prompts, context, and retrieved material—can be controlled through caching, compression, truncation, and retrieval optimization. Output is the model’s generated reasoning process and final answer, and when a model defaults to longer thinking, output tokens dominate the bill. With output priced at 100 CNY per million tokens and the thinking process billed as output, high-frequency chat interactions become very expensive. The real customers are more likely to be agents, batch processing tasks, and machine-to-machine calls.
A simplified cost model illustrates this:
def task_cost(input_tokens, cached_tokens, output_tokens,price_in=20.0, price_cache=1.0, price_out=100.0):# Price unit: CNY per million tokensbillable_in = max(input_tokens - cached_tokens, 0)cost = (billable_in * price_in+ cached_tokens * price_cache+ output_tokens * price_out) / 1_000_000return cost# Example: 10K input tokens, 5K cache hits, 50K output tokenscost = task_cost(10_000, 5_000, 50_000)print(cost) # About 5.105 CNY
In this example, output cost is absolutely dominant. If output drops from 50K to 10K tokens, task cost falls significantly. So enterprises should not just ask “how much per million tokens” but “how many input tokens, cache hits, output tokens, and failed retries does an average task require.” For reasoning models, output length control, structured output constraints, maximum thinking budgets, cache reuse, and task decomposition matter far more than comparing unit prices alone.
3. Open Weights Coexisting with a High List Price: A Ten-Day Anchoring Window
A key economic feature of open-weight models is that once weights are released, third-party inference providers can offer competing hosting services on the same weights, and prices quickly diverge. The official list price is therefore not so much a long-term transaction price as a “value scale” carved out before the weights become commoditized. Before the weight release window closes, the official service is the primary supply; after release, cheaper hosting options appear in the market. The high official price still serves a function: it anchors perceived value, so that users who see lower prices on third-party platforms feel they are getting a bargain.
This “open weights + high official list price” combination is uncommon. It requires strong capability scores and task completion quality to sustain—otherwise a high price would simply suppress call volume. The lesson for enterprises is that the validity period of an official list price may be shorter than the model’s lifecycle. When selecting models, pay attention to the weight release schedule, hosting market competition, provider SLAs, and metering methodology, rather than treating the official price at a given moment as the long-term cost. For large-scale usage, prepare multi-provider routing and price monitoring mechanisms to avoid being anchored to a single list price.
4. Per-Task Pricing: Agent Scenarios Change the Cost Formula
An output price of 100 CNY per million tokens is hard for ordinary users to accept in chat scenarios, but in agent scenarios the buyer’s calculus has changed: they no longer compute per-million-token price, but per-task cost. A task may involve multiple rounds of tool calls, retrieval, code execution, result validation, and retries—tokens are just intermediate consumption. If a model completes tasks in fewer rounds with a higher success rate, its per-task cost may remain acceptable even at a higher unit price. The per-task cost comparison cited in the original discussion shows this model sits in the same tier as a certain closed-source flagship, while significantly cheaper options exist within the open-weight camp. This shows that “expensive or not” depends on task definition: high-value, low-fault-tolerance, long-chain tasks can absorb a higher unit price; high-frequency, short-output, low-value tasks should use cheaper models.
Enterprises can adopt the following evaluation process: first, define task success criteria and average retry counts; second, measure per-task input, cache hits, output, and tool-call overhead; third, compute effective per-task cost instead of per-token price; fourth, set quality thresholds—low price below the threshold is meaningless; fifth, route across multiple models by task type. For example, route complex planning tasks to a high-price, high-capability model, simple classification and extraction tasks to a low-price model, and cache-friendly knowledge Q&A to prioritize cache hits.
5. Competition Within the Open-Weight Camp: Price Bands and Selection Boundaries
The open-weight camp is not uniformly low-priced. For the same task, different models may range from a few cents to tens of cents in USD, driven by model size, inference frameworks, quantization strategies, hosting efficiency, and margin objectives. A high official list price does not mean all hosting prices are high; a low list price does not guarantee low task cost. Enterprises should watch four boundaries: first, whether cache-hit pricing covers system prompts and long context; second, whether output billing includes the thinking process; third, whether concurrency and rate limits affect task completion time; fourth, whether third-party hosting provides stable metering, logging, and monitoring. On general-purpose cloud platforms (including Baidu AI Cloud), enterprises can observe these metrics through unified metering and monitoring, log analysis, and model routing capabilities, but actual selection should still be based on real task benchmarks.
6. Conclusion: Treat List Price as a Signal, Per-Task Cost as the Decision Basis
The core significance of this 5x price increase is not the “100 CNY” figure itself, but that it shifts the discussion from “how cheap per million tokens” to “how much the model is worth and how much a task costs.” The official list price is a value anchor, promotional pricing is a business tactic, third-party hosting prices are the result of commoditization, and per-task cost is the true basis for enterprise decisions. Developers should avoid being swayed by a single list price or short-term promotions, and instead build cost models centered on task success rate, output length, cache hit rate, retry counts, and SLAs. Platforms, in turn, should provide transparent metering, cache optimization, batch processing, and multi-model routing. Only by reducing price signals to engineering metrics can teams make robust choices in a market of rapidly iterating model capabilities and frequently fluctuating prices.
