Part 1 · Part 1: Openness, Graded Honestly
Model-Making Masterclass, Part 1. Written Nov 17, 2026. Engineer voice: plain language, terms defined when they first matter, every claim tied to an artifact you can go read.
Why this part comes first
Every later part of this study compares training decisions: data mixes, architectures, optimizers, RL recipes. A comparison is only worth reading if you can check it, and you can only check what was actually released. “Open” is the word every lab uses and no two labs mean the same thing by it. One lab’s open means a weights download behind a custom license. Another lab’s open means you can download the exact training data sequence, the configs, 360 intermediate checkpoints, and the run logs, and rerun the whole thing on your own hardware if you can pay for the compute.
So before any benchmarks, we grade openness itself. This part does four things. It builds a ladder of openness layers, from weights-only up to a full rerunnable pipeline. It grades every family in the rosters on that ladder, with evidence. It walks the license traps, because the license is where openness quietly stops being true. And it ends with the cyber read: why LAB2 reads license text before it reads benchmark tables, and what grade a sovereign cyber model release should target.
One discipline note before we start. Licenses are per checkpoint, not per family, and not per lab. The single most common openness error in this field is assuming a family has “a license.” Nemotron alone uses at least six different NVIDIA license names across its roster, plus upstream licenses that stack underneath. Grade the checkpoint in front of you, from its own card, or do not grade it at all.
The ladder
Seven rungs. Each rung includes everything below it. The test for each rung is not what the lab says in a launch post; it is what a builder can actually download and use today.
Rung 1: Weights only. You can download trained checkpoints and run them. Nothing about how they were made is public beyond marketing. This is the floor of the word “open” and it is where most releases that call themselves open actually stop. Weights-only still has real value: you can serve, fine-tune (license permitting), quantize, and measure. What you cannot do is learn how the model got good, or verify any claim about how it was trained.
Rung 2: License clarity. On top of the weights, the legal terms are a known, stable quantity: a standard license (Apache 2.0, MIT) or a custom license whose full text you have actually read, with no termination triggers you cannot live with, no unilateral update rights, and no upstream license stacked underneath that changes the deal. Rung 2 is a legal rung, not an artifact rung, and it is the rung most often skipped. A release can have beautiful artifacts and still fail here, and a failure here can void everything above it, as the trap section shows.
Rung 3: Recipe. A tech report, paper, or detailed engineering write-up documents the architecture, the data mix at the level of components and proportions, the training stages, and the key hyperparameters, in enough detail that a competent team could imitate the run. Imitate, not reproduce: a recipe tells you the ingredients and the method, but you are cooking with your own groceries.
Rung 4: Data. The actual training datasets are downloadable, or there is an exact reconstruction path from public sources with the preparation code included. This is the rung that separates study from homage. With the data you can audit what went in, check contamination claims, measure the mix yourself, and train a different architecture on the same diet to isolate variables. Data has its own licenses, separate from the weights, and they count: a corpus under share-alike or terms-of-use conditions is not the same artifact as the same corpus under Apache 2.0.
Rung 5: Code and configs. The training code that actually ran, with the actual configuration files: hyperparameters, data order, parallelism layout, the lot. Configs are the difference between a recipe and a run. Two teams following the same paper with different configs get different models, and the deltas live in the configs.
Rung 6: Checkpoints and logs. Intermediate checkpoints across the run (not just the final weights) and the training logs to go with them. This rung is what turns a release into a time machine. With per-stage checkpoints you can watch capabilities appear, diff what each stage bought, catch the moment a behavior was trained in, and start your own work from any point in the lineage instead of only from the end. Public run logs (loss curves, gradient norms, the incidents) are how you learn what training actually costs in pain, not just in FLOPs.
Rung 7: Eval harness. The evaluation code, prompts, and scoring the lab itself used, public and runnable. Without this rung, every published score is a claim. With it, a score is a measurement you can repeat, dispute, and extend. The strongest releases also ship their decision discipline with the harness: which suite they tuned against and which suite they held out and never touched.
A family at rungs 1 to 3 is a product you can use. A family at rungs 4 to 5 is a system you can study. A family at rungs 6 to 7 is an experiment you can rerun. Keep those three sentences in mind through the grades.
The grades
The transparency ceiling: K2-Horizon and the Ai2 line
K2-Horizon (IFM): rungs 1 to 7, the full ladder. Weights under plain Apache 2.0 on every checkpoint card. A 134-page tech report (arXiv:2611.21003). The pretraining corpus (TxT360-v2, about 13 TB, CC BY 4.0) and the mid-training, SFT, and reasoning datasets are public. Training code (the xLLM framework), the RL stack (RL360), and the eval harness (Eval360) are public. About 380 checkpoints including per-stage branches you can address by name (the flagship’s branches read like a run diary: pretrain, four mid-training stages, RL-merged, three SFT phases), plus fine-grained training logs on Weights and Biases across 58 runs. Two honest caveats, both flagged in the roster and kept flagged here. First, at launch the two MoE models shipped weights first with data and code marked forthcoming; the flagship’s artifact index later listed them as available, but the 36B model’s artifact table was not read line by line in the roster pass, so MoE artifact completeness is corroborated at the flagship and unverified at the 36B. Second, the 32B launched as a Stage 1 mid-training checkpoint; its repo has been updated since, but nobody in this pass diffed the current main branch against the stage branches. Grade stands at full ladder with those two verification items open.
OLMo 2 (Ai2): rungs 1 to 7. Apache 2.0 weights. The exact pretraining data files are downloadable (Dolma-based mixes with manifests, the data itself under ODC-By). Two public training codebases with full YAML configs per stage and per seed. Every intermediate checkpoint, at minimum every 1,000 steps, in two formats, plus public Weights and Biases runs. The OLMES eval harness is public with the exact prompt formats from the report. OLMo 2 also publishes the negative-space details closed recipes hide: the stability fixes (QK-norm, reordered normalization, z-loss) were ablated in public, and the annealing stage was run multiple times from the same checkpoint with different data order and then weight-averaged, with configs per run.
OLMo 3 and 3.1 (Ai2): rungs 1 to 7, currently the most complete release pattern in the field. Ai2 formalized the release as a model flow: every lifecycle stage ships as an artifact, including branches most labs never show (the Think track, the Instruct track, and RL-Zero, RL applied straight to the base as a research artifact). Dolma 3 data mixes and the source pools behind the mid-training (Dolmino) and long-context (Longmino) stages are public, so the anneal is auditable, not just described. Post-training ships as the Dolci suite, split by stage and track, with a checkpoint at every stage boundary so you can measure what SFT bought, what DPO bought, and what RLVR bought, separately. OLMo 3 also ships something no other family ships: OlmoTrace, an index that traces spans of model output back to the training documents that support them. That is rung 4 (data) weaponized into a provenance tool.
Tulu 3 (Ai2): rungs 3 to 7 for the post-training half only, and that is by design. Tulu is a recipe line, not a base family: the full SFT mixture (939,344 prompts, sources named, decontamination method published down to the 8-gram overlap threshold and the worked example of a dataset that failed it), the preference mixtures, the RLVR mixes, the open-instruct code, per-stage checkpoints at 8B and 70B, and a two-suite eval discipline (a development suite for decisions, an unseen suite only for generalization checks). It is the most complete open post-training recipe ever published. Its license wrinkle gets its own trap entry below.
Full pipeline, with footnotes: SmolLM, Apertus, LLM360, Marin, and the data testbeds
SmolLM2 (Hugging Face): rungs 1 to 7. Apache 2.0. Every pretraining component is a public dataset, most of them built for the project (FineWeb-Edu, DCLM, FineMath, Stack-Edu). The four-stage curriculum for the 1.7B is published with the reasoning, including the deliberate decision to run the small models on a single-stage mix instead, and why. Training code (nanotron) and configs are public, the ablation models are released so the data claims can be re-measured, and the paper even publishes the compute cost of the 1.7B run (about $250K), a calibration number almost nobody else gives you.
SmolLM3 (Hugging Face): rungs 1 to 7, assembled from more places. Exact per-stage mixture percentages are public (85/12/3 web/code/math in stage 1, shifting by stage), the long-context extension recipe is published with its failure modes (upsampling long-context data lost to the NoPE plus RoPE-theta approach, and they say so), post-training configs live in the Alignment Handbook, and base, midtrained, SFT, and final checkpoints are all on the Hub. The soft spot is rung 3’s form: there is no formal paper, the blueprint is a long blog post plus cards and configs. Everything needed to reproduce is public; you assemble it yourself.
Apertus (Swiss AI Initiative): rungs 1 to 7, with the data rung delivered differently. Apache 2.0 weights, training code (a Megatron-LM fork plus preparation code), per-stage post-training repos, intermediate checkpoints as repo branches, eval suites, and a published alignment charter. The difference is rung 4: the corpus is released as preparation code plus reconstruction from public sources, filtered for non-permissive licenses, toxic content, and PII, with robots.txt opt-outs applied retroactively. You can rebuild the corpus; you do not download one frozen token dump. That is a defensible design (it is what makes the compliance story work), but grade it as what it is: data by reconstruction, not data by download. One more deviation, flagged for the trap section: the 1.5 post-trained finals sit behind a Hugging Face gate recording assent to an acceptable-use policy. The weights stay Apache 2.0; the gate is still a deviation from the ungated pattern.
LLM360 (Amber, CrystalCoder, K2-65B): rungs 1 to 7, at 2023-era model quality. This line started the transparency movement in December 2023, before it was fashionable. The exact pretraining data sequence is published down to per-source token counts and upsampling multipliers. Amber ships 360 intermediate checkpoints; the 65B K2 saved 360 and uploaded 120, and the team states plainly that storage was the binding constraint, which is the kind of operational honesty this ladder exists to reward. Full training code and Weights and Biases logs are public. The models are weak by 2026 standards. The release discipline is still a teaching resource nobody matched at 65B scale for a long time.
Marin (Stanford CRFM): rungs 1 to 7 for pretraining, thin post-training by design. Marin is an open lab, not just an open model: every experiment is a public GitHub issue, preregistered, failures kept in the record. The 8B retrospective names every phase of the run, including a discarded cooldown and a mid-run decision to rewarm and switch the mixture. That is the best public record of what a real training run looks like when it does not go in a straight line. Code (the Levanter trainer, JAX on TPUs, the roster’s one serious non-PyTorch data point), deterministic mixture pipelines, per-phase checkpoints, and the Delphi scaling-law suite are all public. The caveats are form (the trail lives across issues, docs, and run logs, not one tech report) and post-training (deliberately thin: the 8B Instruct is SFT-only, the 32B has none). Marin teaches pretraining and does not pretend to teach the rest.
DCLM and the FineWeb line: rung 7 artifacts at the dataset layer. These are testbeds and datasets with models attached, graded here because half the families above train on their outputs. DCLM fixes the recipe and the compute, varies only the dataset, and publishes the 240T-token pool, the winning filtered dataset, the classifier that built it, and the baseline models. FineWeb publishes the full filtering and dedup pipeline (the datatrove library) with every major decision ablated, plus the ablation checkpoints. If you want to understand why data decisions explain more performance variance than architecture at these scales, this layer is where the receipts live.
The industrial anchor, graded per line: Nemotron
Nemotron cannot take one grade. It is five years of releases with different openness postures, and averaging them would be exactly the error this part exists to kill. Graded by line:
Nemotron 3 generation (Nano 30B-A3B, Super, Ultra): rungs 1, 3, 4, 5, and partial 6, with rung 2 varying by checkpoint. This is the strongest NVIDIA line on artifacts. The family paper is public. The pretraining corpus is released as a dataset collection with a disclosed token total (about 10.6T tokens), and the flagship runs are multi-epoch over that released corpus, which means the data leg is genuinely auditable. Post-training datasets ship (13M+ SFT samples at Nano scale, the Super post-training collection, 10M SFT samples and 1M RL tasks at Ultra). Recipes are shared through the NVIDIA-NeMo/Nemotron GitHub repo. Ultra’s post-training teachers, more than ten domain-specialized 550B checkpoints built on the Ultra recipe, are themselves partially released, which is rare enough to name: a builder can distill from the same teachers NVIDIA used. What is missing against the ceiling families: no per-stage intermediate checkpoint series for the pretraining runs, no public run logs at K2-Horizon granularity, and no single public eval harness that reproduces the cards’ tables end to end. And rung 2 splits inside the generation: Nano and Super sit under the NVIDIA Nemotron Open Model License, while Ultra and the whole 3.5 line moved to OpenMDW-1.1. Same family, same year, two different legal instruments. (Verification note: the roster’s direct read of the Super card was still owed at roster time. A check run for this part found two independent card-reading sources, AnchorTerminal’s card audit and Aquanode’s family index, both naming the NVIDIA Nemotron Open Model License, version dated December 15, 2025, for the Super 120B-A12B cards. That corroborates the roster’s secondary summaries. The direct card read remains the gold standard and stays on the owed list, but the license name for Super should now be treated as corroborated, not guessed.)
Nemotron 3.5 line (Lightning, Super VL, Bolt pair, Transcribe): same artifact posture as Nemotron 3, uniformly OpenMDW-1.1. Lightning ships base, BF16, NVFP4, and speculative-decoding variants and is positioned as a post-training base for other builders, with a reported downstream post-train (CodeRabbit’s code-review router) already in the wild. Super VL’s card publishes its full pretraining corpus table by component, which is rung-4 behavior even where the components are dataset releases rather than one corpus file. The Bolt E4B entry carries the lineage trap detailed below: it is a post-train of Google’s Gemma 4, not an NVIDIA pretrain, and its name does not tell you that.
Llama-Nemotron reasoning family (2025): rungs 1, 3, and 4, explicitly not rung 5. Open weights, a solid paper, and the full post-training dataset public on Hugging Face. But NVIDIA’s own Megatron Bridge documentation states that training recipes for Llama Nemotron are not currently available. Credit NVIDIA for saying it in their own docs; grade it as what it is: open weights plus open post-training data, no recipes. This family is also the roster’s clearest stacked-license case (trap section).
Qwen-derived specialist lines (OpenMath, OpenCodeReasoning, AceReason, OpenReasoning, Cascade, Terminal): rung 4 is the story. These are post-training releases on other labs’ bases, and their contribution to openness is data: the datasets are public (AceReason-Math, OpenCodeReasoning, the OpenScienceReasoning split, Terminal-Corpus), and AceReason and Cascade publish their RL recipes in papers in real detail. Several checkpoints carry CC-BY-4.0, the cleanest terms in the whole Nemotron roster. The weak point is rung 2 bookkeeping: several of these lines’ exact card license strings were not pinned in the roster pass (Cascade-2 and Terminal among them), so they are graded here on their data and papers, with their per-checkpoint license verification still owed. Do not ship on a secondary license summary.
Nemotron-H: ungraded, pending one read. The paper discloses the architecture search and the FP8 recipe, and NeMo ships vendor-supported pretraining recipes for the 4B, 8B, and 47B, which would put the line at rungs 1, 3, and 5 with a real from-scratch path at small size. But rung 2 is in open conflict (next section), and a rung-2 conflict suspends the grade. Until the card text is read directly, treat Nemotron-H as not commercially cleared.
Nemotron-4 340B (2024): rungs 1 and 3, plus one rung-4 jewel. Weights under the NVIDIA Open Model License, a real tech report, 9T tokens, and an alignment dataset that was over 98 percent synthetic. The jewel: HelpSteer2, the preference dataset behind the era’s RLHF, released under CC-BY-4.0. The 340B itself is a study artifact now, but HelpSteer2 is still load-bearing open infrastructure.
Nemotron Labs diffusion lines (NLD and Sigma): research-grade openness, uneven. NLD publishes its training recipe and code on GitHub and a tech report, more than most research lines do. Sigma shipped with no announcement; its base card publishes no benchmark table and points at the paper, and one card flags its own figures as provisional. Treat both as research artifacts whose openness is real but whose claims are, by their own cards’ admission, not finished.
The boundary cases: Granite and EuroLLM
IBM Granite 4.x: rungs 1 and 3, partial rung 4, nothing above. The weights are plain Apache 2.0, the cleanest license posture in this entire part, and the model cards publish a real four-stage curriculum table. Then the card itself settles the question: the data is, in IBM’s own words, “a mix of open source and proprietary data.” GneissWeb (a 10T-token public web dataset with its filtering recipe and the Data Prep Kit that built it) is genuinely public, and named public components of the mix are real. The full mixture proportions, the complete data, and the pretraining code and configs are not released, and there are no intermediate checkpoints. Grade: weights plus documented recipe, partial data. Granite is in this study precisely so the boundary is visible, and for LAB2-style base selection its license cleanliness keeps it competitive even at this grade. One verification flag carried from the roster: Granite 4.1’s openness grade assumes the 4.0 data pattern carries over; a line-item primary data statement for 4.1 was not read directly in the roster pass.
EuroLLM: rungs 1 and 3, partial 4, weak 5, honest gap. Apache 2.0 weights, ungated, including per-phase checkpoints. Tech reports document tokenizer, architecture, mixture, and procedure in real detail, and the EuroFilter classifier is released. But only part of the roughly 4T-token mix is actually released (the web subset and the SFT data), the released datasets carry no explicit license tag on their cards, and the cited pretraining repo is a generic Megatron-LM fork without EuroLLM configs, so the run is not reproducible from released code. EuroLLM calls itself fully open. Parts of that claim hold. The distance between the label and the artifact list is itself the teaching example: grade artifacts, never labels.
The license traps
Five traps, all live in the rosters. Each one is a way a release that looks open stops being open at the exact moment you build on it.
Trap 1: Per-checkpoint variance inside one family. Nemotron ships under at least six NVIDIA license names: the AI Foundation Models Community License (2023 line), the Open Model License Agreement, the Nemotron Open Model License, OpenMDW-1.1, a Source Code License (one diffusion VLM variant), and an Internal Scientific Research and Development tag (next trap). The same checkpoint can even carry different names on different surfaces: Nemotron 3 Nano’s Hugging Face card says Nemotron Open Model License while its NGC card says Open Model License Agreement, and the HF card governs the HF download. K2-Horizon has the mirror-image version of this trap at the artifact level: weights Apache 2.0, main corpus CC BY 4.0, other datasets under Apache or ODC-By class terms. None of this is sinister. All of it means the unit of license diligence is the individual artifact, every time.
Trap 2: Termination and unilateral-update clauses. Custom vendor licenses can carry triggers that standard licenses never have: rights that end if you use the model in ways the vendor later defines as guardrail violations, or terms the vendor may update unilaterally, with your continued use counting as acceptance. This is not hypothetical in this roster’s neighborhood. LAB2’s Phase 0 decision note (Oct 28, 2026) recorded exactly this pattern in the Nemotron Nano line: the Nano-9B-v2 card terms were read during base selection and found to carry a guardrail-termination clause and a unilateral-update clause, which is why Nemotron was deferred as the V0.1 base despite strong benchmarks. Bookkeeping honesty: the roster pass did not re-pin that checkpoint’s exact license string, so the clause finding stands on the Phase 0 read, and the string re-verification stays on the owed list. The engineering point does not depend on the re-read: a license that can be revoked or rewritten by the vendor is a supply-chain dependency, and you evaluate it like one.
Trap 3: The Nemotron-H tag conflict. Hugging Face metadata for Nemotron-H-8B-Base-8K carries the tag for the NVIDIA Internal Scientific Research and Development Model License. Downstream redistributors cite the same checkpoint as under the NVIDIA Open Model License. One secondary family index read for this part describes the Nemotron-H cards as carrying “a research-focused NVIDIA license,” which leans toward the restrictive reading but does not settle it. Both cannot be the governing story for a commercial build, and the difference is not academic: an internal-R&D license and an open model license are opposite answers to the only question that matters, which is whether you may ship. The roster flags this as the single most consequential open item in the Nemotron file, and it stays flagged here. Nobody in this study has read the 8B-Base-8K card text directly. Until someone does, Nemotron-H is a paper and a recipe collection, not a base model.
Trap 4: Inherited upstream licenses. A post-trained checkpoint carries two legal layers: the post-trainer’s terms and the base model’s terms, and you are bound by both. The roster’s cleanest documented case is Llama-3.3-Nemotron-Super-49B-v1.5, whose card states it verbatim: use is governed by the NVIDIA Open Model License, with the Llama 3.3 Community License Agreement as additional information stacked underneath. Tulu 3 is the same shape in the other direction: Ai2’s recipe, data, and code are openly licensed, but the Tulu weights sit on Llama 3.1 bases, so the checkpoints inherit the Llama Community License, not Apache 2.0. (When Ai2 later ran the same recipe style on its own OLMo bases, the chain became clean Apache end to end, which is what a solved version of this trap looks like.) Nemotron 3.5 Bolt E4B stacks OpenMDW-1.1 on Gemma 4’s Apache 2.0 terms. The Minitron derivatives stack NVIDIA terms on Llama 3.1 and Mistral terms. Nemotron-Labs-Diffusion is initialized from Ministral 3 checkpoints, so its chain runs through Mistral’s terms as well as NVIDIA’s two different licenses for its text and vision variants. The rule: the openness of a derivative is the minimum of its chain, and the chain is only visible if you read the card’s governing-terms block, not the headline.
Trap 5: OpenMDW-1.1, the new house license. The Nemotron 3 Ultra and the entire 3.5 line ship under the Open Model Definition and Weights license, version 1.1, a Linux Foundation license built for model weights rather than adapted from software. What the roster verified: it governs the Ultra cards (Hugging Face and build.nvidia.com agree), it covers the Ultra base’s published SFT and RL data as well as weights, and card summaries describe the models as ready for commercial or non-commercial use. What this part will not do is paraphrase its clauses from summaries. OpenMDW-1.1 is increasingly the default for NVIDIA’s flagship open releases, and any team building on Ultra or Lightning owes itself a full read of the actual agreement before the build, not after. The contrast set is plain Apache 2.0 (K2-Horizon, OLMo, SmolLM, Apertus, LLM360, EuroLLM, Granite weights): short, famous, OSI-approved text with no vendor in it. Neither posture is automatically right. They are different risk shapes: Apache gives you a known quantity and no steward; a purpose-built weights license gives you terms written for the artifact you are shipping, at the cost of having to actually read it.
Two smaller traps worth a line each. Gates are not licenses, but they are friction with legal shape: Apertus 1.5’s finals require recorded assent to an acceptable-use policy before download; the weights are Apache 2.0 once you have them, but the release is not ungated, and automated pipelines notice the difference. Research lines carry research terms: Sigma is offline-use only with no hosted endpoint, and its cards mark their own numbers provisional; NLD’s vision variant sits under a Source Code License while its text siblings sit under the Nemotron Open Model License, same release, two instruments.
What each rung actually lets you do
Grades are abstract. Capabilities are not. Here is the ladder translated into the five things a builder actually tries to do.
Rerun the training run. Needs rungs 4, 5, and 6 together: data, code with configs, and checkpoints to validate against. Only the ceiling group supports this at all (K2-Horizon, OLMo 2 and 3, SmolLM2 and 3, Apertus by reconstruction, LLM360, Marin for pretraining), and even there, rerun means modulo compute: SmolLM2’s 1.7B cost about $250K to train; nobody reruns a 375B flagship as homework. Nemotron 3 gets you partway: released corpus and recipes, but no per-stage checkpoints to validate against, so you can imitate the run but not verify the imitation stage by stage. Granite supports no rerun claim at all.
Diff two models and attribute the difference. Needs rung 6 (checkpoints across stages) and rung 3 (a recipe honest about what changed). This is the masterclass’s core move, and it is why the anchors are who they are: K2-Horizon’s stage branches let you diff the same model before and after each mid-training stage; OLMo 3’s per-track stage checkpoints let you price SFT, DPO, and RLVR separately; Nemotron’s Nano-to-Cascade-2 pair gives a controlled recipe comparison on an identical base lineage. Weights-only releases make attribution impossible by construction: when one improves, its report tells you a story about why, and there is no artifact to check the story against. That impossibility is exactly why such releases sit outside this study’s scope.
Audit the data. Needs rung 4, full stop. With the corpus you can test contamination claims, find out whether your eval leaked into training, inspect what a domain mix really contains, and check a lab’s data-quality story against the artifact. OLMo’s OlmoTrace pushes this furthest, from corpus access to per-output provenance. Nemotron-CC and the Nemotron 3 corpus collection make NVIDIA’s data auditable at the corpus level even where the run itself is not fully rerunnable. Granite’s data is partly an artifact and partly a sentence about proprietary data. You cannot audit a sentence.
Reproduce a published claim. Needs rung 7 (their harness, their prompts, their scoring) plus rung 1 (the exact checkpoint). This is the cheapest capability on the list and the one most often missing. The ceiling families ship their harnesses (OLMES, Eval360, the DCLM suite). Vendor cards elsewhere publish numbers produced by internal harnesses you cannot run, which is how the field ends up with two different scores for the same checkpoint on different surfaces; the roster caught exactly that on Nemotron 3 Ultra, whose Hugging Face card and build.nvidia.com card give SWE-Bench Verified figures about a point apart for the same BF16 weights. Neither is necessarily wrong. They are different measurements wearing the same name, and without the harness you cannot tell how.
Ship commercially. Needs rung 2, and only rung 2. Not the most artifacts, not the best report: the cleanest legal chain. A checkpoint under plain Apache 2.0 on its own base (OLMo, K2-Horizon, SmolLM, Granite) is shippable on a one-page legal read. A checkpoint with a stacked chain (Llama-Nemotron, Tulu weights, Bolt E4B) is shippable after reading every layer. A checkpoint under a custom license with termination or update clauses is shippable only with the risk priced in. A checkpoint whose card metadata and redistributors disagree about which license governs (Nemotron-H) is not shippable at all until the conflict resolves. Notice what is absent from this paragraph: benchmarks. Commercial shippability is a legal property. It does not care how the model scores.
The cyber read
LAB2’s standing discipline, set during the V0.1 base selection in October 2026, is to read the license text before the benchmark table. This part is the long version of why, and the Nemotron file alone justifies it three times over. The Nano line’s termination and update clauses were found by reading, not by benchmarking, and they changed a base-model decision. The Nemotron-H conflict means the family’s most recipe-complete small line cannot be cleared for commercial use at all until one card gets read. The Llama-Nemotron family looks like an NVIDIA release and is legally a two-party release. In each case the benchmark table was the least informative document in the folder.
For a cyber model specifically, rung 2 carries extra weight, for a structural reason. A cyber model’s job description includes work that sits near every vendor’s guardrail definitions: vulnerability research, exploit development, offensive tooling on replicas. A license with a guardrail-termination trigger is not an abstract risk for this use case; it is a clause aimed at the neighborhood of the work itself. The same logic applies upstream: LAB2’s teacher discipline (only training-use-permitted sources feed training sets) is rung-2 thinking applied to data generation, because a model trained on outputs its generator’s terms forbade for training is a contaminated artifact no matter how clean its weights license is. Openness grading and training-data provenance are the same habit at different stages.
So what grade should a sovereign cyber model release target? The full ladder, with three emphases drawn from the grades above.
First, a clean Apache 2.0 chain end to end: own base or an Apache base, own post-training, datasets under Apache, CC BY, or ODC-By class terms with each artifact’s license stated on its own card. The Tulu-to-OLMo progression is the template: the moment Ai2 ran its recipe on its own base, the chain problem disappeared. A sovereign release cannot have a vendor in its license chain who can terminate, update, or rebrand the deal.
Second, checkpoints and logs at K2-Horizon granularity: per-stage branches, named so an outsider can reconstruct the lineage without asking. For a cyber model this is not transparency theater. It is how a user verifies that the refusal behavior the release claims was actually trained the way the card says, by diffing the checkpoint before and after the stage that set it. Part 8 takes up refusal as a training decision; the diffing capability that makes refusal claims checkable is built here, at rung 6.
Third, an eval harness that grades by execution: the release’s scores should come from a harness the reader can run, scoring whether the exploit worked on the replica, whether the patch held under re-attack, whether the detection fired, not from a multiple-choice proxy. That is Proof of Defense discipline, and rung 7 is where it lives. The ceiling families prove the artifact pattern is shippable today (OLMES and Eval360 are both public, both runnable). A cyber release that publishes weights and a PDF of scores has graded itself at rung 3, whatever its press release says.
The closing summary is one line: openness is not a vibe or a launch adjective, it is an artifact list plus a license chain, and both are checkable before you spend a dollar of compute. The families at the top of this ladder are the ones this study can actually learn from, because they are the ones whose claims come with receipts.
Items left flagged, on purpose
Kept open from the rosters, unresolved here: the Nemotron-H card text (the direct read that settles Trap 3); the exact license strings for Nemotron-Cascade-2, Nemotron-Terminal, and Nemotron 3 Nano Omni; the DCLM baseline repos’ license tags; K2-Horizon’s MoE artifact tables beyond the flagship and its 32B main-branch diff; Granite 4.1’s line-item data statement. Newly corroborated in this pass, with the direct read still owed: Nemotron 3 Super’s license name (NVIDIA Nemotron Open Model License, version dated December 15, 2025, per two independent card-reading sources). Each later part closes its own items at primary sources or keeps them flagged the same way.
Sources for this part
Roster files built for this masterclass on Nov 17, 2026: research/nemotron-roster.md, research/k2-horizon-roster.md, research/open-families-roster.md. LAB2 Phase 0 decision note, Oct 28, 2026 (Nano-line clause finding). Verification check run Nov 17, 2026 for the Nemotron 3 Super license name: AnchorTerminal’s Nemotron 3 Super card audit and Aquanode’s NVIDIA Nemotron family index, both secondary card readings, cited as corroboration rather than as a direct card read. Primary artifacts behind the rosters: IFM K2-Horizon tech report (arXiv:2611.21003) and model cards; NVIDIA Hugging Face and NGC cards and Nemotron tech reports; Ai2 OLMo 2 (arXiv 2412.15115 line), OLMo 3 (arXiv 2512.13961), and Tulu 3 (arXiv 2411.15124) reports; Hugging Face SmolLM2 (arXiv 2502.02737) and SmolLM3 publications; Apertus tech reports (arXiv 2509.14233, 2610.15542); LLM360 (arXiv 2312.06550) and K2 (arXiv 2501.07124) reports; Marin retrospectives; DCLM (arXiv 2406.11794) and FineWeb (arXiv 2406.17557) papers; EuroLLM tech reports; IBM Granite 4.x model cards.