Model Families and Who Makes Them

By the end of this lesson you will be able to name the fourteen open-weight families that matter to a local builder and the organisation behind each, place any new repository on the map as a new generation, a point release or someone else’s derivative, read what a family is built for out of its config.json instead of its announcement, explain why the labs run on a small Qwen3-heavy reference set, and refresh the whole map from the Hugging Face Hub with four short scripts.

That last skill is the one that lasts. Everything else here has a date attached.

A map with a date stamped on it

The family descriptions were written from each publisher’s Hugging Face organisation page and flagship model cards, read on 8 September 2026 and re-read for this revision on 12 September. Every table of dates, licences, configs and derivative counts was produced on 12 September by the scripts in the last section, so you can run the same scripts on the day you read this and see how far the map has moved.

Four words carry the whole lesson, and each can be checked on the Hub without trusting a name:

Term	Means	How to tell, from the Hub
Family	One publisher’s line of models with a shared training lineage	Same namespace; within a generation, the same architectures class and vocab_size in config.json
Generation	A new pretraining run; architecture, tokeniser and data may all change	The card says so. The config shows it only when model_type, the layer layout or vocab_size change; an identical config cannot rule out new pretraining
Point release	New post-training on an existing pretrained base	The card names the earlier model; config.json is identical except for a handful of keys, often the context length
Derivative	A quantisation, fine-tune, adapter or merge of somebody’s published model	The card’s base_model metadata names the parent; the Hub counts children per model

⌚Version note

The tables were produced with the huggingface_hub library at Hugging Face CLI 1.30.0 · verified 2026-09-08. A licence in this lesson is the Hub’s license: tag plus the card’s license_name. Neither substitutes for reading the licence file in the repository you are about to download from.

The map on 12 September 2026

“Newest main-line release” means the newest generation or dated point release of a family’s general-purpose models, by repository creation date; quantised copies, safety classifiers, speech and research checkpoints are left out.

Family	Publisher, Hub namespace	Newest main-line release (repository created)	Architectures in the family	Licence tags on recent main-line repositories	Gated	In this course
Llama	Meta, meta-llama	Llama 4 Scout and Maverick (2025-04-02)	dense (3.x); MoE with image input (4)	llama3.1, llama3.2, llama3.3; other (llama4)	yes, manual approval	Llama 3.1 8B Instruct, cross-engine comparison; Llama 3.1 405B Instruct, two-Spark lab
Qwen	Alibaba, Qwen	Qwen3.8 (2026-08-05)	dense, MoE, hybrid linear attention, vision, coder, embedding, reranker	apache-2.0 on most; other on Qwen3.8-2.4T-A95B and Qwen3.8-Flash-Next	no	most of the reference set, 0.6B to 235B
DeepSeek	DeepSeek, deepseek-ai	DeepSeek-V4.1-Flash (2026-09-10)	MoE with latent, sparse or compressed attention	mit	no	none; its reports explain routing in the next lesson
gpt-oss	OpenAI, openai	gpt-oss-20b and gpt-oss-120b (2025-08-04)	MoE, alternating sliding and full attention, native MXFP4	apache-2.0	no	gpt-oss-20b and gpt-oss-120b
Gemma	Google, google	Gemma 4 (2026-03-02; the 12B size followed on 2026-05-23)	dense, MoE, per-layer embeddings, multimodal	gemma (Gemma 3); apache-2.0 (Gemma 4)	Gemma 3 yes; Gemma 4 no	Gemma 4 E4B, small multimodal alternative
Mistral	Mistral AI, mistralai	Mistral Medium 3.5 (2026-03-31)	dense, MoE, vision, speech	apache-2.0 on most; other on Medium 3.5 and Devstral 2 123B	no	Devstral Small 2, dense coder alternative
GLM	Z.ai, zai-org	GLM-5.3 (2026-08-25)	MoE, vision	mit up to GLM-5.2; other (glm-5.3) on GLM-5.3, mit on GLM-5.3-Flash	no	GLM-4.6, MIT alternative at the 256 GB tier
Kimi	Moonshot AI, moonshotai	Kimi-K3 (2026-06-13)	MoE on the DeepSeek-V3 architecture; hybrid linear attention (Kimi-Linear)	other on the K line (modified-mit, then kimi-k3); mit on Kimi-Linear and Kimi-VL	no	none
MiniMax	MiniMax, MiniMaxAI	MiniMax-M3 (2026-06-02)	MoE	apache-2.0 (M1); other from M2 (modified-mit, then minimax-community)	no	none
Nemotron	NVIDIA, nvidia	Nemotron 3.5 Lightning 30B-A3B (2026-08-01)	hybrid Mamba-2, MoE and attention	other (nvidia-nemotron-open-model-license; openmdw-1.1 on 3.5)	no	Nemotron 3 Nano 30B-A3B, hybrid alternative; NVIDIA’s Parakeet TDT 0.6B v3 (CC-BY-4.0), a speech-recognition reference model outside the Nemotron line
Phi	Microsoft, microsoft	Phi-4-reasoning-vision-15B (2026-01-23)	dense, small MoE	mit	no	none
Granite	IBM, ibm-granite	Granite 4.2 (2026-08-07)	dense; hybrid Mamba-2 with MoE (the -h- models)	apache-2.0	no	none
SmolLM	Hugging Face, HuggingFaceTB	SmolLM3-3B (2025-06-19 base, 2025-07-08 instruct)	dense, no positional encoding on one layer in four	apache-2.0	no	none; Part 12 reads its data recipe
OLMo	Ai2, allenai	Olmo-Hybrid-7B (2026-01-28)	dense with sliding-window layers; hybrid linear attention	apache-2.0	no	none; the strict meaning of “open source”

The families this course builds on

Qwen3 and gpt-oss do most of the work in the labs, because they are Apache-2.0 and published in every file format the four tracks need. Llama 3.1 8B Instruct stays as the cross-engine comparison model despite its community licence and gating, and Gemma 4 E4B as the small multimodal alternative.

Qwen, from Alibaba

Its organisation page describes Qwen as Alibaba Cloud’s large language model group. On 12 September 2026 its namespace held 465 repositories whose id contains “qwen”, more than any other family here counted the same way; Gemma came next with 411 (including PaliGemma, T5Gemma and CodeGemma), then Granite with 241.

Qwen3 passes every rule in the reference-set table, and it ships dense and mixture-of-experts models at the same tier, which is what makes the next lesson’s comparison possible.

The Qwen3-8B card is worth opening as a specimen: 8.2 billion parameters of which 6.95 billion are outside the embeddings, 36 layers, 32 query heads and 8 key-value heads, a native context window of 32,768 tokens extensible with YaRN to 131,072, and a switch between a thinking mode and a non-thinking mode.

The releases since show why a family name is neither a licence nor a tokeniser. From Qwen3.5 in February 2026 the 27B model (Qwen/Qwen3.5-27B, apache-2.0) declares vocab_size 248,320 and makes 48 of its 64 layers linear attention, so nothing in it pairs with a Qwen3 model by tokeniser. Qwen3.8-27B carries apache-2.0, but Qwen3.8-2.4T-A95B carries other with the licence name qwen3.8-max and Qwen3.8-Flash-Next carries other with qwen-community-1.0: one version number, three licences.

gpt-oss, from OpenAI

gpt-oss is a pair of mixture-of-experts models, gpt-oss-120b and gpt-oss-20b, both Apache-2.0. The larger card gives 117 billion total parameters with 5.1 billion active per token and says the model was designed to run on a single 80 GB accelerator; the smaller gives 21 billion total with 3.6 billion active and says it runs within 16 GB of memory.

