Choosing Models & Licences
|
This content was generated with the assistance of AI and should be verified against the official documentation of each tool and framework before being relied on in production. This section’s bibliography lists the reference material consulted while preparing these pages. |
This page was written against the model cards on the Hugging Face Hub as checked on 2026-09-30, huggingface_hub 2.0.0
and transformers 5.17.0. Licences and gating are properties of each repository, not of a model family, and they
change between releases: the Gemma 4 instruct model that was checked carries Apache-2.0, while the older Gemma
repositories carry the custom Gemma terms. Always read the card and the LICENSE file of the exact repository you
ship; the table values below are examples of each class, not a substitute for doing that.
Choosing a model for an app is three separate questions: is it good enough for the task (the card and evaluations), will it fit on the target device (size versus hardware) and may I ship it (the licence). The general selection method for hosted and open models is on Choosing a Model; this page adds what is specific to Hub repositories. Downloading and authentication are on Hub Essentials.
Reading a model card
Start with the YAML header, then read three parts of the text in this order.
-
Intended use and out-of-scope use. What the authors built the model for (for example "English dictation of clean audio") and what they say it must not be used for. A model used outside its intended use has no evaluation evidence behind it.
-
Evaluation. Which datasets, metrics and settings were used, and whether the numbers are the authors' own or come from a public benchmark. Treat a single headline number as a marketing figure; compare models on your data.
-
Limitations and biases. Languages and accents covered, context length, known failure modes (hallucinated text on silence for speech models, small-object misses for detectors), and the training-data description.
Also check the metadata that decides whether you can run the model at all: license, library_name (which runtime loads
it), pipeline_tag, base_model and its relation (quantized, adapter, finetune), and the file list (formats and
sizes, see Model Formats).
from huggingface_hub import ModelCard
card = ModelCard.load("openai/whisper-small.en")
meta = card.data.to_dict()
print(meta.get("license"), meta.get("pipeline_tag"), meta.get("library_name"))
print(card.text[:400]) # the start of the Markdown bodyThe same from a terminal: hf models card openai/whisper-small.en --metadata --format json. Reference:
Hugging Face — Model Cards and
huggingface_hub — Create and share Model Cards.
Size versus hardware
Weight memory is, to a first approximation, parameter count times bytes per parameter; the runtime then adds the KV cache (for language models), activations and framework overhead. With parameters stored at bits:
A 1-billion-parameter model is therefore about 2 GB in 16-bit, about 1 GB in 8-bit and about 0.5 GB in 4-bit, before overhead. The repository’s file list tells you the real figure: add up the sizes of the files you would download, and keep headroom for the context and the rest of the app. The full treatment — KV cache, unified memory, GPU versus CPU, token throughput — is on Hardware Sizing, and the effect of lower precision on quality is on Quantization for Inference.
hf download ggml-org/gemma-3-1b-it-GGUF gemma-3-1b-it-Q4_K_M.gguf --dry-run
hf models ls ggml-org/gemma-3-1b-it-GGUF --tree -hSource: Hugging Face CLI guide (hf download --dry-run, and
hf models ls <repo-id> listing a repository’s files, documented for huggingface_hub 2.0.0; older releases lack the
file listing). From Python, HfApi().list_repo_tree("ggml-org/gemma-3-1b-it-GGUF") yields each file with its size, on
any recent huggingface_hub release.
Phones and embedded devices add limits a desktop does not have: a per-app memory ceiling, thermal throttling and download size in an app store. Speech and vision models are usually far smaller than language models, which is why a small LLM is the part of an on-device pipeline that most often decides the hardware floor.
Licence classes
A repository’s licence is the license field of its card metadata, with the text in a LICENSE file or behind a link.
The classes you meet, with real repositories checked on 2026-09-30 as examples:
| Class | Example repositories (licence on the card) | What it means for an app |
|---|---|---|
Permissive — Apache-2.0, MIT |
|
Commercial use and redistribution allowed with attribution and notice files. Apache-2.0 also grants a patent licence. The least friction to ship. |
Attribution — CC-BY-4.0 |
|
Commercial use allowed; you must give credit, link the licence and indicate changes. Put the notice in your app’s about screen or third-party notices. |
OpenRAIL — Responsible AI Licences |
|
Free to use and redistribute, with use-based restrictions (for example on harmful or deceptive uses) that must be passed on to anyone who receives the model or a derivative — including your users. |
Community licences — custom vendor terms |
|
Often usable commercially but with conditions: acceptable-use policies, attribution or naming requirements, user-count or revenue thresholds, and terms that follow the model into every derivative. Read the text; do not assume. |
Copyleft — AGPL-3.0 |
|
See below: the obligations reach your application, not only the weights. |
Non-commercial |
|
Free for non-commercial use only. Not usable in a commercial product without a separate commercial agreement. |
Two practical rules follow. First, quantized and converted re-uploads inherit the original licence: a GGUF, MLX or ONNX
repository whose base_model points at a Llama model is a Llama-licensed artefact whatever its uploader wrote in the
summary, and the conversion repositories do not always repeat the terms faithfully. Check the base model’s card
(base_model and base_model_relation in the metadata). Second, licences on the code (for example the
inference library) are separate from licences on the weights.
AGPL-3.0 and Ultralytics YOLO
The Ultralytics YOLO models and library are licensed under AGPL-3.0, with a paid Enterprise licence as the alternative. AGPL is a strong copyleft licence whose section 13 extends the source-offer obligation to network use: if you modify the program and users interact with it over a network, you must offer them the corresponding source of your version. For an application this means:
-
Shipping a mobile or desktop app that embeds YOLO code or weights is distribution of a work under AGPL-3.0; the combined work has to be offered under the same licence, which conflicts with a closed-source product.
-
Offering YOLO inference as a web or API service triggers the network clause for any modified version.
-
Using it only internally (analysis scripts, offline research) does not distribute anything.
If the product is closed-source, either buy the Enterprise licence, or choose a detector under a permissive licence instead. Have a lawyer read the actual licence for your case. Reference: Ultralytics — AGPL-3.0 licence and the GNU — AGPL-3.0 text.
Non-commercial: XTTS and the CPML
coqui/XTTS-v2 is a capable multilingual text-to-speech model whose card names the Coqui Public Model License (CPML),
a non-commercial licence. It is fine for a prototype or research and not for a product you sell or run for a
business. The permissive alternatives for on-device speech synthesis (for example Kokoro under Apache-2.0) are listed
in Speech Models: STT & TTS.
OpenRAIL in practice
OpenRAIL licences keep the model open but attach behavioural restrictions, and they require those restrictions to travel with redistributions and derivatives. For an app, that means your own terms of use must not permit what the licence forbids, and a fine-tuned model you publish must carry the same restrictions. See Hugging Face — OpenRAIL.
Gated access
A gated repository (gated is "auto" or "manual" in the API) requires you to accept terms, and sometimes share your
contact details, before download; with manual approval the authors decide. Gating is not a licence class: a gated
model can be permissively licensed and an ungated one can be non-commercial. For shipping, note two consequences:
-
Your users cannot download it for you. An app that fetches a gated model on first launch would need a token of an account with access, and a token must never be embedded in an app. Either pick an ungated model, or download the files in your build pipeline (where you hold the token as a secret) and ship or host them according to the licence.
-
Redistribution terms still apply even after you have been granted access; read what the terms say about hosting the weights yourself.
Mechanics of access requests and tokens: Hub Essentials.
Leaderboards
Public leaderboards help build a shortlist but do not replace an evaluation on your own data. Three are used throughout this sub-section; none of their numbers are quoted here because they change continuously:
-
Open ASR Leaderboard — word error rate and real-time factor for speech-to-text models; the speed column matters as much as accuracy for on-device use.
-
MTEB — the Massive Text Embedding Benchmark, for choosing embedding models by task and language (see also Generating Embeddings in Practice).
-
Arena — human-preference rankings of chat models from blind pairwise votes; good for overall chat quality, weaker for a narrow task such as extraction. For how benchmarks mislead, read Benchmarks and Leaderboards.
Check the date of the snapshot, whether the model is the exact size and quantization you would run, and whether the benchmark data may have leaked into training.
Licence checklist for shipping in an app
Before a model goes into a release, record the answers for every model, tokenizer, dataset and library in the pipeline:
-
Exact repository and commit.
owner/nameand the revision hash you tested, pinned withrevision=. -
Licence of the weights. Read the
LICENSEfile, not only the metadata field; note the SPDX identifier or name. -
Commercial use. Is it allowed for your business model, revenue size and user count?
-
Redistribution. May you bundle the files in an app or installer, or host them on your CDN? Do derivatives (quantized, converted, fine-tuned) carry the same terms?
-
Attribution and notices. What text must appear in your app, documentation or third-party-notices file; does the licence require the model name in product naming?
-
Use restrictions. Acceptable-use policies or OpenRAIL clauses that your product and your own terms of use must respect.
-
Copyleft reach. AGPL or similar on code or weights that would pull your application under the same licence.
-
Gating. Who accepted the terms, with which account, and how the files reach end users without a token.
-
Training-data and output terms. Restrictions on using outputs to train other models, or on certain regions or users.
-
Conversions. The base model’s licence for every GGUF, MLX, ONNX, LiteRT or Core ML variant you use.
-
Archive the evidence. Keep a copy of the licence text and card at the time of release, because cards can change.
Model choice by task and family, including their licences, is surveyed on Open-Weight Models; this checklist applies the same licence classes to the STT, TTS, vision and small-model catalogues (Speech Models: STT & TTS, Vision Models and Small LLMs & Embeddings).
from huggingface_hub import HfApi
api = HfApi()
for repo_id in ["openai/whisper-small.en", "hexgrad/Kokoro-82M", "google/siglip2-base-patch16-224"]:
info = api.model_info(repo_id)
card = info.card_data
print(
repo_id,
info.sha, # the commit to pin
getattr(card, "license", None), # licence identifier from the card
info.gated, # False, "auto" or "manual"
)Reference: Hugging Face — Licenses.