Back to series
· 8 min read

Open-Source, Open-Weight, and Closed-Source Models: The Openness and Tech Ecosystem of Large Models


I. Why Do We Need to Distinguish Between Different Approaches to Model Openness?

With the development of large language models, different routes have gradually emerged for how models are obtained and used.

Some models allow users to download the weights, inspect the code, and even train and modify the models themselves; some models only release the weights, while the training data and the full training process are not made public; and some models can only be used through an API or product provided by the vendor.

These models may all have strong capabilities, but they differ markedly in technical transparency, deployment methods, modification permissions, and commercial-use restrictions.

There are three common types:

  1. Open-source model: In accordance with the relevant open definition, sufficient model-related materials are provided, and users are allowed to use, study, modify, and redistribute the model within the scope of the license.
  2. Open-weight model: The trained model weights are made public, and users can download and run them, but the training data, full training code, or other key materials are not necessarily public.
  3. Closed-source model: The core implementation and weights of the model are usually not public, and users mainly use it through official products, APIs, or controlled platforms.

Particular attention should be paid to this:

Open weights are not the same as fully open source, and being able to download a model does not mean having unrestricted usage rights.

II. What Is an Open-Source Model?

2.1 Basic Definition of Open-Source Models

What open-source models emphasize is not only that the model files can be downloaded, but also that the model-related materials and usage rights have a relatively high degree of openness.

For artificial intelligence models, open source usually involves:

  • Model architecture and implementation code.
  • Model weights.
  • Information about training data.
  • Data processing and training methods.
  • Training and evaluation code.
  • Licenses for use, modification, and redistribution of the model.

Among these, model weights are an important part of an open-source model, but they are not the whole of it.

Traditional software open source usually focuses on whether the source code is public and whether the license permits use, modification, and distribution.

AI models also have a special issue: even if the model weights and inference code are made public, it may still not be possible to fully reproduce the model's training process.

For example:

  • The training data may not be public.
  • The data cleaning and filtering process may be incomplete.
  • The training code may not be released.
  • The compute and infrastructure required for training may be unavailable.
  • Some data may be subject to copyright, privacy, or contractual restrictions.

Therefore, the degree of openness of an AI model cannot be judged simply by whether a GitHub repository is public.

2.2 Open Source AI Definition

The Open Source Initiative (OSI) has published the Open Source AI Definition to clarify the conditions an artificial intelligence system must meet to qualify as open source.

Its core focus areas include:

  1. Freedom to use: Allow users to use the model for different purposes.
  2. Freedom to study: Be able to study how the model works.
  3. Freedom to modify: Be able to modify the model and adapt it as needed.
  4. Freedom to share: Be able to share the original model or modified versions.

To realize these freedoms, sufficient materials also need to be provided so that users can understand and modify the model.

Important materials include:

  • Model parameters or weights.
  • Model architecture information.
  • Data-related information, including training data sources, processing methods, and other materials sufficient to understand the training process.
  • Necessary code and technical documentation.

Note that specific judgments about open-source AI should be based on the definition of the relevant version and the actual released materials. A model publisher calling its model Open Source does not automatically mean that it satisfies OSI's Open Source AI Definition.

2.3 Advantages of Open-Source Models

1. High technical transparency

Researchers can inspect the model architecture, weights, and training-related materials and study model behavior in greater depth.

2. Strong modifiability

The model structure, training strategy, and parameters can be modified according to actual needs.

3. High deployment autonomy

The model can be deployed on one's own servers, private cloud, or local devices, reducing dependence on a single model provider.

4. Conducive to building the technical ecosystem

Developers can build inference frameworks, fine-tuning tools, quantization solutions, and application ecosystems around the model.

5. Facilitates research reproducibility

When materials are sufficiently complete, model training, evaluation, and behavioral characteristics can be studied more effectively.

2.4 Limitations of Open-Source Models

Open source does not mean there is no cost.

  • Training large models still requires substantial GPU resources.
  • Deployment and inference require computing, storage, and operations capabilities.
  • Public weights do not mean the model can be fully reproduced.
  • Models may have safety, bias, and factual issues.
  • Licenses may impose restrictions on commercial use, redistribution, or specific use cases.
  • Updates, maintenance, and security responses for the model must be handled by the user.

Therefore, open-source models offer a higher degree of technical autonomy, not a free, complete solution.

III. What Is an Open-Weight Model?

3.1 Basic Definition of Open-Weight