Two things make them unusual teaching material. Their weights ship natively in MXFP4, a four-bit floating-point format, and the 20b config.json shows exactly where: its quantisation block lists the attention layers, the router, the embeddings and the output head as not converted, so only the experts are four-bit. Part 16 uses this as its worked example of quantisation-aware publishing. And both cards specify low, medium and high reasoning effort plus the harmony response format, which Part 10 uses when it teaches chat templates. The same config declares 32 experts with 4 per token and 24 layers alternating between full attention and a 128-token sliding window.

There has been one main-line release: both repositories were created on 2025-08-04, and only the two gpt-oss-safeguard repositories have appeared since. One release is not a cadence.

Llama, from Meta

Llama is the family with the longest tail of downstream work, and that is now a number: the Hub counts 7,085 repositories declaring Llama 3.1 8B Instruct as their base, the most of any model counted in this lesson (the table in Where each family is strong). Every meta-llama repository is gated with manual approval: you accept the licence on the model page, wait for approval, and download with an authentication token.

The course keeps Llama 3.1 8B Instruct, under the Llama 3.1 Community License, as its cross-engine comparison model: 910 quantised copies declare it as their parent, second in the table only to Qwen3.8-27B’s 1,053, and accumulated over 25 months rather than 38 days, so it is the checkpoint most likely to exist in the format an older engine build wants. That licence attaches naming and attribution conditions, and its section 2 is a single user-count test pinned to one date: “If, on the Llama 3.1 version release date” (23 July 2024, per Meta’s model card), the products or services of a licensee or its affiliates had more than “700 million monthly active users in the preceding calendar month”, it “must request a license from Meta”. Part 3’s licence lesson works through every condition.

Two dates matter for planning. The Llama 4 repositories were created on 2025-04-02 with a new naming scheme, Llama-4-Scout-17B-16E, where the card reads 17B as activated parameters and 16E as experts, and gives 109B total. And no main-line Llama repository has been created since: seventeen months of silence at the map date.

Gemma, from Google

Gemma is the family whose licence changed between generations. Gemma 3 repositories carry the gemma tag, Google’s own terms of use, and are gated with manual approval; the Gemma 3 27B card describes 1B, 4B, 12B and 27B sizes with a 128K context window above 1B. Gemma 4 repositories carry apache-2.0 and are not gated.

Gemma 4 also introduced a size notation of its own. Its card lists E2B, E4B, 12B, 26B A4B and 31B, and explains that the “E” means effective parameters: Per-Layer Embeddings give every decoder layer its own small embedding table, which is looked up rather than computed, so E4B has 4.5 billion effective parameters and 8 billion with embeddings. The 26B A4B is a mixture of experts with 25.2 billion total and 3.8 billion active. The small models have a 128K window, the larger ones 256K. The course’s Gemma 4 E4B entry is Apache-2.0 on the card read on 2026-09-08. The sizes did not arrive together: E2B and E4B on 2026-03-02, 26B A4B and 31B nine days later, 12B on 2026-05-23.

!Important

The course’s rule for licences is on the models reference page: every model the course names carries the licence recorded in its data file, and where that file says the licence is unverified, the page says so rather than guessing.

The large mixture-of-experts families

These are models a single desktop machine can rarely hold, and the reason Parts 18 to 21 exist. To a reader with one machine they are a target: the thing you will run across two machines, run quantised and slow, or decide not to run.

Family	Specimen, licence tag (card licence name)	Total / active parameters	Routed experts + shared, per token	Context	Before you plan around it
DeepSeek	deepseek-ai/DeepSeek-V4-Flash, mit	284B / 13B (card)	256 + 1, 6 (config)	one million tokens (card)	No Jinja chat template ships; the card points to its own Python encoding scripts
DeepSeek	deepseek-ai/DeepSeek-V3.2, mit	671B / 37B (V4 card’s figures for DeepSeek-V3.2-Base)	256 + 1, 8 (config)	163,840 (max_position_embeddings)	No Jinja chat template either; the card describes a revised tool-calling format and a new developer role
GLM	zai-org/GLM-4.6, mit	357B / 32B (course data file)	160 + 1, 8 (config)	200K (card)	Card: context raised from 128K to 200K over GLM-4.5
Kimi	moonshotai/Kimi-K2-Instruct-0905, other (modified-mit)	1T / 32B (card)	384 + 1, 8 (card and config)	256K (card)	Card: this point release raised the context from 128k to 256k
MiniMax	MiniMaxAI/MiniMax-M2, other (modified-mit)	230B / 10B (card)	256, 8 (config)	196,608 (max_position_embeddings)	Card metadata names modified-mit while its badge reads MIT; open the LICENSE file

DeepSeek describes itself as a Chinese company founded in 2023. Its V3 technical report documents the routing and shared-expert design the next lesson uses. The missing Jinja template matters locally: an engine that renders chat from a Jinja template has nothing to render until someone writes one, which is the failure Part 10’s chat-template lesson teaches you to recognise.

GLM, from Z.ai, released a new version roughly every two months through 2025 and 2026, all under MIT until GLM-5.3.

Kimi, from Moonshot AI, shows architecture reuse in the open: Kimi-K2’s config.json names DeepSeek-V3’s model class, so an engine’s DeepSeek-V3 loading code handles its layers; the tokeniser is Moonshot’s own (tokenization_kimi.py and tiktoken.model, vocab_size 163,840 against DeepSeek-V3’s 129,280) and needs support of its own. MiniMax publishes the M series; its licence moved from apache-2.0 on M1 to modified-mit on M2 and minimax-community on M3, three names in twelve months.

Mistral AI runs several lines in parallel (Ministral, Small, Medium, Large, Devstral, Magistral, Voxtral) with a date stamp in most names, and the licence is per model: most carry apache-2.0, but Mistral Medium 3.5 and Devstral 2 123B carry other, as did Mistral-Small-Instruct-2409, Ministral-8B-Instruct-2410 and Mistral-Large-Instruct-2411 (licence name mrl), the first three releases in the cadence table below. The course’s coder alternative is published as mistralai/Devstral-Small-2-24B-Instruct-2512: Apache-2.0, not gated when checked on 2026-09-12, a 24B dense model whose card describes FP8 weights and a 256k context window.

The small, the open and the specialised

The final group is where machines of 8 to 24 GB spend most of their time, and where the most methodologically interesting work happens.

Family	Specimen, licence tag	Parameters	Layer layout, from config.json	Context	Published beyond the weights
Nemotron	nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16, other (nvidia-nemotron-open-model-license)	30B total / 3.5B active (card)	52 layers: 23 Mamba-2, 23 MoE, 6 attention; 128 experts + 1 shared, 6 per token	1M (card); 262,144 in config.json	pretraining and post-training datasets linked from the card; data cut-off dates
Granite	ibm-granite/granite-4.0-h-small, apache-2.0	32B total / 9B active (card)	40 layers: 36 Mamba-2, 4 attention; 72 experts, 10 per token	128K (card)	description of the fine-tuning data sources
Phi	microsoft/phi-4, mit	14.7B (Hub safetensors count)	40 attention layers, 10 key-value heads	16K (card)	data overview: synthetic “textbook-like” data, filtered public web, acquired books; 9.8T tokens
SmolLM	HuggingFaceTB/SmolLM3-3B, apache-2.0	3.1B (Hub safetensors count)	36 attention layers, rotary position encoding removed on one in four	trained at 64k, 128k with YaRN (card)	pretraining datasets, training configs, intermediate checkpoints
OLMo	allenai/Olmo-3-7B-Instruct, apache-2.0	7.3B (Hub safetensors count)	32 layers: 24 sliding-window (4,096 tokens), 8 full attention	65,536 (max_position_embeddings)	pretraining and post-training datasets, code, checkpoints

