What a model actually is

What is inside the file

If you could look inside a model file, you would not find words. You would find numbers. Billions of them, kept in blocks.

GGUF is one common way to store a model. A GGUF file holds a count of the blocks, the numbers in each block, and some notes about the model. The blocks have plain names, like token_embd.weight.

Each block is called a tensor. Another common format is called safetensors, and Hugging Face describes it as a way of storing tensors safely and fast. Different wrapper, same contents.

The numbers in those blocks are the model. Everything else in the file is a label on a box.

Backed by GGUF file format specification, Safetensors documentation, Qwen3-8B model card.

What that looks like on a real page

You can see this for yourself without downloading anything. Most models are published on Hugging Face, and each one has a Files tab listing what is in it.

Take Qwen3-0.6B, a small model. Its listing has ten entries. One of them, model.safetensors, is 1.5 GB. Another, config.json, is 726 bytes.

That gap is the point. 726 bytes is a short page of plain text, and you can read it in a browser. The version for Qwen3-8B says the model is 36 layers deep. Another line gives its vocab_size as 151,936. That is the number of different tokens, meaning chunks of text, that it can read or write.

Larger models arrive in pieces. Qwen3-8B lists five of them, named model-00001-of-00005.safetensors through to the fifth, adding up to about 16 GB. Beside them sits an index file, saying which block lives in which piece.

So a model is a great many learned numbers, plus a short note saying how they are arranged. Nothing else is in there.

Backed by Qwen3-0.6B repository files, Qwen3-8B repository files, Qwen3-8B config.json.

Where the numbers came from

Nobody typed those numbers in. They were learned, in a long process called training.

Training shows the model a great deal of text. Each time, it guesses what comes next. When the guess is off, the numbers are nudged a little. That happens an enormous number of times.

The scale is worth seeing. Microsoft says its phi-4 model was trained on 9.8 trillion tokens. The run used 1,920 H100-80G graphics cards and took 21 days.

This is why you download a model rather than make one. The training is the costly part. The file is what it leaves behind.

Backed by Phi-4 model card, The Open Source AI Definition 1.0.

The file stops changing

When training ends, the numbers are fixed. The file you download does not change while you use it.

Microsoft calls phi-4 a static model, with a cutoff of June 2024 and earlier for public data. It does not know what happened after that. Later news is not in there, and cannot be.

It also does not remember you. LM Studio says it plainly in its own docs: the model does not learn from chats. It knows what is in the chat in front of it, and nothing else.

A chat window can still feel like memory. That is the app doing the work. It keeps your earlier messages and sends them in again with the new one.

One mistake follows from this, and nearly everyone makes it once. You correct the model, it takes the correction, and it gets the next answer right. So you assume it has learned. Open a new chat tomorrow and the correction is gone. It was never in the file. It was in the messages being re-sent.

Backed by Phi-4 model card, Manage chats.

What can change, and what it costs

Fixed does not mean nothing can move. Two things change what a model can tell you. Neither edits the file you downloaded.

The first is what you put in front of it. Drag a document into the chat and it can answer from that document. LM Studio says files you drop in are processed on your machine and do not leave the app. The model has not learned the document. It is reading it, this once, for this answer. Lesson thirteen covers the limits of that.

The second is training the numbers again, which produces a new file. There is a lighter version of it too. Ollama's Modelfile has an ADAPTER instruction for LoRA adapters, small extra files laid over a base model. The base file stays as it was, with the adapter sitting on top.

So when somebody says a model "learned" something, it is worth asking which one they mean. Text handed to it costs seconds. A new file costs a training run.

Backed by LM Studio offline operation, Ollama Modelfile reference.

One piece at a time

Your question does not go in as words. It is cut into tokens first.

A token is a common chunk of text. Hugging Face gives the example of annoyingly, which may be split into annoying and ly. Common words stay whole. Rare ones come apart.

Then the model does one job. Hugging Face puts it in one line: it predicts the next token in a sequence.

It picks a token, adds it to the end, and runs again. And again. The answer you read was built one small piece at a time.

Backed by Tokenization algorithms, Causal language modeling.

Why the same question gives two answers

The model does not hand back one token. It hands back a score for every token it knows. For Qwen3-8B, that is 151,936 numbers, every single step.

The program around the model then chooses one. Hugging Face names the two usual ways of choosing. Greedy search selects the most likely token at each step. Sampling picks at random, weighted by how likely each token was.

Which one you get is a setting, not a property of the file. Ollama's default temperature is 0.8, and its docs say raising it makes the model answer more creatively. Turn it down and answers get more predictable.

That is why the same question can give you two different answers from the same file. Nothing changed. The dice did.

You can put the dice away. Ollama has a seed setting, and its docs say that fixing it makes the model generate the same text for the same prompt. Worth knowing before you go hunting for a bug that is not there.

Backed by Qwen3-8B config.json, Generation strategies, Ollama Modelfile reference, Qwen3-8B model card.

Not a box of answers

No answer is stored in the file, waiting for the right question. The file is the same size whatever you ask it.

Think of a musician who has played thousands of songs. They can play in the style without reading any sheet music. The comparison breaks in one spot, and it is the important spot: a good musician knows when they are lost, and a model does not.

Microsoft says the same thing on its own model card. Language models can produce content that sounds reasonable but is wrong or out of date.

This is not a fault that a patch will remove from your copy. It follows from what the file is. Guessing well is still guessing.

Backed by Phi-4 model card.