esc
  • WorkflowsPages
  • Case studiesPages
  • Machine Learning FoundationsLearn
  • AI EngineeringLearn
  • AI Guardrails & Red TeamingLearn
  • UI/UXLearn
  • Design SystemsLearn
  • Production System DesignLearn
  • Book a callContact
  • Download ResumeContact
Let’s talk

I’ll build the agent for it.

AI engineering / Core / 02.02

Open-weight model families

Four families of downloadable models a builder will meet, what their names and sizes tell you, and why you read the licence first.

12 min readFree

From the shop window to the shelf

The last lesson, Choosing the Right Model, ended with a promise: next, open-weight model families you can download and run. Here they are.

Think of a bakery. A hosted model is a cake you buy by the slice. An open-weight model is the recipe and the finished cake handed over in a box. You can take it home. What you may do with it afterwards depends on the note stuck to the box. That note is the licence.

By the end you will know four families by name, one or two facts about each, how to read a model name like a label, and why the licence note matters before you sell anything. You will also run a small program that reads made-up names. Running the real models comes in the next lessons.

Key words

Open weights
The weights, the model's learned numbers, are published so anyone can download them. It does not always mean everything else is open.
Model family
A group of models from one maker that share a name and a design, like Llama 3.1 in three sizes.
Parameter
One number inside the model. Sizes like 8B mean eight billion of them.
Base model
A model that learned from lots of text but was not taught to follow instructions. It continues text.
Instruction-tuned
A base model that got extra training to follow requests like a chat assistant. Names often say instruct or chat.
Licence
The written rules for what you may do with the model. Different models, even in one family, can have different licences.

If a word like weights or tokens is new, the lessons Self-Hosted Models and Type of Models explain it first. This lesson only adds the names.

Meta Llama

Llama is the family made by Meta. Wikipedia describes it as "a family of large language models (LLMs) released by Meta AI from February 2023 to April 2025". It adds that the latest version is Llama 4, released in April 2025, and that in April 2026 Meta released a model called Muse Spark as a replacement for Llama powering chatbots on its services.

On sizes, Wikipedia says Llama models "come in different sizes, ranging from 1 billion to 2 trillion parameters". It also notes that starting with Llama 2, Meta released instruction fine-tuned versions alongside the foundation models.

For a closer look, take one model card: Llama 3.1. Its card says the collection is "pretrained and instruction tuned generative models in 8B, 70B and 405B sizes". Its model developer is Meta. On the Hugging Face page, the Instruct model lists the plain Llama-3.1-8B as its base model.

The licence is named on the card too: "A custom commercial license, the Llama 3.1 Community License". The same page says you must log in and accept the licence terms before you can open the files. So even getting the weights starts with agreeing to a licence.

DeepSeek

DeepSeek is a company. Wikipedia calls it "a Chinese artificial intelligence (AI) company that develops open weight large language models", based in Hangzhou, and says it was founded in July 2023. Its Hugging Face page says it was founded in 2023 and is "dedicated to making AGI a reality".

Take its DeepSeek-R1 card. The card's top lines name the licence as MIT. A table on the card lists DeepSeek-R1 at 671B total parameters and 37B activated parameters. Activated means only part of the model works on each token. Wikipedia's Llama page describes the idea for Llama 4: a mixture of experts, where "only a fraction of the model's expert sub-networks are activated per input token".

The same card says the team open-sourced "distilled 1.5B, 7B, 8B, 14B, 32B, and 70B checkpoints based on Qwen2.5 and Llama3 series". Look at what that does to the names. A model called DeepSeek-R1-Distill-Qwen-7B comes from DeepSeek but is built on a Qwen model. A name can carry two makers.

Tip

On the card's table the distilled models list the model they start from, such as Llama-3.1-8B. When a name has two families in it, read the licence of each.

Qwen

Qwen is made by Alibaba Cloud. Wikipedia describes it as "a family of predominantly open-weights large and small language models". The word predominantly matters: not every Qwen model is open.

Its Hugging Face page says the organisation releases "large language models (LLM), large multimodal models (LMM)" and other projects. Multimodal means a model can handle more than text, such as pictures.

Qwen3 shows how a family is laid out. Wikipedia says that on 28 April 2025 the Qwen3 family was released "with all models licensed under the Apache 2.0 license". The dense sizes were 0.6B, 1.7B, 4B, 8B, 14B and 32B. The other kind, called MoE, included 30B-A3B, which Wikipedia explains as "30B with 3B activated parameters". So the A3B part of that name is the active size.