Nemotron, from NVIDIA, is the course’s hybrid example; the hybrid_override_pattern string in its config spells the layout one letter per layer, M for Mamba-2, E for a mixture-of-experts layer and * for attention, the mapping in transformers 5.16.1’s NemotronH configuration. NVIDIA also republishes other publishers’ models under its own namespace, nvidia/Qwen3-Nemotron-235B-A22B-GenRM (apache-2.0) for one, so an nvidia/ search result is not necessarily a Nemotron.

Granite, from IBM, pitched at enterprise use, marks its hybrids in the name: the configs of granite-4.0-h-small and granite-4.0-micro (both apache-2.0) declare the same model class, but the first has 36 Mamba-2 layers and the second has 40 attention layers and none. IBM published its own MLX conversions of Granite 4.2 on 2026-09-01, so Mac readers need not wait for a community copy.

Phi, from Microsoft, is the family built on synthetic training data. The phi-4 card warns that most of its Python training data uses a handful of standard packages (typing, math, random, collections, datetime, itertools) and asks users to verify other API uses.

SmolLM, from Hugging Face, publishes its homework: the SmolLM3-3B card links the pretraining datasets, the training configurations and the intermediate checkpoints, and Part 12’s data lesson reads that line of work. OLMo, from the non-profit Ai2, goes further: Ai2’s Olmo page describes releasing the pretraining, mid-training and post-training data mixes, the Olmo 3 card links its Dolci post-training datasets and releases code and checkpoints, and Ai2 publishes every post-training stage as its own repository (Olmo-3-7B-Instruct-SFT, -DPO, then -Instruct), so you can measure what each stage changed. OLMo is what “open source” means applied strictly; Part 3 draws that line.

Reading a family’s fingerprint from config.json

A card is written to persuade; config.json is written to be loaded, so it cannot exaggerate. A dozen fields in it identify the lineage and the design priorities of a family. The script below reads them for nine specimens. It needs only huggingface_hub, which Part 2’s lab installed: in ~/llm-course/.venv on Tracks X, M and N (run source ~/llm-course/.venv/bin/activate first), and inside the NGC container on Track S (after a container restart, run pip install huggingface_hub there again). Save each script on this page under its title and run it with its file name, for example python fingerprint.py. Each config is a few kilobytes and goes into the Hugging Face cache.

RunnableAll tracks

fingerprint.py

import json
from collections import Counter
from huggingface_hub import hf_hub_download

REPOS = ["Qwen/Qwen3-8B", "Qwen/Qwen3.8-27B", "openai/gpt-oss-20b",
         "moonshotai/Kimi-K2-Instruct-0905",
         "nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16",
         "ibm-granite/granite-4.0-h-small", "microsoft/phi-4",
         "HuggingFaceTB/SmolLM3-3B", "allenai/Olmo-3-7B-Instruct"]

def first(cfg, *keys):
    return next((cfg[k] for k in keys if cfg.get(k) is not None), "-")

for repo in REPOS:
    with open(hf_hub_download(repo, "config.json")) as f:
        top = json.load(f)
    cfg = top.get("text_config", top)       # multimodal repos nest the LLM
    kinds = Counter(cfg.get("layer_types")
                    or list(cfg.get("hybrid_override_pattern", "")))
    if "kv_lora_rank" in cfg:               # DeepSeek-style latent attention
        kv = f"latent rank {cfg['kv_lora_rank']}"
    else:
        head_dim = cfg.get("head_dim") or cfg["hidden_size"] // cfg["num_attention_heads"]
        kv = f"{cfg['num_key_value_heads']} x {head_dim}"
    print(repo)
    print("  ", top["architectures"][0], "| layers", cfg["num_hidden_layers"],
          dict(kinds) if kinds else "(all attention)")
    print("   experts", first(cfg, "num_experts", "num_local_experts", "n_routed_experts"),
          "per token", first(cfg, "num_experts_per_tok"), "| kv", kv,
          "| vocab", cfg["vocab_size"], "| max_pos", cfg["max_position_embeddings"])

Output — what you should see

fingerprint.py, huggingface_hub 1.30.0, run on 2026-09-12 without a token

Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.
Qwen/Qwen3-8B
   Qwen3ForCausalLM | layers 36 (all attention)
   experts - per token - | kv 8 x 128 | vocab 151936 | max_pos 40960
Qwen/Qwen3.8-27B
   Qwen3_5ForConditionalGeneration | layers 64 {'linear_attention': 48, 'full_attention': 16}
   experts - per token - | kv 4 x 256 | vocab 248320 | max_pos 262144
openai/gpt-oss-20b
   GptOssForCausalLM | layers 24 {'sliding_attention': 12, 'full_attention': 12}
   experts 32 per token 4 | kv 8 x 64 | vocab 201088 | max_pos 131072
moonshotai/Kimi-K2-Instruct-0905
   DeepseekV3ForCausalLM | layers 61 (all attention)
   experts 384 per token 8 | kv latent rank 512 | vocab 163840 | max_pos 262144
nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16
   NemotronHForCausalLM | layers 52 {'M': 23, 'E': 23, '*': 6}
   experts 128 per token 6 | kv 2 x 128 | vocab 131072 | max_pos 262144
ibm-granite/granite-4.0-h-small
   GraniteMoeHybridForCausalLM | layers 40 {'mamba': 36, 'attention': 4}
   experts 72 per token 10 | kv 8 x 128 | vocab 100352 | max_pos 131072
microsoft/phi-4
   Phi3ForCausalLM | layers 40 (all attention)
   experts - per token - | kv 10 x 128 | vocab 100352 | max_pos 16384
HuggingFaceTB/SmolLM3-3B
   SmolLM3ForCausalLM | layers 36 {'full_attention': 36}
   experts - per token - | kv 4 x 128 | vocab 128256 | max_pos 65536
allenai/Olmo-3-7B-Instruct
   Olmo3ForCausalLM | layers 32 {'sliding_attention': 24, 'full_attention': 8}
   experts - per token - | kv 32 x 128 | vocab 100278 | max_pos 65536

The warning goes away once you are signed in (the shortlist lab’s Task 2). Four readings come out of those lines:

Field	What it tells you	What the run shows
architectures	The code path an engine uses to load the layers; a family that reuses another’s class inherits that code path, but the tokeniser must be checked separately	Kimi-K2 loads as DeepseekV3ForCausalLM; Phi-4 as Phi3ForCausalLM, the class of the previous Phi generation
vocab_size, with bos_token_id	Tokeniser lineage. Equal values are evidence, not proof, of a shared tokeniser; compare tokenizer.json to be sure	Qwen3: 151,936 on all eight sizes; Qwen3.8: 248,320. Phi-4 and Granite 4.0: 100,352 and bos_token_id 100,257. SmolLM3: 128,256 and 128,000, the same pair as Llama 3.1 8B Instruct’s config
Layer types	How many layers keep a key-value cache that grows with every token	4 of 40 in Granite 4.0 H Small, 6 of 52 in Nemotron 3 Nano, 16 of 64 in Qwen3.8-27B, all 36 in Qwen3-8B
Experts and experts per token	The mixture-of-experts ratio, which sets how much of the model each token touches	384 and 8 in Kimi-K2; 32 and 4 in gpt-oss-20b

