MaaS Token Economics: Why LLM API Revenue Doesn't Equal Profit

    A China-based large-model company's first annual report after its IPO shows how fast MaaS revenue can grow without producing profit. For the year ended December 31, 2025, revenue reached RMB 724 million (up 131.9% year over year) and the MaaS API platform's annual recurring revenue (ARR) hit roughly RMB 1.7 billion, yet API gross margin was only 18.9% (up from 3.3% a year earlier). This article explains why token-based revenue does not automatically convert into profit. It breaks down MaaS unit economics with a worked gross-margin model and reproducible Python code, then covers inference-efficiency techniques (continuous batching, chunked prefill, speculative decoding, KV-cache and prefix/semantic caching, quantization, and capacity management), pricing and model-routing strategies, customer and product structure, and the metering, monitoring, and FinOps metrics needed to run MaaS profitably at scale.

    From Selling Models to Selling Tokens: Why Growth and Profit Diverge

    On March 31, 2026, a China-based large-model company disclosed its first annual report after going public. For the year ended December 31, 2025, it reported revenue of RMB 724 million, up 131.9% year over year. Over the prior three years, revenue was approximately RMB 57 million, RMB 125 million, and RMB 312 million — a compound growth rate above 130% that accelerated each year. The annual recurring revenue (ARR) of its model-as-a-service (MaaS) API platform reached roughly RMB 1.7 billion, up about 60× year over year, placing it among the leading LLM providers in China.

    So why didn’t rapid revenue growth and soaring ARR automatically deliver high profit? The same report offers an uninspiring answer: the MaaS API platform’s gross margin improved from 3.3% in 2024 to 18.9% in 2025. That is a marked improvement, but still far short of the 50%+ gross margin the company posted overall during its track-record period.

    This “growth and profitability move out of step” pattern is not unique to one company — it is a structural challenge of the MaaS business model. This article does not focus on any single vendor. Instead, it abstracts the problem into two general questions: how to lower the inference cost per token, and how to raise revenue per unit as usage grows. The following sections cover the underlying principles, methods, code, and metrics across four dimensions.

    The Economics of MaaS: Why Selling More Doesn’t Mean Earning More

    Revenue and cost both scale with tokens

    The core unit of trade in MaaS is the token: customers pay by the number of input and output tokens, and the platform consumes inference compute by the number of tokens. Revenue and cost therefore sit on the same driver chain.

    • Revenue ≈ billable tokens × unit price
    • Inference cost ≈ tokens × per-token compute cost + fixed cost

    When revenue grows, inference cost grows almost in lockstep. Scale delivers marginal gains from only two sources: the per-token cost falls, or revenue per token rises faster than cost. Otherwise you get “the more you do, the thinner you earn.”

    From a financial standpoint, inference compute in a MaaS business is closer to a variable cost than the mostly-fixed cost of traditional software. Traditional software products can reach gross margins above 80%; MaaS has a gross-margin structure closer to cloud computing, where profit has to be “squeezed out” through scheduling efficiency and pricing strategy.

    Unit economics: locating profit leakage with a “gross-margin tree”

    Getting the math right is the first step to optimization. MaaS unit economics can be decomposed into a gross-margin tree:

    1. Business gross margin
    2. ├── 1 - platform fixed cost / total revenue → scale leverage (utilization, resource pooling)
    3. └── effective price / actual inference cost - 1 → unit leverage (pricing and efficiency)
    4. ├── effective price = Σ(tier price × tier token share) - discounts and giveaways
    5. │ → model mix, cache discounts, price tiers
    6. └── actual inference cost = compute cost / (effective throughput × utilization)
    7. ├── effective throughput ← batching efficiency, decoding efficiency, model-precision optimization
    8. └── utilization ← load balancing, capacity planning, peak-valley scheduling

    This tree carries two key judgments:

    • Gross margin is driven mainly by “effective price / actual inference cost.” Fixed-cost dilution can improve overall profit but has limited effect on API gross margin.
    • Cheap does not mean low margin. A high-priced model running on fully utilized GPUs often has a lower per-token cost than a low-priced model running on idle cards.

    The output-to-input billing-token ratio below is only an example, used to illustrate the calculation:

    Variable Meaning Example value
    I Input billable tokens (millions) 1,200
    O Output billable tokens (millions) 150
    r Output-to-input billable-token ratio (example) 3
    p Input unit price (RMB per million tokens, example) 1.0
    c Input-side unit inference cost (RMB per million tokens, example) 1.2
    k Output/input unit cost ratio (example) 3

    Actual inference cost = (I + k × O) × c = (1200 + 3 × 150) × 1.2 = RMB 1,980

    Pricing method Revenue calculation Revenue Gross margin
    Linear per-token billing (1200 + 3 × 150) × 1.0 RMB 1,650 -20.0%
    Separate input/output pricing (output = 3× input) 1200 × 1.0 + 150 × 3.0 RMB 1,650 -20.0%
    Separate input/output pricing (output = 5× input) 1200 × 1.0 + 150 × 5.0 RMB 1,950 -1.5%
    With context caching (90% input hit, billed at 80%) (120 + 1080 × 0.8) + 150 × 5.0 RMB 1,734 +14.2%
    Same price, unit cost down to 0.8 (1200 + 450) × 0.8 RMB 1,650 +20.1%
    Small tasks routed to lightweight model (output 120, cost ratio 2, price 0.5) 1200 × 1.0 + 120 × 2.5 RMB 1,500 +12.0%

    You can reproduce and extend these calculations with the Python code below, so teams can quickly evaluate how different strategies affect margin:

    1. from dataclasses import dataclass
    2. @dataclass
    3. class Workload:
    4. input_mtok: float # Input tokens (millions)
    5. output_mtok: float # Output tokens (millions)
    6. cache_hit_rate: float = 0.0 # Input prefix hit rate, range [0,1]
    7. cache_discount: float = 1.0 # Billing discount for the hit portion, range (0,1]
    8. small_share: float = 0.0 # Share routed to the lightweight model, range [0,1]
    9. def unit_economics(w: Workload, price_in: float, price_out: float,
    10. cost_in: float, out_cost_ratio: float,
    11. small_price_ratio: float = 0.5,
    12. small_out_cost_ratio: float = 2.0) -> dict:
    13. """Return billed tokens, revenue, cost and gross margin; all parameters are examples."""
    14. s = w.small_share
    15. c_in, c_out = 1 - s, 1 - s * (1 - small_price_ratio)
    16. k = 1 - s * (1 - small_out_cost_ratio)
    17. # Billed tokens: cached portion billed at discount, the rest at full price
    18. billed_in = w.input_mtok * ((1 - w.cache_hit_rate)
    19. + w.cache_hit_rate * w.cache_discount) * c_in
    20. billed_out = w.output_mtok * c_out
    21. revenue = billed_in * price_in + billed_out * price_out
    22. cost = w.input_mtok * cost_in * c_in + k * w.output_mtok * cost_in * c_out
    23. return {
    24. "billed_tokens": billed_in + billed_out,
    25. "revenue": revenue,
    26. "cost": cost,
    27. "gross_margin": (revenue - cost) / revenue if revenue > 0 else 0.0,
    28. }
    29. if __name__ == "__main__":
    30. base = Workload(input_mtok=1200, output_mtok=150)
    31. scenarios = [
    32. ("Linear per-token pricing", unit_economics(base, 1.0, 3.0, 1.2, 3)),
    33. ("90% cache hit", unit_economics(
    34. Workload(input_mtok=1200, output_mtok=150,
    35. cache_hit_rate=0.9, cache_discount=0.8), 1.0, 5.0, 1.2, 3)),
    36. ("Unit cost down to 0.8", unit_economics(base, 1.0, 3.0, 0.8, 3)),
    37. ("30% of requests to lightweight model", unit_economics(
    38. Workload(input_mtok=1200, output_mtok=150, small_share=0.3), 1.0, 5.0, 1.2, 3)),
    39. ]
    40. for name, result in scenarios:
    41. print(f"{name}: revenue {result['revenue']:.0f} RMB, "
    42. f"cost {result['cost']:.0f} RMB, gross margin {result['gross_margin']:.1%}")

    There are two common mistakes in these calculations:

    1. Output tokens must be costed separately. Because output uses autoregressive, token-by-token decoding, its per-token compute cost is usually significantly higher than the input side. Linearly extrapolating from the input unit price systematically underestimates cost.
    2. Don’t assume margins improve automatically when models get cheaper. If you bill per call rather than per token (common in application-type products), the benefit of lower unit cost can be offset by “token bloat per call.” Agent calls, long context, and chain-of-thought output all amplify this bloat. Per-token MaaS billing avoids this risk by design, but only if pricing keeps a reasonable ratio to token cost.

    Inference Efficiency: Engineering Ways to Lower Per-Token Cost

    What determines inference cost is the effective throughput per unit time per accelerator card. On the same card, different workloads can produce per-token costs that differ by several times. The optimization idea comes down to one sentence: make compute produce as many effective tokens as possible, as fast as possible.

    Scheduling: from “wait-for-the-batch” to per-request entry and exit

    Traditional inference runs in fixed batches: all requests enter and finish together. Within a batch, short requests must wait for long ones, and completed requests sit idle — compute is wasted on padding. Continuous batching instead schedules at the level of individual requests and reorganizes the batch at every decode step: completed requests exit immediately, and waiting requests are slotted in at any time.

    Combined with chunked prefill, a long input is split into small chunks and interleaved with requests that are already decoding. This prevents a long input from monopolizing compute and slowing the streaming output of other requests.

    The scheduling loop below is illustrative and omits low-level details such as memory and KV-cache allocation:

    1. def scheduler_loop(pending, engine, max_batch_tokens, max_running):
    2. running = []
    3. while pending or running:
    4. # 1. Admit new requests per token-bucket budget, reserving KV cache for this step's decoding
    5. while pending and len(running) < max_running and engine.can_admit():
    6. running.append(pending.popleft())
    7. # 2. Build this step's batch:
    8. # decoding requests contribute 1 token each; waiting requests get prefill chunks within the remaining budget
    9. batch = build_step_batch(running, engine, max_batch_tokens)
    10. outputs = engine.step(batch)
    11. # 3. Complete streaming output, free memory and return to step 1
    12. for req, token in zip(batch.seqs, outputs):
    13. yield_token(req, token)
    14. if token.is_eos or req.is_finished():
    15. running.remove(req)
    16. engine.release(req)

    Scheduling optimization has three core constraints:

    • Constrain throughput and latency together: admission should look at both memory headroom and latency budgets such as time to first token (TTFT);
    • Handle requests by priority: interactive requests go first, batch requests act as filler load;
    • Guard against starvation of long requests: use aging or priority-weighted fair queuing so long requests aren’t starved of scheduling for long periods.

    Decoding: fewer autoregressive steps and lower memory overhead

    During decoding, generating each token requires reading the entire KV cache from memory, so the bottleneck is usually memory bandwidth, not compute. Three directions improve decoding efficiency:

    1. Speculative decoding: a lightweight draft model or multi-step prediction heads propose several candidate tokens at once, then the large model verifies them in parallel, accepting multiple tokens in a single forward pass and reducing the number of autoregressive steps.
    2. Sparsification: sparse-activation structures such as mixture-of-experts (MoE), or weight quantization, reduce the data that must be moved per forward pass.
    3. KV-cache optimization:
      • Use grouped-query attention (GQA), multi-query attention (MQA), and similar structures to compress cache size;
      • Use KV quantization, windowing, or sparsification to cut memory usage under long context;
      • Use paged management (like the page-table mechanism of OS virtual memory) to reduce memory fragmentation and let different requests share the same cache segment.

    Caching: reuse “repeated computation”

    • Prefix caching: system prompts, tool definitions, and long documents repeat heavily across sessions; reusing their KV cache drives the prefill cost of repeated prefixes toward zero.
    • Semantic caching: for high-frequency repeated questions (such as FAQ-style Q&A), return cached results directly. This requires clear freshness boundaries and isolation between tenants.

    Caching design must follow two principles:

    • Multi-tenant isolation: cache keys must include model version, tenant ID, and a hash of the full prefix to prevent unauthorized reads.
    • Discount-pricing alignment: requests that hit the cache should be billed at a discounted price.

    The reason: without a discount, customers will artificially split the same request into multiple calls to avoid the cache, so the platform neither collects revenue that matches the cost it saved nor gets the full context — which actually lowers service quality.

    Model layer: trade precision for throughput

    Low-precision quantization such as INT8 and FP8, along with model-compression techniques like knowledge distillation and pruning, significantly reduce memory usage and raise compute throughput. In industry practice, model-level optimization is usually combined with kernel-level optimization, and actual gains must be based on measured results for the target model and hardware.

    Engineering must hold a quality baseline: maintain a fixed evaluation set and regression pipeline, and compare accuracy, hallucination rate, and long-context performance item by item before and after quantization, so you don’t end up with “lower cost but collapsed quality.”

    Capacity layer: eliminate “paying for the peak” waste

    Elastic scaling is a natural cloud capability, but capacity management for inference services is trickier:

    • Model loading and memory allocation take a long time, so scaling can’t keep up with sudden traffic spikes;
    • Running interactive and batch workloads together makes them contend for memory.

    Practical approaches include:

    • Deploy interactive and batch workloads in separate pools;
    • Keep a minimum number of replicas for always-on services and spin up the rest on demand;
    • Smooth peaks and valleys with request queuing, rate limiting, and graceful degradation;
    • On cloud platforms such as Baidu AI Cloud, these capabilities can be supported by container-platform autoscaling, message queues that smooth peak and valley traffic, and model-version distribution backed by object storage.

    Pricing and Model Routing: Raising Prices Without Losing Volume

    Cutting prices doesn’t always add profit: two rules of price elasticity

    Let ε be the price elasticity of demand (negative) and m the gross margin. Two rules follow:

    1. Condition for a price increase to raise gross margin: ε < -1 / (1 - m). When demand is inelastic, raising price can increase both gross profit and gross margin.
    2. Condition for a price cut to raise gross margin: ε > 1 / (m - 1). Only when demand is elastic can cutting price lead to higher volume and higher margin.

    For example, when API gross margin is very thin (say m = 5%), raising price requires ε < -1.05 — essentially requiring perfectly inelastic demand — while cutting price requires ε > 20, an elasticity that almost never exists in the market. This mathematically explains why a price war alone can hardly improve profit during the “revenue up, profit flat” phase. Measure the true elasticity of your own customer base before deciding.

    Making price increases “painless”: capacity matters more than price cuts for retention

    Price increases usually cause churn not because customers care about unit price, but because their workloads won’t run on the new model. Context truncation in their ticketing system, throttled concurrency, and frequent failures on long-document requests all translate directly into abandonment.

    By contrast, 800K or even million-level context windows, output speeds of hundreds of tokens per second, and strict concurrency and SLA guarantees form the foundation for “raising price without losing volume.” The engineering priority should be “expand capacity first, then discuss price.” Tiered quotas, burst-traffic queuing, retry on failure, and fallback degradation should all be part of a pre-launch capacity review.

    Replace single linear pricing with hybrid pricing

    Under a single pricing structure, the workload determines the margin. Here is a set of illustrative workloads:

    Workload Avg input length Avg output length Typical scenario
    Batch summarization/classification Long Short Document summarization, content moderation
    Code completion/rewriting Medium Medium Coding assistants
    Agent / chain-of-thought reasoning Medium Very long Tool calls, multi-step reasoning

    Gross margin by pricing method (parameters are examples):

    Pricing method Batch summarization/classification Code completion/rewriting Agent / chain-of-thought reasoning
    Linear per-token pricing 5.0% 5.0% 5.0%
    Tiered input/output pricing 18.6% 12.2% 0.2%
    Tiered pricing + volume tier discounts 18.6% 12.2% 0.2%
    1. def blended_pricing(input_len, output_len, tiers):
    2. """Tiered pricing + volume discounts (illustrative); returns margin and effective price (RMB per million tokens)."""
    3. tokens = input_len + output_len
    4. for upper, discount in tiers:
    5. if tokens <= upper:
    6. break
    7. eff_out_price = sum(
    8. rate if output_len > lower else 0
    9. for lower, rate in sorted(output_price_tiers)
    10. )
    11. revenue = (input_price * input_len + eff_out_price * output_len) * discount
    12. cost = COST_PER_TOKEN * tokens
    13. margin = (revenue - cost) / revenue
    14. effective_price = revenue / tokens
    15. return margin, effective_price

    “Tiered pricing” here carries two meanings:

    • Output tokens carry a higher unit price, reflecting the real cost difference on the decoding side;
    • Once context exceeds a certain length, the long-context portion carries a higher unit price, avoiding dilution of the average price by long inputs.

    The core goal is not to set high prices but to make the price structure match the cost structure. On that basis, volume tier discounts can trade margin for more stable cash flow — token prepayment, annual commitments — and latency-insensitive requests can be steered to off-peak or batch channels.

    Intelligent routing: allocate compute by task difficulty

    Not every request deserves the flagship model. Route by task type, difficulty, and latency budget to different model tiers to balance cost, quality, and experience. Below is a simplified cost-aware cascade-routing example; thresholds must be calibrated from offline evaluations:

    1. import re
    2. MATH_HINT = re.compile(r"calculate|solve|prove|equation|reason")
    3. CODE_HINT = re.compile(r"code|function|api|error|implement")
    4. def classify_task(prompt: str) -> str:
    5. """Give an initial route based on task type (illustrative; should be calibrated with evals)."""
    6. if CODE_HINT.search(prompt):
    7. return "code" # route to a stronger coding model
    8. if MATH_HINT.search(prompt):
    9. return "reasoning" # flagship model + reasoning boost
    10. return "lite" # prefer the lightweight model
    11. def cascade_answer(prompt: str, call_model, max_attempts: int = 2):
    12. """Cascade routing from light to heavy: escalate to the flagship model only when the lightweight one is unreliable."""
    13. task = classify_task(prompt)
    14. plan = [("lite", "reasoning"), ("reasoning",), ("lite",)][:max_attempts]
    15. for names in plan:
    16. answer = call_model(names[-1], prompt, task=task)
    17. if call_model.verify(answer):
    18. return answer
    19. return call_model("reasoning", prompt, task=task)

    Routing needs four supporting mechanisms:

    • Difficulty predictor: a small model or classifier can run at the request entry point;
    • Quality verifier: format checks, rule validation, a second-model review, or tool verification;
    • Failure escalation: automatically escalate to a stronger model when verification fails, with an escalation cap;
    • Routing decision logs: record the routing reason, model consumption, and verification result for offline analysis and threshold iteration.

    One point to stress: routing saves compute cost, not token-billing revenue. But if you pass the saved cost on to price-sensitive long-tail customers, you can win usage volume while protecting margin.

    Customer and Product Structure: How High-Value Customers Balance Margin and ARR

    Looking at customer structure, enterprise customers usually sit in the mid-to-upstream of the AI value chain — mainly platform integrators and vertical application vendors. They embed model APIs into their own products for delivery, are closer to the end scenario than the model vendor, and have more incentive to integrate deeply and use the model long term. As a result, a higher share of high-value customers tends to lift both gross margin and ARR at the same time.

    Prioritize AI-native companies: trade integration depth for stickiness

    AI-native companies treat the model as a core production factor, not an add-on feature. Rapid prototyping, agent-style tool calls, and continuous experimentation with the latest model capabilities give them a naturally “high-consumption, fast-iteration” profile. Serving them well comes down to four levels:

    1. Self-service onboarding: standardized APIs, clear documentation, SDKs, and reusable code samples so developers get their first scenario running in a day or two;
    2. Platform tooling: online playgrounds, prompt debugging, batch testing, evaluation, and monitoring form a conversion path from trial to paid;
    3. Dedicated instances: for customers with high usage and strict SLAs, offer dedicated deployment with guaranteed throughput, balancing stability and resource utilization;
    4. New-model launches: co-develop scenarios with customers, gaining real feedback while creating switching costs.

    Serve scaled enterprises: hold margin with a hybrid model

    Enterprise customers demand data compliance, cost control, and stability, which a single API model can’t fully cover. Common combinations:

    • Public-cloud API + dedicated instances: general scenarios go through the API, core business runs on dedicated resources — ensuring stability while raising utilization;
    • Private and hybrid deployment: delivered on demand for industries where data cannot leave their domain;
    • Joint operations: deliver together with industry ISVs and system integrators, sharing revenue.

    Note that dedicated-instance pricing must cover reserved cost; otherwise a seemingly long-term partnership can turn into a low-margin burden. The gain from a hybrid model comes from “peak-valley complementarity”: interactive traffic has peaks, and batch workloads fill the troughs, raising overall utilization.

    Capture the long tail with API economics: low price isn’t the goal, scale is

    • Limited-time free or heavily discounted new models: lower the trial barrier, trade word-of-mouth for usage, and build a “try → production → pay” funnel;
    • Free quota + tiered pricing: keep the free quota to small-scale trials, and use tiered pricing so higher usage means a lower average price;
    • Ecosystem programs: support universities, startups, and open-source communities to cultivate long-term users.

    Whether a low-price strategy holds depends on whether unit cost falls with scale. Long-tail traffic has short, bursty requests, so it most needs prefix caching and elastic scheduling to amortize cost.

    Vertical scenarios: productize domain know-how

    Beyond the general API, productized solutions for vertical scenarios can raise average order value and build a moat:

    • Coding tools: code completion, repo-level Q&A, unit-test generation — high-frequency calls with strong willingness to pay;
    • Content production: long-form writing, marketing copy, short-drama and audio/video scripts;
    • Data services: data labeling, synthetic data generation, data cleaning and knowledge processing.

    These products need supporting domain evaluation sets, prompt templates, and fine-tuning capabilities. The key is to turn deliverables into reusable platform capabilities rather than one-off projects.

    Metering, Monitoring, and FinOps: Make Every Unit of Compute Visible

    Cost governance for MaaS depends on observability. If you can’t answer “which customer, which model, which scenario consumes how many tokens and delivers how much margin,” both price increases and cost cuts lose their basis. Build at least the following metrics:

    Layer Core metrics Purpose
    Business ARR, billable tokens, paying customers, net revenue retention (NRR) Judge whether revenue is recurring or one-off
    Commercial Margin by customer/scenario, cache hit rate, free-quota cost share Locate margin leakage
    Inference Effective throughput per accelerator, TTFT, TPOT, batching efficiency, first-token latency P99 Evaluate unit cost
    Resource Accelerator utilization, memory usage, request queue time, scale-up/scale-out time Evaluate capacity efficiency
    Quality Eval-set pass rate, human feedback rate, retry rate, degradation rate Hold the quality baseline while cutting cost

    Metering data should be based on API call logs, fed via message queues into streaming or offline compute pipelines, then into a data warehouse for margin attribution. Monitoring and alerting can cover scenarios such as:

    1. # Metric names are illustrative; adjust to your monitoring system's conventions
    2. groups:
    3. - name: maas-unit-economics
    4. rules:
    5. - alert: GrossMarginLow
    6. expr: gross_margin_ratio{model!=""} < 0.10
    7. for: 30m
    8. labels: {severity: warning}
    9. annotations: {summary: "Model gross margin below 10% for 30 consecutive minutes"}
    10. - alert: CacheHitRateDrop
    11. expr: cache_hit_ratio < 0.50
    12. for: 15m
    13. labels: {severity: warning}
    14. annotations: {summary: "Cache hit rate dropped significantly; unit cost may rise"}
    15. - alert: FirstTokenLatencyHigh
    16. expr: histogram_quantile(0.99, ttft_seconds_bucket) > 2
    17. for: 10m
    18. labels: {severity: critical}
    19. annotations: {summary: "TTFT P99 above 2 seconds; possible scale-up or queue backlog"}

    A Reusable Path to Profitability: A Six-Step Checklist

    1. Set up accounting: build margin attribution by customer, model, and scenario so every call’s cost can be computed.
    2. Improve efficiency: prioritize prefix caching, continuous batching, low-precision inference, and KV-cache optimization, and establish a quality regression process.
    3. Adjust pricing: use tiered output pricing, long-context premiums, cache-hit discounts, and volume tier discounts, aligning price with cost structure.
    4. Route: deploy task classification, quality verification, and failure escalation so lightweight models handle simple requests.
    5. Scale: expand capacity and guarantee SLAs before raising prices, minimizing price-driven churn.
    6. Optimize structure: raise the share of high-value customers and scenarios, and stabilize margin with dedicated instances and hybrid deployment.

    Conclusion: MaaS’s Long-Term Competitiveness = Efficiency × Pricing

    The jump in revenue from RMB 57 million to RMB 724 million, along with roughly RMB 1.7 billion in platform ARR, marks a shift in the domestic LLM industry from a “contest of model capability” to a “contest of sustained service capability.” ARR matters because it measures whether customers keep calling and steadily consuming tokens, not one-off project revenue. The rise in API gross margin from 3.3% to 18.9% shows that MaaS’s “revenue up, profit flat” is not destiny but a result that can be systematically improved through engineering and business levers.

    For developers, understanding token economics means looking beyond unit price when choosing a model — also evaluating cache hit rate, batching efficiency, short/long request matching, and how output length affects cost. For enterprise users, cost optimization and quality assurance are equally important: routing tiers, cache reuse, and capacity planning are the key steps for turning model capability into business value.

    The ultimate competitive moat is not about who pushes prices lowest, but about who can make the same compute produce more effective tokens and sell the same tokens at a more reasonable price. Efficiency × Pricing = Gross Margin — this is both the underlying formula of the MaaS business model and a question every model-service provider must keep answering.