How to Calculate Agent Costs After Reasoning Model Price Increases

    Recent price changes for reasoning-capable LLMs have made output tokens more expensive and shifted cost discussions from per-token list prices to task-level economics. This article examines the market signals behind higher standard pricing, why reasoning models consume more output tokens, how to estimate effective cost per task using measured data, and how multi-model routing, caching, and infrastructure choices affect Agent cost planning.

    A new-generation large model from a Chinese provider recently announced new standard pricing, with output prices clearly higher than the previous generation and some tiers reaching hundreds of RMB per million tokens. Cache-hit pricing was adjusted as well. This differs from the past practice of attracting users with low prices and has sparked discussion among developers and enterprise users.

    Any specific prices, timing, and discount validity periods should be based on the vendor’s official announcements. This article focuses on three questions: what the price adjustment may signal, how reasoning models change the cost structure, and how enterprises should evaluate costs in Agent scenarios.

    1. What Higher List Prices May Signal

    Price usually serves two purposes: covering costs and communicating product positioning to the market. In the past, many Chinese vendors used promotional discounts and low-price strategies to win users, so the gap between standard prices and promotional prices was often large. If a vendor directly uses the standard prices of leading international products as a reference, users will usually interpret that pricing as the vendor’s judgment of the model’s capabilities.

    Whether such pricing is accepted by the market depends on how the model performs on real tasks. Price alone cannot prove capability; it needs to be verified through independent evaluations and practical business testing.

    In addition, some vendors adjust prices around the release of open-weight models. If third-party inference providers later offer the same model at a lower price, users’ perception of the original price will change. When judging this kind of strategy, three questions are worth asking: Is the validity period of the official price clear? Does the third-party service provide an equivalent version? Are new restrictions attached after the price decreases?

    2. Why Reasoning Models Increase Output Tokens

    In the era of non-reasoning models, costs were mainly concentrated on the input side. Developers used carefully designed prompts to guide models toward short answers, and the ratio of input tokens to output tokens was usually relatively stable.

    Reasoning models are different. Most reasoning models generate lengthy intermediate reasoning content before producing a final answer. Whether this content counts as output tokens, whether it is visible to users, and whether reasoning intensity can be adjusted depend on the specific vendor and API parameters. Some APIs allow developers to set a reasoning budget, while others use a fixed strategy. As a result, the actual cost of the same question can vary widely across platforms.

    Overall, deeper reasoning usually means higher cost. For simple scenarios such as everyday Q&A, users paying out of pocket are unlikely to accept a high reasoning cost for every conversation. In tasks such as complex code generation and multi-step data analysis, additional reasoning may reduce errors and thereby save the cost of later rework. Whether it is worth it depends on the value of the task and the cost of errors.

    3. From Token Price to Task Cost

    API billing is still primarily based on tokens, and that has not changed. What has changed is the way developers evaluate cost. Comparing only the price per million tokens cannot reflect the full cost required for a model to complete a task. For the same task, a lower-priced model may need multiple attempts to produce a usable result, while a higher-priced model may complete it in one attempt.

    The following formula can be used to estimate the actual cost per task:

    Effective cost per task ≈ (input token price × average input tokens + output token price × average output tokens) × average attempts ÷ task success rate + manual correction cost

    Here, average attempts include retries after failures; task success rate refers to the proportion that passes acceptance without manual intervention; and manual correction cost is converted from work hours. If caching is used, the input price for cache-hit portions should be replaced with the cache price and weighted by hit rate.

    Every item in the formula should be filled in with measured data rather than direct estimates. It is advisable to run at least dozens of tests on your own real task samples, record token consumption, latency, success rate, and number of manual modifications, and then calculate the result with the formula. Comparisons between two models should use the same batch of samples.

    The test report should also note the model version, inference parameters, task samples, test date, and whether retries and caching are included. Cost figures without this information have limited reference value.

    4. Multi-Model Routing Considerations

    As the number of open-weight models increases, a single model can hardly satisfy all scenarios at once. Multi-model routing is a common approach and can be designed in the following ways.

    1. Tiered scheduling. For high-frequency, low-complexity conversations and basic data processing, call low-cost, low-latency models. For core business that requires deep reasoning or long-chain Agent operations, call high-end reasoning models. Routing rules can be set based on task type, input length, or historical failure rate.

    2. Failure fallback. When the output of a low-cost model fails validation, the system automatically hands the task to a stronger model and records the fallback ratio. If the fallback ratio remains high, the routing rules need adjustment.

    3. Regular retesting. Prices and capabilities of open-weight models change quickly. It is advisable to retest with the same batch of samples every quarter or after each version update, and then update the cost table.

    Caching optimization should also be viewed rationally. Properly designing system prompts and fixed instructions can improve cache hit rate and reduce costs for repeated input portions. However, caching usually reduces only repeated billing on the input side; it does not reduce output tokens or reasoning token overhead. If an Agent’s main consumption comes from long reasoning output, the savings from caching will be limited.

    5. Infrastructure Choices

    If an enterprise considers building its own inference service, it can use container services, elastic GPU resources, and monitoring and alerting capabilities provided by cloud platforms to deploy open-weight models in self-owned or hosted compute environments. The advantages of this approach are data controllability and relatively predictable costs, making it suitable for businesses with stable call volumes. The disadvantages are the need to handle operations and maintenance, scaling, and model updates.

    Whether to build in-house depends on call volume, data compliance requirements, and team capabilities. When call volume is low, using third-party APIs directly is usually more cost-effective. When call volume is high and peak-valley patterns are obvious, elastic resource pools and auto-scaling capabilities can show their value. These are common considerations, not the only options; enterprises should compare them based on their own conditions.

    6. Conclusion

    This price adjustment is both a pricing decision and a reflection of changes in the focus of large-model competition. For developers, comparing unit prices is still necessary, but it is not sufficient. More important is to understand the billing logic of reasoning models, establish a task-level cost evaluation method, and continuously verify it with real data.