Open-source LLMs: licenses and commercial use (2026)

#Why an open-source LLM's license matters more than the model

When a team picks a model to self-host, it looks first at answer quality, memory requirements and speed. The license often comes last, when a customer or a procurement department asks about it. That's the reverse of the order that keeps you out of trouble: an excellent model whose license prohibits your use case is useless, and switching models after integration costs development time, new testing and sometimes a new round of fine-tuning.

The terminology fuels the confusion. Many models marketed as “open source” publish their weights, but not their training data or all of their code, and some do so under a license that doesn't meet the Open Source Initiative's definition. The conceptual difference between open-weights and open source is covered in a dedicated guide; here, we focus on a single practical question: what does the license text allow you to do with the weights, especially for commercial use?

Three scenarios come up again and again in companies. Internal use: the model runs on your servers for your teams, and nothing is distributed. Service: you expose the model to customers through an app or an API, without handing over the weights. Redistribution: you ship the weights, possibly modified or quantized, in a product, a device, or a public repository. License obligations differ sharply across these three cases, so keep them in mind for what follows.

#The three families of open-source LLM licenses

In practice, the licenses you'll find on Hugging Face or in the Ollama library fall into three families. This classification says nothing about model quality; it only indicates how many constraints you need to review.

Standard permissive licenses

Apache 2.0 and MIT lead the pack. These are long-established software licenses, familiar to lawyers, that allow commercial use, modification and redistribution with limited obligations (keep the notices, include the license text). They aren't specifically aimed at AI, but many publishers apply them to their weights.

Custom community licenses

Written by the model's publisher for that model: the Llama Community License at Meta, model-specific terms of use at other publishers. They often allow commercial use but add conditions: a user threshold, a required attribution notice, naming rules, and an acceptable use policy you must follow.

Restrictive licenses

Research licenses, noncommercial licenses (for example, Creative Commons with an NC clause), or licenses with detailed use restrictions. Commercial use is excluded or requires a separate agreement with the publisher.

The same publisher may release models in several families. Depending on the generation, well-known model families have mixed sizes under Apache 2.0 with others under a custom or research license. So never infer a model's license from its family name or its publisher: check the file for the exact variant you download.

#Apache 2.0: what the text allows

The Apache 2.0 license dates from January 2004, and its text is published by the Apache Software Foundation. It's the most common permissive license for open-weights LLM weights. It grants each recipient a perpetual, worldwide, non-exclusive, no-charge, royalty-free copyright license to reproduce, modify, display, sublicense, and distribute the work and its derivatives (section 2).

Its distinctive feature is the explicit patent license in Section 3: each contributor grants a license to its patents that are necessarily infringed by its contribution. This license terminates for you if you file a patent infringement lawsuit alleging that the work itself infringes a patent. For a company, this clause clarifies a risk that MIT leaves unaddressed.

Commercial use

Allowed, both internally and in a service or product you sell, with no royalties and no user threshold.

Modification

Allowed: fine-tuning, quantization, weight merging. You can put the result under a different license for your own contributions, provided you comply with Apache 2.0 for the reused portion (section 4).

Redistribution

Permitted under four conditions (Section 4): provide a copy of the license, prominently mark modified files, retain copyright, patent, trademark, and attribution notices, and include the contents of the NOTICE file if one exists.

Marques

Not granted (section 6): you can say your product uses a given model, but you can't use the publisher's name or logo as if it were your own brand.

Warranty and liability

None (sections 7 and 8): the model is provided “as is.” The model's errors remain your responsibility toward your customers.

For internal use, or for a service where the weights aren't handed over, redistribution obligations don't apply directly, since nothing is distributed. They become central again if you publish a quantized or fine-tuned version of the model, or embed it in software shipped to customers.

#MIT: the shortest license

The MIT license fits in three paragraphs, as published by the Open Source Initiative. It grants anyone, free of charge, permission to use, copy, modify, merge, publish, distribute, sublicense, and sell copies of the software, without restriction. The only condition: the copyright notice and the permission notice must be included in all copies or substantial portions. The rest of the text disclaims all warranties and any liability on the part of the authors.