The layer types turn into memory with the key-value cache formula from Part 2, applied only to the layers whose cache keeps growing (it returns in the memory lesson):

Pseudocode — not a real command

bytes_per_token = 2 × growing_layers × kv_heads × head_dim × bytes_per_element   (2 at FP16)

This is arithmetic from the configs above, at FP16, in decimal gigabytes; sliding-window, Mamba-2 and linear-attention layers add a fixed amount that is not in the last column.

Specimen	Layers with a growing cache	KV heads × head_dim	Bytes per token	Growing cache at 32,768 tokens
Qwen3-8B	36 of 36	8 × 128	147,456	4.83 GB
Phi-4	40 of 40	10 × 128	204,800	3.36 GB at its 16,384 limit
SmolLM3-3B	36 of 36	4 × 128	73,728	2.42 GB
Olmo 3 7B	8 of 32 (24 capped at 4,096 tokens)	32 × 128	131,072	4.29 GB, plus up to 1.61 GB in the capped layers
Qwen3.8-27B	16 of 64 (48 linear attention)	4 × 256	65,536	2.15 GB
gpt-oss-20b	12 of 24 (12 capped at 128 tokens)	8 × 64	24,576	0.81 GB
Granite 4.0 H Small	4 of 40 (36 Mamba-2)	8 × 128	16,384	0.54 GB
Nemotron 3 Nano 30B-A3B	6 of 52 (23 Mamba-2, 23 MoE)	2 × 128	6,144	0.20 GB

The models reference page gives Nemotron 3 Nano a larger per-token figure because its data entry counts all 52 layers with 8 key-value heads; only the 6 attention layers keep a growing cache, with the 2 heads the config declares. The table is the mechanism behind “good at long context on small machines”: the families at its bottom were designed so that most layers stop paying per token. The next lesson explains the layer types themselves.

✕Common mistake

max_position_embeddings is what the config allows, not what the card says the model was trained for. Qwen3-8B’s config says 40,960; its card says 32,768 native and explains the difference as 32,768 tokens reserved for output plus 8,192 for a typical prompt. Read the context window from the card, and use the config value only to check what an engine will accept by default.

Release cadence

How a generation or point release arrives varies more than the phrase “a new release” suggests:

Release	Repositories created	Pattern
Qwen3	0.6B, 1.7B, 4B, 8B, 14B, 32B, 30B-A3B and 235B-A22B, all on 2025-04-27	the whole ladder in one day
Qwen3 2507 point release	235B-A22B-Instruct on 2025-07-21, 30B-A3B-Instruct on 2025-07-28, 4B-Instruct on 2025-08-05	staged over fifteen days, largest first
Gemma 4	E2B and E4B on 2026-03-02, 26B A4B and 31B on 2026-03-11, 12B on 2026-05-23	staged over twelve weeks

So when one size of a new generation appears, look for its siblings over the following weeks before choosing a size.

The cadence of each family over the two years to the map date is arithmetic on the repository creation dates of its main-line releases, with the same exclusions as the map. The silence ratio divides the months since the newest release by the family’s median gap.

Family	Main-line releases, 2024-09-12 to 2026-09-12	Count	Median gap, months	Months since newest	Silence ratio
DeepSeek	V3, R1, V3-0324, R1-0528, V3.1, V3.2-Exp, V3.2, V4, V4.1-Flash	9	2.1	0.1	under 0.1
GLM	4-0414, 4.5, 4.6, 4.7, 5, 5.1, 5.2, 5.3	8	2.3	0.6	0.3
Qwen	2.5, 3, 3-2507, 3-Next, 3.5, 3.6, 3.8	7	3.2	1.2	0.4
Granite	3.0, 3.1, 3.2, 3.3, 4.0, 4.1, 4.2	7	3.2	1.2	0.4
Nemotron	Nano 9B v2, 3 Nano, 3 Super, 3 Ultra, 3.5 Lightning	5	3.0	1.4	0.5
Gemma	3, 3n, 4	3	6.0	6.4	1.1
Kimi	K2, K2-0905, K2-Thinking, K2.5, K2.6, K3	6	2.0	3.0	1.5
MiniMax	Text-01, M1, M2, M2.1, M2.5, M2.7, M3	7	1.9	3.4	1.8
SmolLM	SmolLM2, SmolLM3	2	7.6	14.8	1.9
Phi	4, 4-mini, 4-reasoning, 4-mini-flash-reasoning, 4-reasoning-vision	5	2.3	7.6	3.3
Mistral	Small 2409, Ministral 8B 2410, Large 2411, Small 3, Small 3.1, Magistral Small, Small 3.2, Ministral 3, Large 3, Small 4, Medium 3.5	11	1.6	5.4	3.4
OLMo	2 (1124), 2 32B (0325), 2 1B (0425), 3 (1025), 3 32B (1125), 3.1, Hybrid	7	1.7	7.5	4.3
Llama	3.2, 3.3, 4	3	3.2	17.3	5.4
gpt-oss	gpt-oss	1	no gap to measure	13.3	not defined

Gemma 4’s 12B and Gemma 3’s 270M arrived weeks or months after their generation’s first sizes and count inside it, because the cards list them among that generation’s sizes; OLMo’s 32B and 1B count separately because each carries its own date stamp. The ratio divides day counts before rounding, which is why OLMo shows 4.3 (227 days over a 53-day median) rather than 7.5 ÷ 1.7.

The ratio gives a planning rule. Below 1, expect a newer release before you finish the part of the course you are on, so check the namespace on the day you download. Between 1 and 3, a release is due or overdue: check the namespace with newest-releases.py before committing to a download, and prefer a size that already has GGUF and MLX copies. Above 3, the line may have paused or stopped publishing open weights: read the organisation page and the publisher’s announcements before you plan a project around a successor that may not come.

∴Research note

The Hub documents createdAt as the date the repository was created, which is not the date it was made public. A repository prepared privately is created first: mistralai/Ministral-3-8B-Instruct-2512 (apache-2.0) was created on 2025-10-31 and mistralai/Voxtral-4B-TTS-2603 (cc-by-nc-4.0) on 2025-11-17, weeks and months before the month in their own names. Gaps measured from creation dates can therefore be off by months for a publisher that works this way; treat the medians as the shape of a cadence, not a schedule.

A point release, measured

The claim that a point release changes post-training rather than architecture is checkable in twenty seconds. Compare the configs of the original Qwen3-30B-A3B and its July 2025 point release:

RunnableAll tracks

diff-configs.py

import json
from huggingface_hub import hf_hub_download

OLD = "Qwen/Qwen3-30B-A3B"
NEW = "Qwen/Qwen3-30B-A3B-Instruct-2507"

def config(repo):
    with open(hf_hub_download(repo, "config.json")) as f:
        return json.load(f)

old, new = config(OLD), config(NEW)
changed = sorted(k for k in old.keys() | new.keys() if old.get(k) != new.get(k))
print(f"{len(changed)} of {len(old.keys() | new.keys())} keys differ")
for key in changed:
    print(f"  {key}: {old.get(key)} -> {new.get(key)}")

Output — what you should see

diff-configs.py, huggingface_hub 1.30.0, run on 2026-09-12 without a token

Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.
2 of 34 keys differ
  max_position_embeddings: 40960 -> 262144
  rope_theta: 1000000.0 -> 10000000

