Models, open weights and Hugging Face

Before anyone writes a promptPrompt Everything sent to the model in one call: instructions, conversation messages and any tool definitions., trains an adapterAdapter A small set of extra weights trained and attached to a model that otherwise stays unchanged, so its behavior changes without retraining the whole model. or starts a server, someone picked a model. That choice sets what the system can do, what it costs, where the data travels and what the license allows. It is often made on popularity alone.

This lesson covers how to choose deliberately: closed versus open models and their licenses, how to read what a model is, why downloading one means trusting someone, and how to make the final call. The running example is Adapta, which downloads its base modelsBase model A model after its first, general training, which only continues text and has not yet been tuned to follow instructions. from Hugging Face.

Closed models, open models and licenses

There are two ways to use a model. A closed modelClosed model A model reachable only through a provider's API; its weights are never distributed. works like a service: you send text to the provider's API and get an answer, but the model never leaves their servers. An open-weight modelOpen-weight model A model whose trained weights are published for download, under a license that may still restrict use. works like software you install: you download its weights, the billions of numbers learned in trainingTraining Adjusting model weights from data so its predictions improve., and run them wherever you want.

Being able to download a model does not make it open source. The OSI's Open Source AI Definition also asks for the full code and enough information about the training data to rebuild something equivalent. Most popular models publish only the weights.

What you may do with them is set by the license, and licenses vary a lot:

• Permissive (Apache-2.0, MIT): almost any use. DeepSeek-R1 shipped under MIT, some Mistral models under Apache-2.0.
• Custom community licenses add conditions. The Llama 3.1 license, for example, requires Meta's permission above 700 million monthly active users.
• Terms with prohibited uses, such as the Gemma Terms of Use.
• Research or non-commercial licenses rule out use in a product without a separate agreement.

Reading what a model is

A model's name tells you most of what you need. Take Qwen2.5-3B-Instruct-GGUF:

• Size (3B): three billion parameters. It drives memory, quality and speed. Small models fit on a consumer graphics card and are worth trying first.
• Base or instruct: a base model only continues text, like autocomplete; an instruct model was further trained to follow instructions. Applications almost always use the latter.
• Modality: models marked VL (vision-language) accept images as well as text.
• Format (GGUF): how the weights are stored on disk.

Two formats cover most cases. safetensorsSafetensors A file format for model weights that holds only the numbers and a description of them, so opening it cannot run hidden code. holds only the numbers and is the standard across Hugging Face. GGUFGGUF A single-file model format used by llama.cpp and similar tools to run models locally, holding the weights and their metadata, usually quantized. packs them into one file for llama.cpp and similar engines, usually compressed to run on modest hardware (see Serving models). Adapta trains with the first and serves the second, converting its adapters in between (Fine-tuning, LoRA and QLoRA).

Each model also has a model cardModel card The document in a model repository describing intended use, limitations, data, evaluation, license and base model., the page describing intended uses, limitations, data and evaluation, with the license in its metadata. Read it before downloading.

Hugging Face and its alternatives

Hugging Face does for models what npm or PyPI do for code: a public registry where anyone publishes and downloads. Its Hub hosts versioned repositories of models and datasets, and its libraries, led by transformers, load, run and train them. It also offers hosted demos and inferenceInference Running a trained model to produce an output for a new input. services; its own inference server, TGI, is in maintenance mode.

Adapta ships no weights: its README tells you to download the base model from the Hub, and the server stops with instructions if the file is missing.

Downloading a model means trusting someone

A model file looks like data, but it can run code. Older PyTorch files use a Python format called pickle, and opening one can execute arbitrary code. safetensors exists to prevent exactly that.

A second door is trust_remote_code, an option that lets a repository run its own code on your machine. When it is truly needed, the documentation recommends pinning the download to one exact version, so nobody can change the code under you.

Choosing a model

Start from what your system needs, not from a ranking:

Read the table as the first filter in a sequence. Each step shortens the list, and the last one decides:

Public benchmarks help build a shortlist, not make the decision. Test questions may have leaked into training data, so the score measures memory rather than ability; this is called contamination (Xu et al., 2024). And your task does not look like the benchmark's. Hugging Face itself closed its Open LLM Leaderboard in March 2025, saying it pushed people to optimize for things that no longer mattered. The decision belongs to a test set built from your own cases (Evaluating models).

Putting it into practice

• Check the license before the benchmark. An excellent model under a non-commercial license cannot go into a product.
• Treat closed versus open as a data and operations decision, not only a quality one. Open weightsOpen weights A model whose trained parameters can be downloaded and run anywhere, regardless of whether its code or data are published. give you version control and privacy, and hand you the infrastructure.
• Manage weights like any dependency: pinned versions, safe formats and a record of which model runs where.

Sources

• OSI: Open Source AI Definition
• Llama 3.1 license and Gemma Terms of Use
• DeepSeek-R1 model card and Qwen Research License
• Hugging Face: model cards, GGUF, pickle security, custom models, Inference Providers, TGI
• End of the Open LLM Leaderboard
• Xu et al., Benchmark Data Contamination of Large Language Models: A Survey

Go deeper

Adapta's own documentation covers how it picks, stores and runs its base models:

• Operations Runbook has a base-model catalog section listing each model with its Hugging Face source, license and the graphics memory it needs to train.
• Learning the system explains weights, GGUF and quantizationQuantization Storing a model's weights as less precise numbers, using fewer bits, to cut memory and cost at some loss of accuracy. from first principles, treating a model file like a compiled program.
• Stack and decisions explains why Adapta serves GGUF files with llama.cpp rather than vLLM, Hugging Face's own libraries or Ollama.

Key takeaways

• Open weights are not open source; the license decides what you may do, and it can differ between sizes of one family.
• The name, the model card and the file format tell you what a model is and how it runs.
• A downloaded model is a dependency: pin it, prefer safetensors, avoid running repository code you don't need.
• Benchmarks build the shortlist; your own tests decide.

Check yourself