How to read a model card

What a model card is

Open models are commonly shared on Hugging Face, a site that hosts model files the way other sites host code.

Beside each model is a page called a model card. Under the surface it is a plain text file named README.md in the model's own folder.

Hugging Face says a card should describe the model, its intended uses and its limits, how it was trained, what it was trained on, and how it scored on tests.

Cards vary a lot. Some are thorough. Some are three lines. What follows is what to look for, and what to make of a card that leaves it out.

Backed by Model Cards on the Hugging Face Hub.

Five facts worth finding

You do not need to read the whole card. You need five things.

• Size. How many billion weights, and how large the file you would download is.
• Licence. What you are allowed to do with it. This is a legal fact, not a mood.
• Instruct or base. A base model continues your text. An instruct model answers you.
• Context length. How much text it can hold in front of it at once.
• Intended use. What the makers built it for, and what they say it is not for.

Backed by Model Cards on the Hugging Face Hub, Chat templates: base models and chat fine-tunes.

The order to read it in

A long card can take twenty minutes. You do not have twenty minutes, and you do not need them.

Read it in this order. You can stop the moment something rules the model out.

• The strip at the very top. A card is a text file with a block of metadata above it, and that block holds the licence and the base model. Ten seconds.
• What the makers say it is for, and what they say it is not for. Nothing rules a model out faster.
• Size and context length. Can it fit on your machine, and can it hold the documents you have in mind.
• The file list. This is where the number that matters lives: the size on disk of the exact file you would download.
• The benchmark table, last of all. It is the part written to impress you, and a later section here says what to do with it.

Backed by Model Cards on the Hugging Face Hub.

One real card, read

Take Qwen3.5-0.8B, and read it in that order.

The strip at the top settles two of those five facts at once. The licence is apache-2.0, with a link to the licence text. The base model is Qwen3.5-0.8B-Base, so the one you are looking at is the tuned version of that.

The strip also holds a surprise. It tags the model image-text-to-text. This 0.8 billion model takes pictures as well as words, and the overview below confirms it: a language model with a vision encoder.

Then comes the makers' own note. Because of its size, they say the model is meant for prototyping, for fine-tuning on one task, and for research or development.

That sentence is worth more than the benchmark table below it. The people who built the model are telling you it is not the one for your daily work.

Last, the size and the reach. The overview gives 0.8B parameters and a context length of 262,144 tokens. Two facts, in the same short block.

Backed by Qwen3.5-0.8B model card, Model Cards on the Hugging Face Hub.

The file name is a fact too

On the download page you will see files like Qwen3.5-0.8B-Q4_0.gguf. That name follows a written convention.

Reading left to right: the model name, then the size, then sometimes Instruct or Chat, then the quantization setting from lesson 8.

Two parts of a name catch people out. A name ending 00003-of-00009 is one piece of a model split across nine files, and you need every piece. A name beginning mmproj is not a model at all. It is the extra part that lets a model handle images or audio.

The specification is honest about its own limits. It says the convention is not meant to be read perfectly by a machine, because real file names vary so much.

The .gguf ending is the file format local tools read. It holds the model numbers and a standard set of facts about the model.

The file list also gives you the number that matters most, which is the size on disk. In that same folder the 16-bit file is about 1.6 GB, the 8-bit file about 0.8 GB and the 4-bit file about 0.6 GB.

Backed by GGUF file format specification, including the naming convention, Qwen3.5-0.8B-GGUF file listing, GGUF on the Hugging Face Hub.

The benchmark table, read last

Almost every card wants to show you a table of scores. Read it, but read it last, and read it carefully.

Qwen's own table is a good example, because it does not flatter. On the MMLU-Pro test in non-thinking mode, Qwen3.5-0.8B scores 29.7. Their 2B model scores 55.3, and an older 4B model scores 69.6.

The makers printed a number that argues against their own small model. It agrees with the note further up telling you the thing is for prototyping.

A card that only shows wins is the one to be careful with. The useful cards are the ones willing to show where a model is weak.

One more thing sits under those tables. Qwen lists the exact settings used to produce the scores. So a score is a measurement made under set conditions, not a fixed property of the model.

Lesson 24 is about measuring for yourself, without fooling yourself.

Backed by Qwen3.5-0.8B model card.

Licences and gates

Licences differ more than people expect, and the card is where you check. Hugging Face shows the licence in the card's own metadata.

Qwen3.5-0.8B uses Apache 2.0, a standard open licence used across a lot of software.

Llama 3.1 8B Instruct does not. It has its own Llama 3.1 Community License. Hugging Face will not let you download it until you agree to share your contact details with Meta.

Neither is wrong. They are different deals, and the point is knowing which one you took. Lesson 7 covers what those deals actually let you do.

Backed by Model Cards on the Hugging Face Hub, Qwen3.5-0.8B model card, Llama 3.1 8B Instruct model card and licence gate.