Same layers, experts, heads and vocabulary size, so an engine that loads one architecture loads the other. The config does not show the tokeniser files or the chat template, and the card says the 2507 release supports only non-thinking mode, so compare tokenizer.json and the template separately. What did change is the context the model accepts, and that is a memory decision. With the course data file’s 98,304 bytes per token for this model:

Context length	Growing cache at FP16
40,960 (original default)	4.03 GB
262,144 (2507 default)	25.77 GB

A point release you drop in as “the same model” can ask for six times the cache if you let the engine take the config’s default.

The version number is no better a guide in the other direction. With OLD = "Qwen/Qwen3.6-27B" (apache-2.0) and NEW = "Qwen/Qwen3.8-27B", the same script prints:

Output — what you should see

diff-configs.py with OLD and NEW changed, huggingface_hub 1.30.0, run on 2026-09-12 without a token

Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.
1 of 11 keys differ
  transformers_version: 4.57.1 -> 5.8.0.dev0

The nested text_config, with every layer, head and the 248,320-entry vocabulary, compares equal. Two version steps on the name, one changed key in the config: for your engine this release behaves as a point release, and only the card can tell you whether its weights came from new pretraining.

Naming conventions, family by family

Reading a model name takes a generic identifier apart field by field. What that lesson cannot show is how differently the families fill those fields:

Family	Real identifiers	Size is written as	Variant is written as	Stamp in the name
Qwen	Qwen3-30B-A3B-Instruct-2507, Qwen3.8-2.4T-A95B	total, then A and active; T for trillions	-Instruct, -Thinking, -Base; Coder, VL in the family field	-2507, consistent with YYMM
Llama	Llama-3.1-8B-Instruct, Llama-4-Scout-17B-16E-Instruct	total in 3.x; active B and expert count E in 4	-Instruct; base has no suffix	point number
gpt-oss	gpt-oss-20b, gpt-oss-120b	rounded total, lower-case b	none	none
Gemma	gemma-3-27b-it, gemma-4-E4B-it, gemma-4-26B-A4B-it	E effective, A active	-it instruct; -pt (Gemma 3) or no suffix (Gemma 4) for base; -qat- for quantisation-aware	generation number
DeepSeek	DeepSeek-V3.2, DeepSeek-R1-0528 (mit), DeepSeek-V4-Flash	absent; Flash and Pro tiers in V4	R line for reasoning; -Base	-0528, consistent with MMDD
Mistral	Devstral-Small-2-24B-Instruct-2512, Mistral-Small-4-119B-2603 (apache-2.0)	tier word, often with the total	-Instruct, -Reasoning, -Base	-2512, consistent with YYMM
GLM	GLM-4.6, GLM-4.5-Air, GLM-4.6V, GLM-4-32B-0414	mostly absent; Air, Flash for smaller tiers	V for vision; -Base	version number; -0414 consistent with MMDD
Kimi	Kimi-K2-Instruct-0905, Kimi-Linear-48B-A3B-Instruct	absent in the K line; total and active elsewhere	-Instruct, -Thinking, -Base	-0905, consistent with MMDD
MiniMax	MiniMax-M2.5, MiniMax-M1-80k	absent	-40k and -80k are thinking budgets on M1 (card)	version number
Nemotron	NVIDIA-Nemotron-3-Nano-30B-A3B-BF16, NVIDIA-Nemotron-Nano-9B-v2	tier word (Nano, Super, Ultra) plus total and active	-Base; precision suffix -BF16, -FP8	generation number; -v2 earlier
Phi	phi-4, Phi-4-mini-instruct, Phi-4-reasoning-plus	tier word (mini, tiny) or total	-instruct, -reasoning, -reasoning-plus	generation number
Granite	granite-4.0-h-small, granite-4.2-8b	tier word (micro, tiny, small) in 4.0; total from 4.1	-h- for the Mamba-2 hybrids; -base	version number
SmolLM	SmolLM3-3B, SmolLM3-3B-Base	total	no suffix is instruct; -Base	generation number
OLMo	OLMo-2-0425-1B, Olmo-3-7B-Think, Olmo-3-7B-Instruct-DPO	total	-Instruct, -Think, and the stage: -SFT, -DPO	-1124, -0425, -1025, consistent with MMYY

“Consistent with” is doing real work in that last column, because publishers do not document the convention and the same four digits read differently. Take 0425:

Read as	Meaning	Checked against a creation date
MMDD, the DeepSeek, Kimi and GLM habit	25 April	DeepSeek-R1-0528 was created on 2025-05-28, matching 28 May
MMYY, the OLMo habit	April 2025	OLMo-2-0425-1B was created on 2025-04-17, inside April 2025
YYMM, the Qwen and Mistral habit	month 25 of 2004, impossible	Qwen3-30B-A3B-Instruct-2507 was created on 2025-07-28, inside July 2025

The rule: never decode a stamp from the name alone; read it next to createdAt.

Where each family is strong

“Strong” in this course means a property you can check, not a leaderboard position. Pick the row that matches your hardest constraint, then shortlist from it:

If your hardest constraint is	Shortlist	Evidence you can check (2026-09-12)	In the reference set
A permissive licence on every size you might use	Qwen3, gpt-oss, Gemma 4, Granite, SmolLM, OLMo (Apache-2.0); Phi (MIT)	license: tags per repository; not Qwen3.8’s largest, GLM-5.3, Kimi or MiniMax M2 onwards	the Qwen3 set, gpt-oss
One tokeniser from the smallest size to the largest	Qwen3	vocab_size 151,936 on all eight sizes	Qwen3 0.6B to 235B
Long context in little memory	Nemotron 3, Granite 4.0 H, gpt-oss, Qwen3.8	growing-cache table above	Nemotron 3 Nano (alternative)
Fewest bytes read per generated token	mixture-of-experts: gpt-oss, Qwen3-30B-A3B, Gemma 4 26B A4B	active and total on the card	gpt-oss-20b, Qwen3-30B-A3B
A 96 to 128 GB machine without third-party quantisation	gpt-oss-120b	experts published in MXFP4 by the publisher	gpt-oss-120b
The widest downstream ecosystem	Llama 3.1, Qwen3	derived-repository counts below	Llama 3.1 8B (comparison)
Reproducible training: data, code, checkpoints	OLMo, SmolLM; Nemotron for datasets	links on the card	none; Part 12
Open weights at the trillion-parameter scale	Kimi, DeepSeek, Qwen3.8-2.4T-A95B	total parameters on the card	none; Parts 18 to 21 use Qwen3-235B-A22B
Image and audio input on a small machine	Gemma 4 E2B and E4B	modalities on the card	Qwen3-VL-8B (image); Gemma 4 E4B (image and audio, alternative)
A coder with documented tool calling	Qwen3-Coder, Devstral Small 2	tool-calling section of the card	Qwen3-Coder-30B-A3B; Devstral Small 2

“Fewest bytes read per token” is the decode arithmetic from Part 3: gpt-oss-20b reads its 3.6B active parameters per token out of 21B total (card), about a sixth of the bytes a dense 21B model would read at the same precision.

The ecosystem row is measurable because the Hub counts repositories whose card declares a model as base_model, by relation. These are the childrenModelCount values on 2026-09-12; repositories that do not declare their parent are not counted, so every figure is a lower bound, and a count measures how much has been built on a model, not how good it is.

