From Selling API Tokens to Selling Capability: The Shift in LLM Commercialization

    As open-source models gain ground and per-token prices fall, usage is rising while revenue share is not. This article examines why that gap matters: it walks through the criteria enterprises actually use to evaluate models, the four engineering levers that keep driving inference costs down, the economics behind the usage-versus-revenue mismatch, and four monetization paths that go beyond the pay-per-token API. Engineering teams will find concrete guidance on total cost of ownership, where to build durable advantage, and how to design for cost elasticity.

    1. The Market Signal Behind an Industry Inflection Point: From Selling APIs to Selling Capability

    For the past two years, the dominant narrative in the LLM industry has been “token volume growth.” But a set of structural data points should give us pause. Industry observers note that open-source models account for a rising share of enterprise token consumption, while their share of paid spend is declining at the same time. In other words, models are being used more and more, yet vendors are not capturing a proportional share of the revenue.

    This is not simply the outcome of a price war. It is a deeper signal: LLMs are shifting from a scarce, metered resource into a highly substitutable piece of infrastructure. When the usage of a commodity soars while its unit price keeps falling, its commercial nature has already changed. It behaves more like a utility — electricity, water, gas — than like a proprietary product that can sustain high margins over the long run.

    For technical teams, understanding this inflection point is critical. It means that if a model vendor’s business model remains “selling tokens,” then no matter how fast call volume grows, it can easily end up trapped in a pattern of growing revenue without growing profit. The real path forward is to convert technical advantage into comprehensive capability that enterprises recognize and that cannot be easily copied.

    2. The Real Bar for Enterprise Adoption: Stability, Task Execution, and Deployment Cost

    Many people assume that when enterprises choose between open-source and closed-source models, price is the only consideration. In practice, enterprise procurement is evaluated along far more dimensions, which broadly fall into three tracks.

    1. Stability and predictability. Enterprise systems need to sit inside production pipelines, with hard requirements on latency variance, output format consistency, and failure recovery. A model that occasionally hallucinates or produces malformed output can raise total cost through rework and human review, even at a very low unit price. Stability is essentially an implicit optimization of TCO (total cost of ownership).

    2. Task execution capability. What enterprises actually pay for is not “generating a piece of text” but “completing a business task” — for example, automatically extracting key fields from contracts, producing structured reports, or running multi-step workflows. Whether a model can reliably complete an end-to-end task determines whether it is a toy or a productivity tool.

    3. Deployment cost. Different access modes imply different cost structures: public cloud APIs billed by usage, dedicated instances billed by resource commitment, and on-premises deployment requiring upfront hardware and operational investment. Enterprises choose the best fit based on data compliance requirements, concurrency scale, and long-term usage.

    The fact that Chinese models have continued to expand their share of overseas enterprise markets is precisely a sign that they have built comprehensive competitiveness along these three tracks: faster iteration, more mature engineering optimization, and more efficient inference performance. Once these capabilities stack up, the focus of competition naturally shifts from “who is cheaper” to “who can get the job done.”

    3. Why Inference Costs Keep Falling: Four Engineering Levers

    Much of the cost-effectiveness advantage of enterprise-grade models comes from engineering work on the inference side. The following four levers are widely accepted and reusable across the industry.

    1. Low-precision quantization. Using lower-precision representations such as INT8 and INT4 to compress model weights and activations significantly reduces memory footprint and compute, within a controlled loss of accuracy. This is the most direct way to raise throughput per device and lower cost per token.

    2. KV cache and memory management. During autoregressive generation, the KV cache grows linearly with context length, which is the core bottleneck in long-context scenarios. Paged memory management — slicing the cache into reusable blocks — substantially improves concurrency utilization and reduces memory fragmentation.

    3. Continuous batching. Traditional static batching holds resources until every request in a batch finishes, leaving GPUs idle much of the time. Continuous batching schedules dynamically at the sequence level: as soon as one request completes, a new one is slotted in, moving hardware utilization from “luck of the draw” to “close to saturation.”

    4. Sparse architectures and speculative decoding. Mixture-of-Experts (MoE) architectures use sparse activation so that each inference pass only activates part of the parameters, trading lower compute for larger model capacity. Speculative decoding uses a small “draft model” to generate candidates quickly, which the larger model then verifies in batches, reducing the average number of decoding steps while preserving output quality.

    The combined effect of these techniques is to keep pushing down the inference cost per million tokens. A conceptual cost model makes the unit economics easier to grasp:

    1. # Conceptual illustration: how inference cost evolves as optimizations land
    2. # (for trend explanation only, not real data)
    3. def cost_per_million_tokens(throughput_tokens_per_s, gpu_hourly_cost):
    4. tokens_per_hour = throughput_tokens_per_s * 3600
    5. gpu_hours = 1_000_000 / tokens_per_hour
    6. return gpu_hourly_cost * gpu_hours
    7. # Before optimization: low throughput
    8. print(cost_per_million_tokens(throughput_tokens_per_s=2_000, gpu_hourly_cost=2.0))
    9. # After optimization: quantization + continuous batching + sparse architecture
    10. # raise throughput by several times
    11. print(cost_per_million_tokens(throughput_tokens_per_s=12_000, gpu_hourly_cost=2.0))

    With GPU prices held constant, a several-fold increase in throughput means unit cost drops to a fraction of its previous level. This is the engineering root of continuously falling inference costs, and the underlying support that lets vendors compete at lower prices while gradually shifting toward competition on comprehensive capability.

    4. The Structural Gap Between Usage and Revenue: An Economics View

    Return to the core contradiction from the first section: usage is up, revenue share is down. From a technical economics perspective, three overlapping effects are at work.

    First, cost is falling faster than willingness to pay — but in the opposite direction. Inference costs keep dropping and vendors cut prices proactively to compete for market share. Meanwhile, the spread of open-source models makes self-hosting an increasingly attractive alternative, further depressing paid conversion.

    Second, scale produces declining marginal cost, not pricing power. Greater usage lowers unit cost, but that surplus is passed through to customers through competitive price cuts rather than retained as vendor profit. This is a Jevons-paradox-style phenomenon: efficiency gains stimulate total demand without necessarily increasing total profit.

    Third, the open-source ecosystem changes how value is distributed along the chain. Once model weights are broadly available, value moves up to the layers above: engineering, integration, and scenario-specific services. Whoever can package a stable, reliable deliverable at the application layer is the one who captures value; the layer that merely offers “bare model access” is structurally weak in bargaining.

    Treating “usage scale” as equivalent to “commercial success” is therefore a misreading. What actually determines the health of a business is whether scale can be converted into high-value deliverables.

    5. Diversifying Monetization: Four Revenue Streams Beyond the API

    Given the visible ceiling on selling API access, leading model vendors are expanding from a single leg to multiple legs, smoothing revenue structure and increasing customer stickiness.

    1. Usage-based API (the base layer). Still the broadest entry point, responsible for customer acquisition and long-tail coverage, but margin room narrows as competition intensifies.

    2. Subscription services. Fixed-cycle payment priced per seat or per package, converting unpredictable metered billing into predictable recurring revenue (ARR), which also makes capacity planning easier for the vendor.

    3. Agent products. This is the key step up in value capture: moving from “selling model capability” to “selling the completed outcome of a task.” Agents use tool invocation, multi-step planning, and memory management to embed the model inside real business loops. Pricing logic can shift from “per token” to “per task / per outcome,” which naturally escapes the drag of falling token prices.

    A typical agent skeleton contains the following elements:

    1. [User intent] → [Planner] → [Tool executor]
    2. ↑ ↓
    3. [Memory] ←→ [Verifier]

    4. Enterprise application delivery. For requirements around data compliance, on-premises deployment, and deep customization, this covers dedicated deployment and solution integration. Such engagements carry high one-time value and high switching costs, making them an important lever for building long-term pricing power. In this direction, cloud platforms such as Baidu AI Cloud typically provide general capabilities — model services, elastic compute, containerized deployment, monitoring and alerting, and log services — that help enterprises move models into production stably without building the underlying infrastructure from scratch.

    6. Market Segmentation and Pricing Power: What Recent Price Increases Actually Signal

    Some vendors have recently raised API prices while extending into subscription and agent products. That is easily read as “pricing power returning,” but it deserves a cooler look.

    • The market is showing initial segmentation. Models at different capability levels are beginning to map to different customer segments and price bands. Frontier models hold high-value scenarios on the strength of task execution, while long-tail models serve cost-sensitive, standardized demand.

    • Short-term price increases are not the same as stable pricing power. Pricing power means customers still accept the increase when competitors do not follow. Validating it requires watching two variables: whether industry competition keeps intensifying (will someone grab volume at a lower price?), and whether compute supply improves (looser supply pushes unit costs down further and undermines the basis for price increases).

    • Long-term outcomes depend on “irreplaceability.” A vendor only truly holds pricing power when the model’s output is deeply embedded in the customer’s workflow and switching costs are high enough that migration is not easy. This is exactly why agents and deep industry solutions have more commercial resilience than bare API access.

    7. Practical Guidance for Engineering Teams

    • Do not treat token unit price as the only metric. When evaluating models, fold stability, task completion rate, end-to-end latency, and operational cost into a TCO model, so selection decisions are rational rather than price-driven.

    • Build the moat at the application layer first. For most enterprises, rather than agonizing over the foundation model, it is better to invest engineering effort in agent orchestration, result verification, and domain data loops — the parts that are hard to replace.

    • Design for cost elasticity. Use tiered caching, request routing (small models for simple tasks, large models for complex ones), and batch scheduling so inference cost stays controlled as business volume fluctuates.

    • Watch out for the “scale trap.” Growth in call volume is not the same as growth in revenue. Track “share of high-value tasks” rather than “total tokens,” and direct resources toward the core scenarios that actually pay.

    Conclusion

    The rise of Chinese LLMs has moved past the early stage of “trading low prices for market share.” As inference costs keep falling and the open-source ecosystem matures, a pure API business is being compressed into something closer to infrastructure. The next phase of competition no longer tests who charges less, but who can integrate model stability, engineering efficiency, and scenario understanding into comprehensive capability that enterprises are genuinely willing to pay for continuously. For developers and enterprise technology decision-makers, understanding this transition — from selling an interface to delivering capability — is key to catching the next growth curve in the LLM industry.