An open-weight model is one in which the weight files after model training are made public; users can obtain these parameters and run the model in a supported environment.

Weights are the parameters learned by a neural network during training.

Take a simple neural network as an example:

y=f(Wx+b)

Where:

  • W: model weights.
  • b: bias parameter.
  • x: input.
  • y: model output.

For large language models, weights usually include:

  • Token Embedding parameters.
  • Attention layer parameters.
  • FFN layer parameters.
  • LayerNorm or RMSNorm parameters.
  • Output projection parameters.

Model weight files store the values of these parameters after training is complete.

After obtaining the weights, users can load the model with a compatible inference framework, perform local inference, and, within the scope permitted by the license, carry out fine-tuning, quantization, or other adaptation.

3.2 Why Open Weights Are Not the Same as Open Source

Because weights describe only part of the information about a model.

A complete large-model training process also involves:

  • Training data and its sources.
  • Data cleaning, filtering, and deduplication strategies.
  • Model architecture design.
  • Training code.
  • Optimizers and training configurations.
  • Checkpoints from the training process.
  • Evaluation methods and results.

Open-weight models may release only the final parameters without disclosing these materials.

For example, after downloading a model weight file, users can run the model but may not be able to know:

  • What training data the model actually used.
  • What kind of cleaning and filtering the data underwent.
  • What learning rate scheduling strategy was used for training.
  • Whether the model used a special data mixture.
  • How to reproduce the model from scratch.

Therefore, open weights address the availability of model parameters, whereas full open source also involves more materials and freedom of use.

3.3 Capabilities of Open-Weight Models

Open-weight models typically allow users to do the following within the scope specified by the license:

  1. Download model weights.
  2. Run inference locally or in the cloud.
  3. Fine-tune using methods such as LoRA and QLoRA.
  4. Quantize the model.
  5. Develop inference services based on the model architecture.
  6. Distribute the model and deploy it commercially under permitted conditions.

Note, however, that whether these actions are permitted ultimately depends on the model license.

Open weights do not mean there are no license restrictions.

Some models may require:

  • Retaining copyright notices and license text.
  • Labeling modified models.
  • Including specified materials when redistributing.
  • Applying for additional authorization for commercial use at certain scales.
  • Complying with acceptable use policies.
  • Not being used in certain restricted scenarios.

Therefore, you should not look only at whether the model can be downloaded; you must also read the model's actual license and usage policy.

3.4 Typical Ecosystem of Open-Weight Models

Open-weight models have now developed a relatively mature ecosystem.

Common model families include:

  • Llama: a model series released by Meta.
  • Qwen: a model series released by Alibaba.
  • DeepSeek: a model series released by DeepSeek.
  • Gemma: a model series released by Google.
  • Mistral: a model series released by Mistral AI.
  • Phi: a model series released by Microsoft.

Note that different versions, sizes, and uses of these model families may adopt different licenses and openness strategies. You cannot directly infer the openness of a specific version from the model family name.

4. What Is a Closed-Source Model?

4.1 Basic Definition of a Closed Model

A closed-source model generally refers to a model whose core implementation, weights, and training materials are not publicly disclosed, so users cannot directly obtain the complete model parameters.

Users generally use them through:

  • Official web products.
  • Official APIs.
  • Enterprise-grade model services.
  • Cloud-hosted services.
  • Controlled interfaces provided by partners.

For example, a developer can call a model API:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="模型服务名称",
    input="解释一下 Transformer 的核心原理。"
)

print(response.output_text)

The example only demonstrates the API call format; the actual model name, SDK version, and API parameters need to be configured according to the specific service documentation.

Developers only need to submit input and receive the results returned by the model; they do not need to manage the underlying model weights and inference infrastructure themselves.

4.2 Service Architecture of Closed-Source Models

Closed-source models generally use a hosted service architecture.

