After the LLM Price War: Competition Moves to Cost per Task

    Chinese LLM API prices have stopped falling in lockstep and are now stratified by model tier. This article explains why list prices per million tokens no longer reflect real spend, how vendors now compete on end-to-end task cost, and how developers can measure and route workloads accordingly.

    From collapsing prices to price differentiation

    For two years, the dominant story in the large-model API market was price cuts. After a leading vendor pushed input pricing down to about one yuan per million tokens, major cloud providers followed within a week. Free tiers and extreme discounts followed; some domestic model quotes reached roughly one percent of international flagship rates.

    Industry monitoring now shows a structural turn. After normalized average token prices bottomed out, they stopped falling together and split clearly by model tier.

    Normalized averages are based on public list prices at launch, not on actual invoices. Real bills also reflect cache hits, volume discounts, peak/off-peak windows, and retries after failures. List price and market price have never been the same thing.

    Two moves at once: cheaper entry models, dearer flagships

    In the half-year after the average hit bottom, the market did two things that look contradictory.

    Budget tiers kept going down. Some vendors permanently cut lightweight series by as much as about 99%, with several general chat models down more than 90%. Low-price SKUs keep developer traffic and cover long-tail use cases.

    Flagship tiers moved up. Some vendors raised prices several times, citing a return to normal commercial value. Others introduced peak/off-peak pricing, with peak output several times off-peak. One vendor raised flagship output pricing by an order of magnitude and became the most expensive domestic model; public reports still showed several-fold growth in annual recurring revenue, without customer churn or competing price cuts.

    The market is no longer competing on a single price axis. Competing only on the lowest list price is over. Pricing is now by scenario, time window, and capability tier.

    The new unit: cost per completed task

    In October, several vendors shipped a new generation of models in a short window. Only one of five new models cut list prices; the rest held pricing versus the previous generation. Launch narratives aligned on what a customer actually spends to finish one task.

    • Some claimed more than 30% lower cost per task.
    • Some claimed about 70% lower blended cost in agent scenarios.
    • Some sold on-premises data residency as a way to cut compliance cost.
    • Some claimed cost per task of about one-eighth of an international flagship.
    • The one vendor that cut list prices showed almost no change in measured cost per task—list price fell, not real spend.

    Competition has switched from list price per million tokens to total spend to complete a code fix, an analysis job, or a multi-step reasoning run. Official notes even used “Pareto improvement”: better quality without higher cost, and scores above international flagships on evaluation suites.

    Why cost per task is the real cost

    From a developer’s view, cost per task tracks spend better than token list prices because a job stacks several layers:

    1. # Illustrative cost-per-task estimate (pseudocode)
    2. def task_cost(model_pricing, task):
    3. cost = 0
    4. # 1. Primary call: input + output tokens
    5. cost += task.input_tokens * model_pricing.input_price
    6. cost += task.output_tokens * model_pricing.output_price
    7. # 2. Context cache: hits are discounted; misses billed at full input price
    8. cost += uncached_context_tokens * model_pricing.input_price
    9. # 3. Retries: higher failure rates inflate effective unit cost
    10. cost *= 1 / (1 - task.failure_rate)
    11. # 4. Agent loops: one task often includes N tool-call rounds
    12. cost *= task.avg_tool_call_rounds
    13. # 5. Peak/off-peak: peak output can be several times off-peak
    14. cost *= time_window_multiplier(task.schedule)
    15. return cost

    A cheap list-price model with high failure rates, aggressive cache policies, and long agent loops can cost more than a higher-priced model that finishes reliably. That is the difference between a price war and a cost war: the former optimizes the sticker number; the latter optimizes end-to-end task economics.

    Practical guidance for developers and enterprises

    Selection should match a stratified market.

    1. Measure cost at the task level. Do not rely only on public price tables. Pilot on real traffic and record tokens, failure rates, retries, and cache hit rates per task type to get a true unit cost.

    2. Route by scenario. Budget models fit high-volume, low-complexity work (classification, summarization, formatting). Flagships fit lower-volume, high-value work (complex code generation, multi-step reasoning). Mixed routing often beats a single model.

    1. # Layered routing sketch
    2. def route(request):
    3. if complexity(request) < THRESHOLD_LOW:
    4. return budget_model # budget tier: volume at low price
    5. elif latency_sensitive(request):
    6. return mid_tier_model # mid tier: speed vs. quality
    7. else:
    8. return flagship_model # flagship: high-value tasks

    3. Use peak/off-peak scheduling. Batch work that can wait (offline eval, labeling, reports) into off-peak windows. That cut is an engineering change, not a model-capability change.

    4. Include quality cost. Rework, human review, and bug fixes are hidden costs. A slightly higher token price with a higher first-pass rate can be cheaper overall. Track both direct token spend and downstream correction spend.

    5. Weight data-boundary cost. For sensitive data, private deployment and whether data stays on-prem affect total cost and risk and should be part of the score.

    Closing

    The price war ending does not mean less competition; it means a higher-dimensional contest. Once budget, mid, and flagship tiers are distinct, vendors compete on lowering cost per task. Cache design, inference optimization, failure-rate control, and context management replace marketing list prices as the moat.

    For developers that is good news: vendors optimizing cost per task tend to deliver better quality at lower real spend. Selection shifts from “who is cheapest” to “who is worth more.” The practical skill in this phase is task-level costing on your own load.