Read the licence before you read the demo

The order everyone reads it in is wrong

Most people open a model page, look at the sample outputs, decide they like it, and start building. The licence gets checked at the end, if at all — usually the week before launch, by someone who is now unhappy.

A model card is a README.md with a YAML block at the top. That block carries the machine-readable facts: license, base_model, datasets, pipeline_tag, language, tags. The prose underneath is written by whoever uploaded the model, and it is a mixture of documentation and advertising. Read the page in this order instead.

One: the licence, and which family it belongs to

The licence shows in the right-hand sidebar and in the front matter. There are roughly five families and they behave very differently.

• Permissive — Apache-2.0, MIT, BSD. Commercial use, modification, redistribution, keep the notice. The easy case.
• Share-alike and copyleft — anything CC-BY-SA, occasionally GPL. Your derivative may have to carry the same terms. That bites when you fine-tune.
• Non-commercial — cc-by-nc-4.0, cc-by-nc-sa-4.0, and several custom research licences. Excellent models sit here. You may not put them in a paid product, and *my app is free but carries ads* is not a question the card answers. Image people meet this constantly: sd-turbo is the fastest thing you can run on a laptop CPU and its licence is non-commercial.
• Custom community licences — Llama, Gemma and others. Mostly permissive in practice, with named conditions: an acceptable-use policy, an obligation to display attribution such as *Built with Llama*, a naming rule for derivative models, and in Llama's case a clause that only engages above 700 million monthly active users. Read one properly once; they are short.
• `other`, or no licence field at all. Treat that as *unlicensed*, not as *free*. Absence of a licence is not permission.

Two traps. Gated is not a licence: clicking *Agree and access repository* gets you the files, and the licence still governs what you may then do with them. And the model's licence and its training data's licence are separate questions — a permissively licensed model trained on scraped material does not settle the second one for you.

Two: lineage, because you inherit it

The base_model field links a fine-tune to its parent, and the Hub draws the tree from it. This is the most useful thirty seconds on the page. A model presented as an original release is often three fine-tunes downstream of something whose terms, biases and context limit it silently inherits. If a card claims Apache-2.0 while its base model is under a non-commercial research licence, the card is wrong and the base wins. That happens more often than you would like, particularly on community merges.

Three: the numbers, and the sentence next to them

An evaluation table tells you what the author chose to measure. Ask three things of any of them.

• Which benchmarks are missing? Six results with three obvious ones absent is a report, not an oversight.
• In what language and what format? Nearly all famous scores are English multiple-choice. If your work is Hindi customer messages or Yoruba speech, the number is close to meaningless for you.
• Compared with what, and when? Beating a 7B model is not the claim it sounds like if the comparison is two years old.

Lesson nine is entirely about this, and /learn/evaluating-ai takes it further.

Four: the limitations section

Scroll to *Bias, Risks and Limitations*. Most people skip it because it reads like boilerplate. It is usually where the author has written down, in plain language, the exact failure you are about to have: the languages it degrades on, the groups it misclassifies, the input length past which it falls apart, the fact that the speech model was trained on clean read audio and collapses on a phone call recorded in a market.

A card with no limitations section is not a model without limitations.

Five: the Files tab, which cannot lie

The prose is written. The files are what exists.

• Size arithmetic. Parameters times bytes per parameter. A 7-billion-parameter model at 16-bit is about 14 GB; at 8-bit about 7 GB; at 4-bit about 4 GB. Add the file sizes up and check them against what the card implies.
• Prefer `safetensors` to `.bin` or `.pt`. The older PyTorch formats serialise with Python's own object format, and loading one can execute code embedded inside it. The safetensors format exists so that loading weights is only loading weights. If a repo offers both, take the safetensors.
• `trust_remote_code=True` in the usage snippet means the repo ships custom Python that will run on your machine. Sometimes genuinely necessary. Always worth knowing you agreed to it.
• `config.json` states the real architecture, hidden size and context length, whatever the prose above claims.

Do this now

Open the last model you used and answer three questions without scrolling to the demo: what is its licence, what is its base model, and name one stated limitation. If you cannot find all three, you have already learned something about that model.