flowchart TB
    A["User Application"] --> B["Call Model API"]
    B --> C["Authentication and Access Control"]
    C --> D["Request Routing and Scheduling"]
    D --> E["Model Inference Service"]
    E --> F["GPU Cluster Executes Inference"]
    F --> G["Generate Model Output"]
    G --> H["Return API Response"]
    H --> I["User Application Processes Result"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#E5F0E9,stroke:#83A995,color:#315D49

In this architecture, the model provider is responsible for:

  • Model training and updates.
  • GPU cluster management.
  • Inference service deployment.
  • Request scheduling and load balancing.
  • Service monitoring and failure recovery.
  • Model security policies and access control.

Users are mainly responsible for business applications, prompt design, data processing, and interface integration.

4.3 Advantages of Closed-Source Models

1. Low barrier to use

No need to download, deploy, and maintain massive model weights yourself.

2. Access to managed compute

No need to set up your own GPU cluster; you can use model capabilities through an API.

3. Model updates are handled by the vendor

The model vendor can continuously update model capabilities, inference systems, and security mechanisms.

4. Easier and faster integration

Models can be integrated into existing business systems through an API.

5. Access to supporting services

Some services also offer capabilities such as structured output, tool calling, batch processing, and enterprise permission controls.

4.4 Limitations of Closed-Source Models

  • Cannot directly obtain model weights.
  • Cannot fully control the model's internal implementation.
  • Cannot freely modify the underlying model architecture.
  • Dependent on the provider's API, pricing, and service availability.
  • Need to pay attention to data processing, privacy, and compliance policies.
  • Model version upgrades may affect output behavior.
  • Providers may change model names, interfaces, and usage limits.

For enterprises, closed-source models also require considering vendor lock-in.

If a business system depends heavily on a single model service, migrating to another model may require re-adapting prompts, tool calling, structured output, and the evaluation system.

V. Core Differences Between the Three Model Openness Approaches

5.1 Comparison Dimensions

Comparison dimension Open-source model Open-weight model Closed-source model
Model weights Usually public Public Usually not public
Inference code Necessary materials provided per the openness definition Not necessarily public Usually not public
Training code Sufficiently relevant materials must be provided Not necessarily public Usually not public
Training data Sufficient data-related information provided; specific materials are constrained by the definition Usually not fully disclosed Usually not public
Model architecture Relevant information is public Architecture configuration usually provided Usually not fully disclosed
Local deployment Usually possible Usually possible Usually not possible to deploy the original model directly
Model modification Within the scope permitted by the license Depends on the license Usually not possible to directly modify the underlying model
Commercial use Depends on the license Depends on the license Depends on the terms of service
Degree of self-reliance and control Relatively high Relatively high, but affected by materials and licensing Relatively low
Typical usage Download, study, modify, deploy Download weights, local inference, adaptation Official products, APIs, managed services

Here, "open-source model" refers to the strict concept as understood under the AI open-source definition. In the actual market, many products called open-source models are, strictly speaking, closer to open-weight models.

5.2 Openness Is Not a Simple Binary Judgment

In reality, model release approaches are not limited to fully open and fully closed.

A model's degree of openness can be observed from multiple dimensions:

Openness dimension Question of interest
Weight openness Can the model parameters be downloaded?
Architecture openness Is the network structure and configuration disclosed?
Code openness Are training and inference code provided?
Data transparency Are training data sources and processing methods disclosed?
Training transparency Is the training process and key configuration disclosed?
License openness Are research, modification, redistribution, and commercial use permitted?
Evaluation transparency Are evaluation methods and test results disclosed?

Different models may have different degrees of openness across these dimensions.

For example:

  • Model weights are public, but training data is not.
  • Model code is public, but weights are not.
  • Weights and code are public, but commercial use is restricted.
  • Weights can be downloaded, but modified models cannot be freely redistributed.

Therefore, when evaluating a model's degree of openness, you should check each item individually rather than just looking at what name the publisher uses.

VI. Technical Architecture Differences Between Open-Source and Closed-Source Models

6.1 Local Deployment of Open-Source or Open-Weight Models

When using open-weight models, users can directly manage the model runtime environment.

flowchart TB
    A["Get model weights"] --> B["Prepare runtime environment"]
    B --> C["Configure GPU and VRAM"]
    C --> D["Load Tokenizer"]
    D --> E["Load model weights"]
    E --> F["Start inference engine"]
    F --> G["Receive user requests"]
    G --> H["Run model inference"]
    H --> I["Return generated results"]
    I --> J["Monitor resources and performance"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#E5F0E9,stroke:#83A995,color:#315D49
    style J fill:#F5F8F4,stroke:#B5CBBB,color:#40594A

Local deployment usually needs to handle:

  • Downloading and loading model weights.
  • GPU memory planning.
  • Inference framework adaptation.
  • Tokenizer configuration.
  • Concurrent request scheduling.
  • KV Cache management.
  • Quantization and inference acceleration.
  • Service monitoring and failure recovery.