The Qwen3-8B card says "Number of Parameters: 8.2B" and shows its licence as apache-2.0. Notice: the name says 8B and the card says 8.2B. The size in a name is a round number, not an exact count. The card also lists a Qwen3-8B-Base model as its base.

Licences can change inside one family. Wikipedia says of the later Qwen3.8 release that larger models "require a revenue sharing agreement from providers generating more than US$50 million annually", while the 27B model "was released under a more permissive Apache License". Same name start, two sets of rules.

Gemma

Gemma is made by Google DeepMind. Wikipedia describes it as "a series of source-available large language models". Its first release in February 2024 came in two sizes, 2 and 7 billion parameters. Gemma 3 came in 1, 4, 12 and 27 billion parameter sizes.

The gemma-3-4b-it card says Gemma 3 has "open weights for both pre-trained variants and instruction-tuned variants". Its licence tag reads gemma, and the page says that to access it you are "required to review and agree to Google’s usage license".

Licence rules also move between versions. Wikipedia says Gemma 4, released on 2 April 2026, came "under the free and open-source Apache 2.0 license". That is a different licence from the gemma one on the Gemma 3 card. Four sizes are listed for it: Effective 2B, Effective 4B, a 26B mixture of experts and a 31B dense model.

Quick check

Gemma 3 and Gemma 4 are both called Gemma. What do their pages show about licences?

Reading a model's name

A model name is a label. Once you know the pattern, you can learn a lot before you download anything. The patterns below come from the cards you just read.

  1. 1

    Family and version

    The start names the family and its version, like Llama-3.1 or Qwen3 or gemma-3. Newer versions can have different sizes and a different licence.

  2. 2

    Size

    A number followed by B, such as 8B, is billions of parameters. It is rounded: the Qwen3-8B card says 8.2B. Names like 30B-A3B show the total and the active part.

  3. 3

    Base or tuned

    A plain name such as Llama-3.1-8B or Qwen3-8B-Base is the base kind. A name ending in Instruct, or the pt and it pair on Gemma pages, points to the pre-trained and instruction-tuned variants. Check the card to be sure which is which.

  4. 4

    Extra words

    Words like Distill or Qwen inside DeepSeek-R1-Distill-Qwen-7B tell you how it was made and what it came from. Read them once; they matter for the licence.

Why base versus tuned? A base model finishes text. Give it "The capital of France is" and it may keep writing a list of facts. An instruction-tuned model was trained on top to answer you like a helper. For a chat feature in a product, you usually want the tuned kind. The lesson Fine-tuning goes deeper on how tuning works.

Files you download may add one more piece: how many bits each number uses, called quantisation. That was the subject of Self-Hosted Models. Check the page of the file you download for how it is written.

Read names with a small program

Let's do the reading in code. The names below are made up, nothing here is a real model, and nothing runs a model. The program uses a regular expression, a short pattern that describes which text to grab, to pull out the family, the size, whether the model is tuned or base, and the quantisation.

Then it uses the weights-memory rule from Self-Hosted Models: billions of parameters times bits, divided by 8, gives gigabytes for the weights alone. It then checks that against a laptop budget. We made up the budget: 8 GB for the weights.

weights (GB)=billions of parameters×bits per parameter8\text{weights (GB)} = \text{billions of parameters} \times \frac{\text{bits per parameter}}{8}

In words: count the billions of numbers, then multiply by how many bytes each takes. A byte is 8 bits. Real runs need extra memory on top, so treat the answer as a floor.

Python
import re

# Every name below is made up. Real names vary, so always read the model card.
names = [
    "alpha-7b-instruct-q4",
    "alpha-70b-instruct-q4",
    "beta-8b-base-f16",
    "beta-3b-chat-q8",
    "gamma-1b-base",
    "omega-2b-q8",
    "delta-14b-instruct-q8",
    "delta-14b-instruct-q4",
    "mystery_model_v2",
]

pattern = re.compile(
    r"^(?P<family>[a-z]+)-(?P<size>\d+(?:\.\d+)?)b"
    r"(?:-(?P<kind>instruct|chat|base))?"
    r"(?:-(?P<quant>f16|q8|q4))?$"
)