Parent repository	Created	Months on the Hub	Fine-tunes	Adapters	Quantisations	Merges	Total	Total per month
meta-llama/Llama-3.1-8B-Instruct	2024-07-18	25.8	3,186	2,886	910	103	7,085	274
Qwen/Qwen3-8B	2025-04-27	16.5	2,072	2,150	408	28	4,658	282
Qwen/Qwen3.8-27B	2026-08-05	1.2	325	81	1,053	15	1,474	1,181
openai/gpt-oss-20b	2025-08-04	13.3	552	458	235	7	1,252	94
google/gemma-4-E4B-it	2026-03-02	6.4	355	345	345	1	1,046	164
microsoft/phi-4	2024-12-11	21.0	115	205	165	2	487	23
allenai/Olmo-3-7B-Instruct	2025-11-19	9.8	306	57	40	1	404	41
nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16	2025-12-04	9.3	60	275	68	0	403	44
HuggingFaceTB/SmolLM3-3B	2025-07-08	14.2	150	62	114	4	330	23
ibm-granite/granite-4.0-h-small	2025-09-16	11.9	9	125	36	0	170	14
zai-org/GLM-4.6	2025-09-29	11.4	19	3	39	0	61	5
deepseek-ai/DeepSeek-V3.2	2025-12-01	9.4	34	7	19	1	61	7
MiniMaxAI/MiniMax-M2	2025-10-22	10.7	15	2	39	2	58	5
moonshotai/Kimi-K2-Instruct-0905	2025-09-03	12.3	3	2	16	0	21	2

Two patterns stand out. The models people fine-tune are the ones that fit on the machines people own: the 8B checkpoints collect thousands of adapters, the trillion-parameter ones collect a handful. And quantisations of a popular new release arrive fast: Qwen3.8-27B gathered 1,053 in its first 38 days. That is one data point, but a reason not to rule out a model just because it has no GGUF on release day.

The course reference set, and why those

Every lab uses models from one small set, listed on the models reference page with licence, sizes and architecture. The selection rules were applied in order:

Rule	Why the course needs it	How Qwen3 meets it
1. A permissive licence	no lab stops to explain a naming or user-count clause	apache-2.0 on every Qwen3 text model the course uses (Qwen3-Omni carries other with license_name apache-2.0)
2. safetensors, GGUF and MLX all exist	all four tracks run the same model	publisher safetensors, GGUF from unsloth, MLX from mlx-community
3. Documented tool calling	Part 24 tests it	the Qwen3 cards document tool use in thinking and non-thinking modes
4. A size ladder that fills each memory tier	a method learned on 8 GB transfers to 128 GB	eight sizes from 0.6B to 235B
5. One tokeniser across the ladder	distillation pairs and cross-size comparisons	vocab_size 151,936 throughout

That produces a Qwen3-heavy set with deliberate exceptions, each stated where it appears:

Memory tier	Reference models	Exceptions and alternatives, and why
8 GB	Qwen3-0.6B, Qwen3-1.7B, Qwen3-4B, Qwen3-8B, Qwen3-VL-8B-Instruct (vision), Qwen3-Embedding-0.6B and Qwen3-Reranker-0.6B (Apache-2.0)	Llama 3.1 8B Instruct (Llama 3.1 Community License, gated): the cross-engine comparison model; Gemma 4 E4B (Apache-2.0): image and audio alternative; Parakeet TDT 0.6B v3 (CC-BY-4.0): speech
16 GB	Qwen3-14B, gpt-oss-20b (Apache-2.0)	Devstral Small 2 (Apache-2.0): a dense coder
24 GB	Qwen3-30B-A3B, Qwen3-32B, Qwen3-Coder-30B-A3B (Apache-2.0)	Nemotron 3 Nano 30B-A3B (NVIDIA Open Model License): the hybrid architecture example
64 GB	none	Qwen3-Next-80B-A3B (Apache-2.0): hybrid linear attention
96 GB	gpt-oss-120b (Apache-2.0)	native four-bit weights no other open model in the set teaches as cleanly
128 GB and clusters	Qwen3-235B-A22B (Apache-2.0)	none
256 GB and clusters	none	GLM-4.6 (MIT): permissive alternative; Qwen3-Coder-480B-A35B (Apache-2.0): cluster-scale coder; Llama 3.1 405B Instruct (Llama 3.1 Community License, gated): the vendor-documented two-Spark lab

The GGUF files the labs download come from one namespace per family, recorded in the course’s model data: unsloth for Qwen3, ggml-org for gpt-oss. Qwen publishes its own conversions, and they are a sound alternative, but the file listings show why the course standardises elsewhere:

Repository (file listing, 2026-09-12)	Quantisation types published
Qwen/Qwen3-8B-GGUF	Q4_K_M, Q5_0, Q5_K_M, Q6_K, Q8_0
unsloth/Qwen3-8B-GGUF	BF16, IQ4_NL, IQ4_XS, Q2_K, Q2_K_L, Q3_K_S, Q3_K_M, Q4_1, Q4_K_S, Q4_K_M, Q5_K_S, Q5_K_M, Q6_K, Q8_0, plus eleven UD- dynamic types
Qwen/Qwen3-235B-A22B-GGUF	Q4_K_M, Q5_0, Q5_K_M, Q6_K, Q8_0
unsloth/Qwen3-235B-A22B-GGUF	BF16, IQ4_XS, Q2_K, Q2_K_L, Q3_K_S, Q3_K_M, Q4_1, Q4_K_S, Q4_K_M, Q5_K_S, Q5_K_M, Q6_K, Q8_0, plus six UD- dynamic types

The 128 GB tier needs IQ4_XS for the 235B model, and only one namespace ships it alongside every other tier, so every Qwen3 path in the course reads the same way.

Standardising is about comparability. When Part 16 reports what quantisation cost you, the number matters because your neighbour ran the same model. It is also why the set does not move to Qwen3.8 on release day: the tokeniser Qwen adopted at 3.5 breaks every same-tokeniser teacher and student pair with Qwen3 (Part 15), its licences differ by size, its linear-attention layers change the memory arithmetic, and every result already recorded against Qwen3 would stop being comparable. The set moves when a review re-runs this lesson’s procedure and the new candidate passes all five rules.

✦Tip

Nothing stops you using a model that is not in the set. Every lab states the model as a variable at the top of its script for exactly that reason. What you lose is the ability to compare your numbers with anyone else’s, so record the substitution in your lab notebook when you make one.

How to update this map

When a release lands, these checks tell you whether it matters to you. Each can send you back to your current model without downloading a single weight.

Checking a new model release

1. 1List what the publisher creatednewest-releases.py. Confirms the namespace, the creation date, the licence tag and whether the repository is gated. A copy under a namespace you do not recognise may be modified.
2. 2Read the licence on the cardapache-2.0 or mit means no further reading for this course. Anything else, including other, gemma or a company-named licence, means open the licence file before downloading.
3. 3Fingerprint the config and diff itfingerprint.py and diff-configs.py. A changed vocab_size or layer layout is a new generation; a changed context key is a point release with a memory consequence.
4. 4Check the formats your engine needsformats.py. GGUF for llama.cpp and Ollama, MLX for Apple silicon, safetensors for Transformers and vLLM.
5. 5Treat every quoted score as a claimNote who reported it and on what date. The card-and-benchmark lesson in this part is about doing this properly.
6. 6Record what you foundThe notebook entry below. In six months that note is worth more than the model.

Six checks, in the order that fails fastest. The first, third and fourth are the four scripts on this page.

What shipped

RunnableAll tracks

newest-releases.py

from itertools import islice
from huggingface_hub import HfApi

