Open-Source Model Enterprise Spending: Why Chinese Models Became Mainstream

    A recent market research report shows that Chinese models account for roughly 89% of global enterprise spending on open-source models, with the top three models holding about 61%, 15%, and 11% respectively. This article clarifies what that figure does and does not measure, explains why enterprises are shifting procurement toward open-weight models with lower inference cost and greater deployment control, provides an evaluation framework for production use, and examines how open-source model adoption is reshaping AI infrastructure requirements and delivery certainty.

    A recent enterprise spending report from a market research firm shows that Chinese models collectively account for about 89% of global enterprise spending on open-source models. The top three models held approximately 61%, 15%, and 11% of that spending, respectively—about 87% combined—while the most widely adopted overseas open-source model family held only about 7%. In the context of the industry, the most important signal is not a specific ranking. It is the substantive shift in where enterprise payments are going: at a key entry point for enterprise deployment of open-source models, Chinese models have moved from “optional alternative” to “mainstream supply,” and they are beginning to influence the demand structure for global AI compute, networking, and cloud services through model services, inference calls, and industry integration.

    First, Clarify the Scope: 89% Is Enterprise Spending on Open-Source Models, Not All AI Spending

    One boundary needs to be made clear first: 89% refers to a share of global enterprise spending on open-source models. It is not equivalent to total global enterprise AI spending, nor to model downloads, developer counts, or benchmark rankings. Its value lies in the word “spending.” When enterprises are willing to pay for model-related products and services, it usually means the model has entered production systems or near-production systems, rather than remaining only in trials, demos, and community discussions.

    In the early days of open-source models, developers were more attracted by “free download,” “self-hosting,” and “active community.” But at the enterprise procurement stage, the decision chain is completely different. Enterprise budget approval depends on harder metrics: cost per Token, inference stability, concurrency capacity, private deployment feasibility, toolchain compatibility, license terms, version upgrade paths, and long-term service responsiveness. Even if a model has a large parameter count and a well-known brand, enterprises will not put it into production if it cannot guarantee stable output under high concurrency or cannot be smoothly managed by their operations systems.

    Therefore, a nearly 90% enterprise spending share shows that enterprise procurement logic has changed significantly. Enterprises are no longer paying solely for open-source brands and parameter scale. They are turning toward choices that are closer to implementation cost and delivery certainty. This shift is the core background behind the rapid share gain of Chinese models in the enterprise open-source model market.

    From “Optional” to “Mainstream”: Why Enterprises Changed Their Choices

    When enterprises procure open-source models, they are essentially looking for a technology path that can control costs, retain control over data assets, and quickly enter production systems. The competitiveness that Chinese open-source models have built in recent years is concentrated at three levels.

    1. Inference Cost Has Become the First Decision Variable

    For high-frequency enterprise use of large models, costs mainly come from inference, not training. After obtaining open weights, enterprises can combine their own compute resources and business scenarios with engineering changes such as quantization, sparsification, batch optimization, KV cache reuse, and dynamic routing to bring inference costs into a controllable range.

    More importantly, open weights give enterprises the ability to route model traffic. For tasks such as simple classification, summary extraction, and formatted output, they can choose smaller, efficient models. For complex reasoning, long-document analysis, and multi-step planning, they can call larger models. This ensures quality while avoiding sending all requests to one giant model and wasting compute and budget. This cost structure is highly attractive for high-frequency internal business use.

    2. Data Control and Flexible Deployment Location

    Enterprise data often involves customer privacy, trade secrets, and compliance requirements. Closed-source model APIs typically require data to pass through a cloud provider. Even with confidentiality agreements, many enterprises still find it difficult to fully set aside security concerns. Open weights allow enterprises to deploy in their own private networks, own data centers, or dedicated cloud environments, reducing the risk of data outflow at the root.

    This is especially critical for heavily regulated industries such as finance, healthcare, government, and manufacturing. Open-source models also allow enterprises to perform targeted fine-tuning, deeply binding the model to internal knowledge bases, business processes, and industry terminology. A customized model is no longer just a general-purpose tool; it can become a dedicated business engine. At the same time, model weights that are auditable, scannable, and rollback-capable make it easier for security and compliance teams to build trust.

    3. Ecosystem Alignment and Engineering Efficiency

    An open-source model is no longer an isolated weight file. It can be embedded as a foundational component in business chains such as RAG, agents, code generation, report analysis, customer service quality inspection, and document processing. What enterprises build around a model is often a complete system: data cleaning, vector retrieval, workflow orchestration, result caching, quality evaluation, monitoring and alerting, and cost analysis.

    Chinese model vendors’ investment in engineering services has also driven this trend. Examples include clearer format specifications, easier-to-use deployment packages, more complete industry examples, and more stable version iteration. The lower the migration cost for enterprises, the faster open-source models can enter production systems. Competition here has already evolved from “how strong the model is” to “how fast it can be delivered and how stable it is to operate.”

    How Enterprises Should Evaluate Whether an Open-Source Model Is Worth Investment

    When choosing an open-source model, enterprises cannot rely only on public leaderboards and promotional copy. A more robust approach is to build a repeatable evaluation system and use real business data and real workloads to verify whether the model meets production requirements. The following is a basic evaluation framework.

    Key Evaluation Dimensions

    • Task capability: Use enterprise-owned labeled data or real business questions to evaluate accuracy, recall, format compliance, and multi-turn conversation consistency in the target scenario, rather than relying on average scores from general benchmarks.
    • Inference performance: Measure P50/P99 latency, throughput, concurrent connections, timeout rate, and error rate under simulated production concurrency. These metrics directly determine real user experience and operational pressure.
    • Token cost: Calculate the average cost per thousand Tokens, including input, output, and cache hit conditions, and compare total cost across different models at the same quality level.
    • Deployment complexity: Consider model size, VRAM/RAM requirements, dependency environment, quantization support, distributed inference capability, and whether expensive hardware changes are required. The higher the deployment threshold, the greater the long-term operational cost.
    • Maintainability: Can model versions be tracked? Can canary releases be performed? Is there a rollback mechanism? Will old knowledge be retained after upgrading to a new version? These factors determine whether the model can run stably inside the enterprise over the long term.
    • License and compliance: Check terms covering commercial use, derivative models, redistribution, and data processing. Enterprises should also confirm the source of model training data and ethical risks to avoid supply-chain compliance hazards.
    • Service assurance: Does the model provider offer timely response, security patches, technical documentation, and training support? Open-source models do not mean “no one is responsible.” Enterprise open-source procurement always includes service commitments.

    Illustrative Evaluation Code

    The following pseudocode shows how to drive model selection with business data:

    1. # Pseudocode: enterprise model selection evaluation pipeline; not tied to any vendor API
    2. def evaluate_candidate(candidate, business_cases, quality_threshold=0.9):
    3. latencies = []
    4. costs = []
    5. quality_scores = []
    6. for case in business_cases:
    7. start = time.perf_counter()
    8. response = candidate.generate(
    9. prompt=case["prompt"],
    10. max_tokens=512,
    11. temperature=case.get("temperature", 0.2)
    12. )
    13. latencies.append(time.perf_counter() - start)
    14. costs.append(estimate_token_cost(response, candidate.price_per_1k))
    15. quality_scores.append(judge_quality(case["expected"], response))
    16. return {
    17. "avg_latency": average(latencies),
    18. "p95_latency": percentile(latencies, 95),
    19. "avg_cost_per_1k": average(costs) * 1000,
    20. "quality_rate": average(quality_scores),
    21. "qualified": average(quality_scores) >= quality_threshold
    22. }

    In actual engineering, it is advisable to include evaluation scripts in the CI/CD process. After each model version update, automatically run the business evaluation set and visualize changes in quality, latency, and cost. This avoids the situation where “the model looks stronger, but it is actually harder to use in business.”

    Open-Source Models Are Reshaping AI Infrastructure Requirements

    After enterprises deploy open-source models at scale, the center of gravity of AI infrastructure gradually expands from training clusters to inference platforms, data pipelines, and model governance systems. This imposes new requirements on both cloud service providers and teams building their own infrastructure.

    • Inference side: There is a need for elastic inference services with high throughput and low latency, including dynamic scaling, load balancing, request queuing, failover, and compute scheduling. Enterprises also need to split costs by tenant or business line to avoid resource waste.
    • Data side: For models to perform well, a data flywheel is essential. Document parsing, cleaning, chunking, vectorization, vector retrieval, knowledge base updates, and caching policies all need to be incorporated into a unified platform. Otherwise, even a strong model can produce hallucinations or irrelevant answers.
    • Model management side: Model repositories, version management, evaluation set management, canary releases, A/B testing, and rollback scripts are all standard for production-grade model systems. A model update is not “replacing a file”; it is a complete release process.
    • Observability: Enterprises need to monitor Token consumption per request, response time, success rate, refusal rate, content safety events, and cost trends. Without observability, an AI system is an uncontrollable black box.
    • Network and security: Large-model inference often involves larger data transmission and multi-node coordination, requiring reasonable VPC planning, internal network connectivity, access control, audit logs, and traffic cleaning. At the same time, new security risks such as prompt injection and data leakage must be prevented.

    For teams that have not yet built complete infrastructure, general cloud services can be used to quickly build a model service platform. For example, by combining container platforms, object storage, message queues, logging, monitoring, and alerting with a model service layer, teams can form a production-grade runtime environment for open-source models. If they choose a cloud provider with full-stack capabilities, the complexity can be further reduced.

    Delivery Certainty Is the Long-Term Competitive Barrier

    Model capability is only the starting point. Continuous delivery certainty is what enterprises are really buying. Delivery certainty includes several layers:

    • The model can be reproduced stably: with the same weights, the same parameters, and the same input, outputs are predictable or have clear behavioral boundaries.
    • The inference service does not collapse during peak periods: when traffic surges, the system can scale elastically, fail fast, and degrade gracefully.
    • Security patches and version upgrades follow a cadence: enterprises will not be trapped by a model that is no longer updated.
    • Costs are predictable: enterprises can estimate next quarter’s model spending based on business volume, rather than discovering after receiving a monthly bill that costs are out of control.
    • Service responsibility is clear: when a model has problems, enterprises know whom to contact, how to diagnose the issue, and how to roll back.

    Even if an open-source model has strong capabilities, enterprises will still hesitate if it lacks the above guarantees. Conversely, models that may not be the strongest at a single point but can provide complete deployment tools, stable version strategies, clear documentation, and fast response are more likely to win enterprise budgets.

    It is important to note that the 89% share is only one segment of enterprise spending on open-source models. It cannot be directly equated with comprehensive Chinese leadership in AI technology overall. In closed-source commercial models, frontier academic research, chips and system software, and developer ecosystems, the global competitive landscape remains diverse and complex. A more accurate understanding is this: in the step of turning open weights into products that enterprises can purchase, deploy, and operate, Chinese models have built strong competitiveness and are using this entry point to reshape the flow of global enterprise AI spending and infrastructure layout.

    For developers and enterprise technology decision-makers, the most important task at the current stage is to build a model evaluation and deployment system centered on real business needs and anchored by cost and delivery quality. Competition in open-source models has only just entered the stage of engineering depth and service certainty. The position of Chinese models in the enterprise spending map will also depend on whether they can continuously deliver model capabilities stably into every production system.