bits = {"f16": 16, "q8": 8, "q4": 4}
BUDGET_GB = 8.0  # made-up: memory we allow for the weights alone

print(f"{'name':<24}{'family':<7}{'size':>5}  {'type':<8}{'quant':<6}{'GB':>6}  fits {BUDGET_GB:g} GB?")
for name in names:
    m = pattern.match(name)
    if not m:
        print(f"{name:<24}no match: read the model card")
        continue
    size = float(m["size"])
    quant = m["quant"] or "f16"
    kind = {None: "?", "base": "base"}.get(m["kind"], "tuned")
    gb = size * bits[quant] / 8  # billions of parameters x bytes each = GB
    verdict = "yes" if gb <= BUDGET_GB else "no"
    print(f"{name:<24}{m['family']:<7}{size:>5g}  {kind:<8}{quant:<6}{gb:>6.1f}  {verdict}")

Output

name                    family  size  type    quant     GB  fits 8 GB?
alpha-7b-instruct-q4    alpha      7  tuned   q4       3.5  yes
alpha-70b-instruct-q4   alpha     70  tuned   q4      35.0  no
beta-8b-base-f16        beta       8  base    f16     16.0  no
beta-3b-chat-q8         beta       3  tuned   q8       3.0  yes
gamma-1b-base           gamma      1  base    f16      2.0  yes
omega-2b-q8             omega      2  ?       q8       2.0  yes
delta-14b-instruct-q8   delta     14  tuned   q8      14.0  no
delta-14b-instruct-q4   delta     14  tuned   q4       7.0  yes
mystery_model_v2        no match: read the model card

Read the table. alpha-7b-instruct-q4 comes to 3.5 GB: 7 billion times 4 bits, divided by 8. It fits our 8 GB budget. alpha-70b-instruct-q4 is the same recipe at 70B and needs 35.0 GB, so it does not fit.

The two delta rows show quantisation at work. delta-14b-instruct-q8 needs 14.0 GB and does not fit, while the q4 version of the same model needs 7.0 GB and does. beta-8b-base-f16 needs 16.0 GB. gamma-1b-base has no quantisation word, so the code guessed f16 and got 2.0 GB.

Two rows show the limits. omega-2b-q8 has no instruct, chat or base word, so the type column says a question mark instead of guessing. mystery_model_v2 matches nothing, and the program says to read the model card. A pattern only knows the names we taught it. Real names vary a lot, so use code to help you read, never to replace the card.

Tip

Facts in this lesson were checked on 16 November 2026. Families change often: new versions, sizes and licences appear all the time. Treat the pages in the sources list as the truth and check them again.

Read the licence before you sell

Open weights does not mean no rules. Wikipedia's Llama page notes that Ars Technica described Llama as "source-available", "openly licensed", and "weights available" after noting what Llama 2's licence did not allow. Words like open and free are used loosely, so only the licence text answers the question.

The Llama 3.1 licence on its card is a good example of a detail you could miss. It says that if the products or services of the licensee or its affiliates have "greater than 700 million monthly active users", you must request a licence from Meta. A small team will not hit that. A big company might. The only way to know is to read it.

  • Find the licence name

    The model card names it: MIT, Apache 2.0, Llama 3.1 Community License, a licence called gemma. Search for that exact name and read it, not a summary.

  • Check your use

    Look for limits on commercial use, on how many users you have, on using outputs to train other models, and on the uses it bans.

  • Check every part

    A model made from another model, like a distilled one, can carry two licences. Check the family, the size and the version you actually download.

Quick check

You plan to sell an app that uses a downloaded model. What should you do first?

Quick check

A model page is named Qwen3-8B and its card says "Number of Parameters: 8.2B". What does the 8B in the name mean?

What to remember

  • Four families, four makers

    Llama is made by Meta, DeepSeek by a company of the same name, Qwen by Alibaba Cloud and Gemma by Google DeepMind. Each has many sizes and versions.

  • Names are labels

    The name tells you family, version, a rounded size and often base or instruct. The card gives the exact numbers.

  • Licences differ

    MIT, Apache 2.0 and custom licences all appear. Read the licence for the exact model and version before commercial use.

Next: model APIs side by side, the same call in different shapes.

Sources

How is this lesson?

Last updated on 16 November 2026

Learn with me

Every lesson is free. I add new ones as I learn. Have a question, or want help with your own work? Book a short call.