Commercial use

Explicitly allowed, including selling.

Modification and redistribution

Allowed, with the sole requirement that you retain the copyright notice and the license text.

Brevets

Unlike Apache 2.0, the text contains no explicit patent license. The implied scope of the patent permission is a matter of interpretation to take to a lawyer if it matters to you.

Guarantee

None, same as Apache 2.0.

For an LLM, MIT is therefore the simplest license to comply with. The main pitfall lies elsewhere: verify that the MIT notice actually covers the weights, not just the inference code published in the same GitHub repository.

#Llama 3.3 Community License: commercial use with conditions

Meta releases its Llama models under a license specific to each version. The Llama 3.3 Community License Agreement, dated December 6, 2024 on the official page, serves here as an example of a custom license, because it's very widespread and many derivative models inherit it. It grants a non-exclusive, worldwide, non-transferable, royalty-free license to use, reproduce, distribute, copy, and modify the "Llama Materials" and to create derivative works. Commercial use is therefore possible, but regulated.

Redistribution

If you distribute the Llama Materials or a product that contains them, including a derivative model, you must provide a copy of the agreement and prominently display "Built with Llama" on a website, user interface, blog post, or product documentation.

Naming derivative models

If you use the Llama Materials or their outputs to create, train, or improve an AI model that you distribute, its name must begin with “Llama”.

Copyright notice

Distributed copies must retain the Notice file stating that Llama 3.3 is licensed under the Llama 3.3 Community License, copyright Meta Platforms.

Acceptable use policy

Use must comply with applicable laws and with the Llama 3.3 acceptable use policy, which is incorporated by reference. It lists prohibited uses; Meta may update it, so reread it as of the date of your decision.

700 million user threshold

If, on the Llama 3.3 release date, the products or services of the licensee or its affiliates exceeded 700 million monthly active users in the preceding calendar month, it must request a license from Meta, which Meta may grant or not at its sole discretion. Nearly all companies fall below this threshold, but it shows that the license isn't universal.

Marques

No trademark license, except for the use of "Llama" required to comply with the attribution and naming requirements.

Termination and governing law

The license terminates if you bring an action against Meta alleging that the Llama Materials infringe your intellectual property rights. The agreement is governed by the laws of the State of California.

This license is not recognized as open source by the Open Source Initiative's definition, notably because of its usage restrictions and the threshold. That doesn't prevent commercial use, but it requires closer monitoring than Apache 2.0 or MIT: notices to display, naming of your derivative models, and compliance with a policy that can change.

#Comparison table: Apache 2.0, MIT, and Llama 3.3

This table is built solely from the three official texts cited as sources, consulted while preparing this guide (brief checked as of September 29, 2026). It summarizes clauses, not their legal interpretation. It says nothing about other custom licenses, each of which has its own rules.

Commercial use

Apache 2.0: yes, with no special conditions. MIT: yes, with no special conditions. Llama 3.3: yes, subject to the 700 million monthly active user threshold and the acceptable use policy.

Modification, fine-tuning

Apache 2.0: yes, modified files must be flagged. MIT: yes. Llama 3.3: yes; a distributed derivative model must have a name beginning with "Llama".

Weight redistribution

Apache 2.0: yes, with a copy of the license, notices, and the NOTICE file. MIT: yes, with the copyright notice and license text. Llama 3.3: yes, with a copy of the agreement, a Notice file, and the "Built with Llama" attribution.

Explicit patent license

Apache 2.0: yes (section 3). MIT: no. Llama 3.3: the text grants a license under Meta's intellectual property rights in the Llama Materials; its exact scope should be reviewed by counsel.

Usage restrictions

Apache 2.0: no list of prohibited uses. MIT: none. Llama 3.3: acceptable use policy incorporated by reference.

Size threshold

Apache 2.0: none. MIT: none. Llama 3.3: 700 million monthly active users as of the release date.