# (Hub namespace, text the repository id must contain; "" keeps everything)
FAMILIES = [
    ("meta-llama", "llama"), ("Qwen", "qwen"), ("deepseek-ai", "deepseek"),
    ("openai", "gpt-oss"), ("google", "gemma"), ("mistralai", ""),
    ("zai-org", "glm"), ("moonshotai", "kimi"), ("MiniMaxAI", "minimax"),
    ("nvidia", "nemotron"), ("microsoft", "phi"), ("ibm-granite", "granite"),
    ("HuggingFaceTB", "smollm"), ("allenai", "olmo-"),
]
NEWEST = 2

api = HfApi()
for namespace, text in FAMILIES:
    found = api.list_models(author=namespace, search=text or None, sort="created_at",
                            expand=["createdAt", "gated", "tags"])
    matches = (m for m in found if text in m.id.lower())   # the search is fuzzy
    for m in islice(matches, NEWEST):
        licence = next((t.split(":", 1)[1] for t in m.tags or []
                        if t.startswith("license:")), "none")
        print(f"{m.created_at:%Y-%m-%d}  {m.id:<52} "
              f"licence={licence:<11} gated={m.gated}")

Output — what you should see

newest-releases.py, huggingface_hub 1.30.0, run on 2026-09-12

2025-04-28  meta-llama/Llama-Prompt-Guard-2-86M                  licence=other       gated=manual
2025-04-28  meta-llama/Llama-Prompt-Guard-2-22M                  licence=other       gated=manual
2026-08-27  Qwen/Qwen-Drive-1.0-4B                               licence=apache-2.0  gated=False
2026-08-24  Qwen/Qwen3.8-Flash-Next-FP8                          licence=other       gated=False
2026-09-10  deepseek-ai/DeepSeek-V4.1-Flash                      licence=mit         gated=False
2026-08-31  deepseek-ai/DeepSeek-V4-Flash-Vision-Exp             licence=mit         gated=False
2025-09-18  openai/gpt-oss-safeguard-20b                         licence=apache-2.0  gated=False
2025-09-18  openai/gpt-oss-safeguard-120b                        licence=apache-2.0  gated=False
2026-06-05  google/gemma-4-12B-it-qat-w4a16-ct                   licence=apache-2.0  gated=False
2026-06-05  google/gemma-4-12B-it-qat-q4_0-gguf                  licence=apache-2.0  gated=False
2026-07-16  mistralai/Shieldstral-1.0-3B                         licence=apache-2.0  gated=False
2026-07-01  mistralai/Leanstral-1.5-119B-A6B                     licence=apache-2.0  gated=False
2026-08-25  zai-org/GLM-5.3-Flash-BF16                           licence=mit         gated=False
2026-08-25  zai-org/GLM-5.3-BF16                                 licence=other       gated=False
2026-06-13  moonshotai/Kimi-K3                                   licence=other       gated=False
2026-06-11  moonshotai/Kimi-K2.7-Code                            licence=other       gated=False
2026-08-07  MiniMaxAI/MiniMax-Music3                             licence=none        gated=False
2026-07-28  MiniMaxAI/MiniMax-H3                                 licence=other       gated=False
2026-09-02  nvidia/Nemotron-3-Labs-Ultra-Math-RL                 licence=other       gated=False
2026-09-02  nvidia/Nemotron-3-Labs-Ultra-Math-SFT                licence=other       gated=False
2026-05-07  microsoft/Phi-Ground-Any                             licence=mit         gated=False
2026-01-23  microsoft/Phi-4-reasoning-vision-15B                 licence=mit         gated=False
2026-09-01  ibm-granite/granite-4.2-30b-bf16-mlx                 licence=apache-2.0  gated=False
2026-09-01  ibm-granite/granite-4.2-30b-q8-mlx                   licence=apache-2.0  gated=False
2026-04-03  HuggingFaceTB/SmolLM3-3B-GSM8K-SFT                   licence=apache-2.0  gated=False
2025-07-20  HuggingFaceTB/SmolLM3-3B-checkpoints                 licence=apache-2.0  gated=False
2026-02-28  allenai/Olmo-Hybrid-Think-SFT-7B                     licence=apache-2.0  gated=False
2026-02-20  allenai/Olmo-Hybrid-Instruct-DPO-7B                  licence=apache-2.0  gated=False

sort="created_at" returns the newest first. Read the output for three things. The newest repository is often not a new generation: here it is a quantisation-aware Gemma 4 copy, IBM’s MLX conversions and NVIDIA research checkpoints, so scan for a generation number you have not seen. The licence column changes inside a family: GLM-5.3-BF16 says other while GLM-5.3-Flash-BF16 says mit. And gated=manual means a person approves access, which can take time; gated=auto means approval is immediate once you accept the terms.

What it is, and can your engine load it

Put the new repository in REPOS in fingerprint.py, and put it and its predecessor in OLD and NEW in diff-configs.py. A changed vocab_size or layer layout means a new generation; engine support and every same-tokeniser pairing start again. Then check formats:

RunnableAll tracks

formats.py

from huggingface_hub import HfApi

REPO = "Qwen/Qwen3.8-27B"
PUBLISHER, NAME = REPO.split("/")
WHERE = {"gguf": ["unsloth", "ggml-org", "bartowski", PUBLISHER],
         "mlx": ["mlx-community"]}

def same_model(repo_id):
    name = repo_id.split("/")[1]
    name = name.split("_", 1)[1] if "_" in name else name   # bartowski/Qwen_Qwen3-8B-GGUF
    return name.lower().startswith(NAME.lower() + "-")

api = HfApi()
info = api.model_info(REPO, expand=["childrenModelCount", "createdAt"])
print(f"{REPO}, created {info.created_at:%Y-%m-%d}")
print("  derived repositories:", info.children_model_count)
for fmt, namespaces in WHERE.items():
    for ns in namespaces:
        hits = [m.id for m in api.list_models(author=ns, search=NAME, filter=fmt)
                if same_model(m.id)]
        print(f"  {fmt:<4} {ns:<13} {len(hits):>2}  {' '.join(hits[:2])}")

Output — what you should see

formats.py, huggingface_hub 1.30.0, run on 2026-09-12

Qwen/Qwen3.8-27B, created 2026-08-05
  derived repositories: {'adapter': 81, 'merge': 15, 'quantized': 1053, 'finetune': 325}
  gguf unsloth        1  unsloth/Qwen3.8-27B-GGUF
  gguf ggml-org       1  ggml-org/Qwen3.8-27B-GGUF
  gguf bartowski      2  bartowski/Qwen3.8-27B-GGUF bartowski/orcarouter_Qwen3.8-27B-Uncensored-GGUF
  gguf Qwen           0
  mlx  mlx-community 17  mlx-community/Qwen3.8-27B-4bit mlx-community/Qwen3.8-27B-MTP-4bit

The search is fuzzy, so the script keeps only repositories whose name starts with the model name, after stripping the Publisher_ prefix that bartowski uses; a fine-tune whose name starts the same way, such as an “Uncensored” variant, still gets through, so read the ids. Here the publisher has shipped no GGUF of its own, unsloth and ggml-org, the namespaces the course records for Qwen3 and gpt-oss, each have one, and mlx-community has several. Before you download any of them, look up the fingerprint’s model class in your engine’s list of supported architectures: a file in the right format is useless to an engine version without code for that class.

Record what you found

One notebook entry per candidate, with the date on everything that can go stale. This example is filled in from this lesson’s own runs:

Pseudocode — not a real command

