TL;DR · Key Takeaways
- A model is not a database of answers. It is one very large function that does a single trick: predict the next token, over and over.
- The parameters are the millions or billions of numbers inside that function. They are the model. The file you download is mostly just those numbers.
- Sizes like 7B, 70B, and frontier models are counts of those parameters. Bigger usually means more capable, but it is a rough guide, not a promise.
- Open weights mean you can download the numbers and run them yourself. Closed weights stay behind a company’s door and you reach them through an API.
People say “the model” constantly, as if it were obvious what one is. It is worth slowing down, because almost every later idea in this series, cost, speed, memory, fine-tuning, hangs on what a model actually is under the hood. The short version may surprise you: a modern AI model is not a brain, not a search engine, and not a vault of stored facts. It is a single mathematical function, frozen after training, that does one humble thing astonishingly well. Once you see that one thing clearly, a lot of the mystery drains away.
A model is a function that guesses what comes next
At its core, a language model does one thing: given some text so far, it predicts what token should come next. That is the entire job. Feed it “The cat sat on the” and it produces a ranked list of likely continuations, with “mat” near the top and “photosynthesis” near the bottom. It picks one, sticks it onto the end, and runs again on the slightly longer text. Repeat a few hundred times and you have a paragraph. Everything a chatbot does, answering a question, writing code, drafting an email, is this same next-token guess, looped.
This is why it helps to think of a model as a function rather than a mind. A function takes an input and returns an output by a fixed rule. Type the same prompt into the same model with the same settings and the same machinery runs every time. The reason replies vary is not that the model is thinking differently. It is that we usually let it pick from among its top guesses with a dash of randomness, a knob we will cover in the part on temperature. The function itself is fixed the moment training ends. It does not learn from your chat, it does not remember yesterday, and it holds no live connection to the world. It is a very large, very still set of numbers waiting to be run.
Why parameter count is a headline, not the whole story
Parameter count is the number everyone quotes because it is one clean figure, but it is a weak predictor of quality on its own. A smaller model trained on more and cleaner data routinely beats a larger model trained on less, which is the whole point of a later part in this series. Architecture matters too: a mixture-of-experts model can list a huge total parameter count while only using a fraction of it per token. So when you read “X billion parameters,” treat it as the size of the engine, not the speed of the car. It sets a rough ceiling on capacity; data, tuning, and design decide how much of that capacity becomes real-world quality.
The numbers inside: parameters are the model
So what is the function made of? Numbers, mostly. A model is a long chain of multiplications and additions, and every one of those operations uses a stored number called a parameter (also called a weight). In Part 2 we pictured these as the dials on a giant mixing desk. Training is the process of slowly turning all the dials to the settings that make the next-token guesses good. When training finishes, the dials lock. Those locked numbers are the model. When you download a model, the file you get is essentially a huge list of these parameters, nothing more.
This is also why a model knows things without storing them like a library does. There is no row in a table that says “Paris is the capital of France.” Instead, that fact is smeared across millions of parameter values that together make “Paris” the likely answer when the surrounding words point that way. The knowledge lives in the pattern of the numbers, not in any single slot. It is closer to muscle memory than to a filing cabinet, which is exactly why a model can be fluent and confidently wrong in the same breath: it is reproducing a pattern, not looking up a record.
What “7B” and “70B” actually mean
When you see a model described as “7B” or “70B,” that letter B means billion, and the number counts its parameters. A 7B model has roughly seven billion of those stored numbers; a 70B model has about ten times as many. The largest frontier models from the big labs are not always public about their exact size, but they run into the hundreds of billions, and some use designs that push effectively into the trillions. More parameters give a model more room to capture subtle patterns, so as a rough rule, bigger models tend to be more capable.
But size carries a cost that matters in practice. Every parameter has to be held in memory and pushed through math on every token, so a bigger model needs more expensive hardware and runs slower and pricier per answer. That is the trade at the heart of the whole infrastructure half of this series. A small 7B model can run on a single decent GPU, or even a laptop, while a frontier model needs a cluster. Choosing a model size is really choosing a point on the line between capability and cost, and the right point depends entirely on the job.
Open weights vs closed weights
One more split shapes nearly every practical decision: can you have the numbers, or not? With an open-weights model, the company releases the actual parameter file for anyone to download, run on their own hardware, inspect, and adapt. Meta’s Llama family and models from Mistral are well-known examples. With a closed-weights model, the parameters stay private inside the company. You never touch the file; you send your text to their servers over an API and get a reply back. OpenAI’s GPT-4o, Anthropic’s Claude, and Google’s Gemini work this way.
Neither is simply better; they trade different things. Open weights give you control, privacy, and the option to run entirely on your own infrastructure, which is a large part of why the later infrastructure parts of this series lean on them, but you own the work of hosting and the hardware bill. Closed models are easy to start with and often sit at the cutting edge of quality, but you rely on a vendor, send your data to them, and pay per use. This is the first glimpse of the build-versus-buy question we will return to in full once the infrastructure phase begins.
▾ Go Deeper (optional, for technical readers)
Parameter count is a convenient headline, but it is a weak predictor of quality on its own. Three other factors often matter more. First, training data: the 2022 Chinchilla work showed many large models were badly undertrained, and that a smaller model fed more, cleaner tokens can beat a larger model trained on less. Quality and quantity of data frequently outweigh raw parameter count.
Second, architecture and tuning. A mixture-of-experts model may list a huge total parameter count yet only activate a fraction of it per token, so its effective compute and its memory footprint tell different stories, something we unpack in the part on MoE. Post-training steps like instruction tuning and preference alignment can lift a model’s usefulness far more than adding parameters would. Third, precision: the same parameters stored at lower numerical precision through quantization shrink the memory bill with little quality loss, which is why “how many parameters” and “how much GPU memory” are related but not the same question. The honest summary: parameter count sets a rough ceiling on capacity, but data, architecture, tuning, and precision decide how much of that capacity becomes real-world quality.
This is Part 4 of a 30-part walk from zero to the infrastructure behind production AI. The full map of what comes next lives on the Generative AI Complete Guide. New here? Start at Part 1, what generative AI actually is, or brush up on the vocabulary in Part 2.
Model sizes, and where each one runs
| Size | Rough capability | Runs on |
|---|---|---|
| ~7B | Capable for many focused tasks | A laptop or single GPU |
| ~70B | Strong general performance | A server-grade GPU |
| Frontier (100B+) | Best available quality | A GPU cluster |
Worked example
Feed a model “The capital of France is” and watch what the function does. It does not retrieve a fact from a table. It runs every input token through its billions of parameters and produces a probability for each possible next token: “Paris” very high, “a” or “the” lower, “banana” near zero. It samples one, almost always “Paris,” and stops. The “knowledge” that Paris is the capital is not stored anywhere you could point to; it is smeared across the parameter values that make “Paris” the likely continuation. That is why a model can be fluent and wrong in the same breath: it is reproducing a pattern, not reading a record.
Why two models of the same size are not the same model
It is tempting to treat the parameter count as the whole identity of a model, but two models that both advertise the same size can behave nothing alike. The count tells you roughly how much capacity a model has, not what it learned or how well. The architecture, the quality and mix of the training data, and how carefully the training was done all shape the result at least as much as raw size. This is why a smaller, well-trained model often beats a larger, carelessly trained one on the tasks you actually care about. When you compare models, the parameter count is a starting clue, not a verdict, and the only reliable judge is how each one performs on your own work.
A model, made concrete
Strip away the hype and a model is refreshingly concrete. It is one large mathematical function whose only move is to predict the next token, built entirely from billions of fixed numbers called parameters that were tuned during training and then frozen. Sizes like 7B and 70B count those numbers and trace a rough line from small and cheap to large and capable. And whether the numbers are open for you to download or closed behind a vendor’s API will shape how you build with them. Hold on to the picture of a still, silent function made of numbers, because the next part puts it to the test and maps out what this thing can genuinely do and where it falls flat.
References
- Llama: an open-weights model family (Meta AI)
- Training Compute-Optimal Large Language Models (the Chinchilla paper, 2022)
- What are foundation models? (IBM Research)
« Part 3: from if-statements to ChatGPT | Generative AI Complete Guide | Next: Part 5, what GenAI can and cannot do »
About The Author
DrJha