Marques

Apache 2.0: not granted. MIT: not mentioned. Llama 3.3: not granted, except for the use of "Llama" required by the license.

Guarantee

None for all three texts.

To find out which current models fall into each family, don't rely on this table: it compares texts, not models. Check our roundup of the best LLMs for commercial use and, above all, apply the method below to the exact variant you plan to deploy.

#Check an open-source LLM's license model by model

The method takes five steps. It takes about twenty minutes per model and leaves a record that a lawyer or auditor can use.

1. 01
   Identify the original repository

   Trace it back to the publisher's page on Hugging Face (the official organization, not a third-party account that republishes a quantization). Note the exact name of the repository and the variant: size, instruct or base, version. A GGUF conversion published by a third party is still subject to the original model's license.
2. 02
   Read the license file, not the tag

   The license field on the model card gives you a hint, but only the repository's LICENSE file (or equivalent) is authoritative, along with any USE_POLICY or NOTICE files. Check that it actually covers the weights and not just the code. If the tag says "other," a custom license applies: read it in full.
3. 03
   Cross-check with the publisher's official page

   Compare it with the license published on the publisher's website or in its announcement. If the two differ, don't decide on your own: flag the discrepancy to your lawyer.
4. 04
   Archive the dated text

   Download the license file, record the date, the URL, and the repository revision number, and compute its hash. If the publisher changes its terms later, you'll know which version you accepted.
5. 05
   Check the license against your use case

   Internal use, hosted service, or redistribution: for each case, list the obligations (notices, naming, usage policy, thresholds) and the person responsible for meeting them. Have a lawyer validate the checklist before going to production.

The public Hugging Face API returns a model card's metadata, including the license tag. It's a quick starting point, to be supplemented by reading the file itself. Replace the repository name with the one you're evaluating.

REPO="organisation/nom-du-modele"
curl -s "https://huggingface.co/api/models/$REPO" \
  | python3 -c 'import json,sys; d=json.load(sys.stdin); print(d.get("sha")); print((d.get("cardData") or {}).get("license")); print([t for t in d.get("tags",[]) if t.startswith("license:")])'

To archive the license file of a public repository, download it with the Hugging Face command-line tool, then compute its hash. Gated repositories, such as Meta's, require you to accept the terms on the website and use an access token. The exact file name varies between repositories: check it in the “Files” tab.

mkdir -p licences/$(date +%F)
hf download "$REPO" LICENSE --local-dir licences/$(date +%F)/
sha256sum licences/$(date +%F)/LICENSE >> licences/registre-empreintes.txt

If the model is already installed in Ollama, the command ollama show affiche the license embedded in the package. It's useful as a consistency check, but it doesn't replace the publisher's source: a community package may contain incomplete text or none at all.

ollama list
ollama show --license nom-du-modele

#Common pitfalls

Confusing the code with the weights

An MIT-licensed GitHub repository may contain the inference code while the weights are published elsewhere under a custom license. It's the weights license that governs how you can use the model.

Relying on a re-upload

GGUF quantizations published by third parties sometimes display an incorrect or simplified license. They don't change the rights: only the original publisher's text counts.

Forgetting what derivative models inherit

A model fine-tuned from Llama is still subject to the terms of Llama, even if its author lists it under Apache 2.0. Read the model card of the base model named in the metadata, along with the derivative's license text.

Assuming a license never changes

Vendors publish a license for each version, and usage policies incorporated by reference can change. That's why it's worth archiving the dated text you accepted.

Ignoring training data and outputs

The weights license doesn't settle everything: the status of generated content, personal data processed by the model, industry-specific obligations. Those issues fall under other texts and call for dedicated legal advice.

Forgetting about regulations

A permissive license does not exempt you from AI Act obligations, which depend on your role (provider, deployer) and how the system is used. That is a separate question from the license.

#Go further

The license is only one criterion when choosing a model. To understand why so few models are truly open source, compare the available models, or see where your deployment stands under the AI Act, these pages complement this guide.