## Candidate: Qwen/Qwen3.8-27B (checked 2026-09-12)
Publisher and namespace:   Alibaba, Qwen (the publisher's own namespace, not a copy)
Created / predecessor:     2026-08-05 / Qwen/Qwen3.6-27B
Licence tag and name:      apache-2.0 (card license_name, if any: none)   gated: False
Kind of release:           config identical to Qwen3.6-27B apart from transformers_version;
                           tokeniser differs from the Qwen3 set (vocab_size 151936 -> 248320)
Growing-cache layers:      16 of 64, kv 4 x 256, 65,536 bytes per token at FP16
Formats:                   GGUF unsloth, ggml-org; MLX mlx-community; no publisher GGUF
Scores quoted on card:     each noted as a claim with its owner and date; none reproduced
Decision:                  not adopted; recheck engine support in Part 6 before any trial

✕Common mistake

A typo in a repository id looks like gating. With Hugging Face CLI 1.30.0 · verified 2026-09-08, hf_hub_download("mistralai/Devstral-Small-2", "config.json") without a token raises RepositoryNotFoundError: 401 Client Error, and its message contains “If you are trying to access a private or gated repo, make sure you are authenticated”. A truly gated repository raises GatedRepoError instead, with “Cannot access gated repo” and “Access to model … is restricted”. Read the exception class before you request access to a repository that does not exist; here the real id is mistralai/Devstral-Small-2-24B-Instruct-2512.

Compare candidates using a stable task contract

A family name is a starting point for finding candidates. It is not a capability test. Two releases from one publisher can differ in architecture, tokeniser, chat template, licence, reasoning behaviour and supported tools. Record the exact repository and revision before bringing any family-level expectation into an experiment.

Make a shortlist table with one row per concrete artefact and columns for task quality, supported serving path, usable context, memory estimate and licence conditions. Leave unmeasured quality blank. Run the same task file and judge failures by category: extraction errors, unsupported citations, malformed calls and excessive output each suggest different causes.

For practice, choose two checkpoints that fit the same memory budget. Predict which requirement each might satisfy, then write the evidence that would overturn that prediction. The point is to learn how to replace a candidate when a publisher changes its catalogue. A decision based on a recorded task and deployment contract remains understandable long after a list of fashionable family names becomes stale.

Recap

A new repository is a generation, a point release or a derivative, and the Hub can tell you which. config.json gives the model class, the vocabulary size, how many layers keep a growing cache and the expert ratio, though not the tokeniser files; a diff of a few keys can still multiply the cache, and a new version number can hide an unchanged config. Cadence is arithmetic on creation dates, and the silence ratio turns it into a decision about when to check a namespace. Licences and date stamps are read per repository. The course runs on Qwen3 because it passes five checkable rules at once. The map will be stale when you read it; the four scripts and a dated notebook entry are how you refresh it.

Check your understanding

Question 1. A hybrid model's config has 40 layers, of which 4 are attention layers with 8 key-value heads and a head dimension of 128; the rest are Mamba-2. How many bytes of growing key-value cache does each token add at FP16?

• 16,384
• 163,840
• 147,456
• 4,096

Show the answer and why

Answer: 16,384

2 × 4 × 8 × 128 × 2 = 16,384. Only the four attention layers keep a per-token cache; the 36 Mamba-2 layers hold a fixed-size state. Counting all 40 layers would give 163,840, a tenfold overestimate, which is the mistake that makes hybrids look no better than dense models at long context.

Question 2. These four notebook entries were written on the day each model was checked. Which one contains the error?

A  Qwen/Qwen3-14B              licence apache-2.0 (tag read)
B  Qwen/Qwen3.8-2.4T-A95B       licence apache-2.0 (same family as Qwen3)
C  zai-org/GLM-5.3-Flash        licence mit (tag read)
D  google/gemma-4-E4B-it        licence apache-2.0 (tag read), gated False

• A
• B
• C
• D

Show the answer and why

Answer: B

Entry B inferred the licence from the family instead of reading it. On 2026-09-12 that repository carried the tag other with licence name qwen3.8-max, while Qwen3.8-27B in the same generation carried apache-2.0. Every licence is read per repository.

Question 3. diff-configs.py reports that only max_position_embeddings (40,960 to 262,144) and rope_theta changed between a model and its dated point release. Which conclusions follow? Select all that apply.

• The layer layout and vocabulary size are unchanged, so an engine that loads the old model's architecture loads the new one
• If the engine allocates the config default, the growing key-value cache for a full context is about 6.4 times larger
• The new model must be a new pretraining run
• The weights are identical to the old model

Show the answer and why

Answer: The layer layout and vocabulary size are unchanged, so an engine that loads the old model's architecture loads the new one, If the engine allocates the config default, the growing key-value cache for a full context is about 6.4 times larger

262,144 ÷ 40,960 = 6.4, and the cache grows linearly with context, so a drop-in replacement can overflow a memory budget that used to fit. The config cannot tell you the weights are identical; post-training changes the values without changing the shapes, which is exactly what a point release is. Nor does it show the tokeniser or the chat behaviour: tokenizer.json and the chat template must be compared separately, and Qwen3-30B-A3B-Instruct-2507 dropped the thinking mode without any config key saying so.

Question 4. Two repositories carry the stamps -0905 (Kimi-K2-Instruct-0905, created 2025-09-03) and -2507 (Qwen3-30B-A3B-Instruct-2507, created 2025-07-28). What is the defensible reading?

• Both are YYMM: September 2009 and July 2025
• Both are MMDD: 5 September, and the seventh day of a 25th month
• Read against the creation dates, -0905 is consistent with 5 September 2025 and -2507 with July 2025; the families use different conventions
• Stamps are build numbers and carry no date

Show the answer and why

Answer: Read against the creation dates, -0905 is consistent with 5 September 2025 and -2507 with July 2025; the families use different conventions

Publishers do not document their stamp convention, and the same four digits mean different things across families. The creation date is the check: a repository created on 2025-09-03 fits MMDD 0905 two days later, and one created on 2025-07-28 fits YYMM 2507.

Question 5. A family's median gap between main-line releases is 3.2 months, and its newest release was 17.3 months ago. What does the course's planning rule suggest?

• Wait a few weeks, because a new release is due
• The silence ratio is about 5.4, so check the organisation page and announcements before planning around a successor
• The family has certainly stopped publishing
• Nothing can be concluded from release dates

Show the answer and why

Answer: The silence ratio is about 5.4, so check the organisation page and announcements before planning around a successor

17.3 ÷ 3.2 ≈ 5.4, well above the threshold of 3. The rule does not say the family has stopped; it says the pause is long enough that a plan depending on a successor needs evidence first. That was Llama on 2026-09-12.

Question 6. allenai/OLMo-2-0325-32B (apache-2.0) was created on the Hub on 2025-02-23. Which reading of its stamp and its creation date holds up?

• 0325 is 25 March, so the repository was created a month before its own date and the stamp is wrong
• 0325 is March 2025 in OLMo's MMYY habit; creation in late February fits a repository prepared before release, so the model was public no earlier than 2025-02-23, but the Hub date does not say when it became public
• 0325 is YYMM, the 25th month of 2003, so it is a build number
• The model was public from 2025-02-23, because createdAt is the publication date

Show the answer and why

Answer: 0325 is March 2025 in OLMo's MMYY habit; creation in late February fits a repository prepared before release, so the model was public no earlier than 2025-02-23, but the Hub date does not say when it became public

A repository cannot be public before it exists, so createdAt is a lower bound on publication and nothing more. OLMo's other stamps fit MMYY (OLMo-2-0425-1B was created on 2025-04-17), and a creation date just before the stamped month is what private preparation looks like. When you compute a cadence, that lower bound is why a gap can come out shorter or longer than the public one.

Check my answersClear