What it is
Parameters are the numbers inside an AI model that it learned during training. They are what the model "knows". When a chatbot writes a sentence, recognises a photo, or suggests the next word in your email, it does it by running your input through a huge calculation, and the parameters are the settings on every step of that calculation.
A helpful picture is a sound mixing desk with an enormous number of knobs. Before training, every knob is set at random, and the music that comes out is noise. Training plays the desk millions of examples and, after each one, turns every knob a tiny amount in whichever direction would have made the output a little less wrong. Nobody sets any knob by hand. After enough examples, the knob positions together hold a compressed version of the patterns in everything the model saw. Those final knob positions are the parameters.
In a neural network, most parameters are "weights": numbers that say how strongly one part of the network should influence the next. A smaller number of them are "biases", which shift a result up or down. People use "parameters" and "weights" almost interchangeably, and you'll hear both. When someone says a company "released the weights", they mean it published the file of learned numbers so that anyone can run the model on their own computer.
A few things about parameters surprise most people.
No single parameter means anything on its own. There isn't one number for "Paris is the capital of France" and another for "be polite". Knowledge is smeared across millions of numbers at once, and each number plays a small part in many different things. That's why it's so hard to look inside a model and explain why it said what it said, and why a whole research field, interpretability, exists to try.
The model doesn't keep its training material. A model trained on a huge amount of text doesn't store that text like a library. It stores the patterns in its parameters. That's why a model can write fluently about a subject yet misremember a detail, and why it can't reliably tell you where it learned something.
Parameters are fixed once training ends. When you chat with an AI, its parameters don't change. It isn't learning from your conversation in the way it learned during training. Anything it seems to "remember" within a chat comes from the text sitting in its context window, not from new parameters. Changing the parameters again takes a separate step, such as fine-tuning.
What "7B" means
Model names often carry a number followed by a B, such as 7B, 70B, or 405B. The B stands for billion, and the number is how many parameters the model has, rounded. A 7B model has about seven billion learned numbers. It's the usual shorthand for a model's size, the way engine size is shorthand for a car.
That number translates directly into memory, which is where it starts to matter to you. Each parameter has to be stored somewhere while the model runs. Most modern models are trained with each number taking 16 bits, or 2 bytes, of memory. Hugging Face, a large public library of AI models, gives the rule of thumb in its own documentation: loading a model with X billion parameters takes roughly 2 × X gigabytes of memory at that precision. So:
- A 7B model needs about 14 GB just to hold its parameters.
- A 70B model needs about 140 GB.
- GPT-3, at 175 billion parameters, needed about 350 GB, far more than any single graphics chip of its day could hold.
On top of that, the model needs some extra working memory for your conversation, which grows as the conversation gets longer. Memory is the main reason big models live in data centres, and it's the number to check first if you want to run a model yourself.
Shrinking the numbers: quantization
Here's the trick that made running models at home realistic. Instead of storing each parameter as a precise 16-bit number, you round it to a coarser one, using 8 bits or even 4 bits per parameter. This is called quantization. It's a bit like saving a photo as a smaller JPEG: you lose some fine detail, but the picture is still clearly the same picture, and the file is a fraction of the size.
At 4 bits, each parameter takes half a byte, so a 7B model drops from about 14 GB to about 4 GB. The Hugging Face guide notes that models can often be quantized to 8 or 4 bits without a large loss in quality, while warning that 4-bit versions can give noticeably different answers, and that there's always some trade-off. When you see a downloadable model labelled "Q4" or "4-bit", this is what it means: the same learned knowledge, stored more roughly, in exchange for fitting on a laptop.
Why it matters
It's the most common measure of a model's size. When companies announce models, compare them, or price them, parameter count is usually the first number in the conversation. Knowing what it means lets you read that news without getting lost.
More parameters can mean more capability. A model with more parameters has more room to store patterns, so, other things being equal, bigger models have tended to know more and handle harder tasks. That's why the headline models of recent years have grown from millions of parameters to hundreds of billions.
But more parameters always mean more cost. Every parameter has to be stored, and every one takes part in the calculation for every token the model reads or writes. Double the parameters and you roughly double the memory and the computing work per word. That cost shows up as slower replies, bigger bills for companies running the models, and the price you pay for premium AI plans. It's also why AI companies usually offer a family of sizes: a large, capable, expensive model, and smaller, faster, cheaper ones for simpler jobs.
Bigger isn't automatically better. Parameter count is only one ingredient. How much text the model learned from, how good that text was, and how the model was taught to follow instructions afterwards all matter just as much. The story told under Language Model, in which a small instruction-tuned model beat one over 100 times its size in people's preferences, and the example of small models below, both make the same point. A well-trained small model can beat a badly-trained big one.
It decides where a model can run. Small models, a few billion parameters, can run on a phone or laptop, with no internet connection and nothing leaving your device. That matters for privacy, for cost, and for working offline. Giant models need racks of specialised chips. For many everyday tasks, such as tidying up notes or drafting a short reply, a small local model is enough.
It shapes who gets access. A company that publishes its parameters lets anyone run, study, and adapt the model. A company that keeps them private controls every use through its own apps and API. Both approaches have strong defenders, and the argument about which is safer and fairer is one of the big ongoing debates in AI.
Real-world examples
Llama: the weights that got out (2023)
On 24 February 2023, Meta announced LLaMA, a family of language models in four sizes: 7, 13, 33, and 65 billion parameters. The research paper claimed that the 13-billion-parameter version outperformed GPT-3, with 175 billion, on most of the benchmarks the team tested. Meta didn't publish the weights for anyone to download. It released them under a non-commercial research licence, granting access case by case to academics, government, civil society, and research labs.
About a week later, on 3 March 2023, a downloadable copy of the weights was posted as a BitTorrent link and shared on the 4chan message board, and it spread quickly through online AI communities. Meta filed takedown requests against copies posted on Hugging Face, but the files had already spread. It was widely reported as the first time a major tech company's restricted AI model had leaked to the public, and suddenly anyone with a fast internet connection had it.
What happened next shows why parameter counts matter. On 10 March 2023, a developer named Georgi Gerganov released llama.cpp, a small free program whose stated goal was to run the model using 4-bit quantization on a MacBook. The next day, the programmer and writer Simon Willison described running the 7B model on his own laptop. After quantization, the 7B model took about 4 GB and the 13B model just under 8 GB, which is exactly what the arithmetic above predicts. Within days, others reported running the 7B model, very slowly, on a Raspberry Pi and on a Pixel 6 phone. Willison titled his post "Large language models are having their Stable Diffusion moment", comparing it with the image generator whose free release had set off a wave of home experimentation.
Meta then changed course. On 18 July 2023 it released Llama 2, in sizes from 7 to 70 billion parameters, free for both research and commercial use, with Microsoft as a launch partner. On 23 July 2024 it released Llama 3.1, including a 405-billion-parameter version that Meta called the world's largest and most capable openly available foundation model. "Open weights" became a whole category of AI, with other companies publishing their own model files.
One word of caution about the labels. Meta describes Llama as "open source". The Open Source Initiative, which maintains the long-standing definition of that term, said in February 2025 that Llama's licence still doesn't qualify, because it restricts who may use it and for what. A more precise term for models like this is "open weights": you get the learned numbers, but under a licence with conditions, and usually without the training data. Some projects, such as OLMo from the Allen Institute for AI, go further and publish their training data and code as well. If you plan to use an open-weights model in a business, read its current licence yourself.
Microsoft's Phi models: small but well taught (2023 to 2024)
In June 2023, Microsoft researchers published a paper with a cheeky title, "Textbooks Are All You Need". It introduced phi-1, a coding model with just 1.3 billion parameters. Instead of training it on as much web text as possible, they trained it on a carefully chosen set of "textbook quality" material plus exercises generated by another AI. The paper reported that phi-1 solved about half of a standard set of programming problems on its first attempt, a strong score for a model that small at the time.
The team kept pushing. On 12 December 2023, Microsoft announced Phi-2, with 2.7 billion parameters, and said that on complex benchmarks it matched or outperformed models up to 25 times larger. In April 2024 came phi-3-mini, with 3.8 billion parameters trained on 3.3 trillion tokens. Its paper reported benchmark results rivalling Mixtral 8x7B and GPT-3.5, and noted that the model was small enough to run on a phone.
The lesson isn't that the small models were secretly as good as the giants at everything. Benchmarks measure particular skills, and small models still know less about the world than large ones. The lesson is that parameter count is not destiny. What goes into the parameters, meaning the quality of the training data, counts for a great deal. The family continues on this table as Phi.
An AI model that lives inside a phone (2023)
In December 2023, Google published the technical report for its Gemini family of models. Alongside the large versions, it described Gemini Nano, built for phones, in two sizes: 1.8 billion parameters for devices with less memory and 3.25 billion for devices with more. The report says Nano is 4-bit quantized for deployment, which is the same shrinking trick the llama.cpp developers used, now built into a product.
The same month, Google's December 2023 Pixel update made the Pixel 8 Pro the first phone running Gemini Nano. It powered features such as summaries in the Recorder app and suggested replies in the phone's keyboard, working on the device itself, so the recordings and messages didn't need to be sent to Google's servers. It's a clear picture of the trade-off parameters force. A phone can't hold hundreds of billions of numbers, so the phone gets a small model for small jobs, and anything harder is sent to a big model in the cloud. Features and supported devices change often, so check your own phone's current settings and privacy terms.
The companies that stopped saying how big their models are (2023 onwards)
For years, publishing a new model meant publishing its size. GPT-3's 175 billion parameters were in the first line of its paper. That changed in March 2023, when OpenAI published the technical report for GPT-4. It said that, given the competitive landscape and the safety implications of large models, the report contained no further details about the architecture (including model size), the hardware, the training compute, the data, or the training method.
Other leading labs have also tended to keep the sizes of their top models private. Numbers you see online for those models are usually estimates or rumours, not official figures, so treat them with suspicion. Open-weights models are the exception, because anyone can count the numbers in the published file.
There's a second reason the old single number is less informative now. Some models use a design called mixture of experts, where the parameters are split into many specialist groups and only a few groups are used for each word. Mistral's Mixtral 8x7B, released in December 2023, has 46.7 billion parameters in total but uses only 12.9 billion for each token. DeepSeek-V3, described in December 2024, has 671 billion in total and uses 37 billion per token. For models like these you'll see two numbers: total parameters, which decide how much memory the model needs, and active parameters, which decide how much work each word takes.
An everyday case: the consultant who wanted her notes to stay private
This is an illustrative scenario, not a documented event. Imagine Dana, a management consultant whose client contracts forbid uploading their documents to outside services. She'd love an AI to tidy her meeting notes, but she can't paste them into a cloud chatbot.
Her laptop has 16 GB of memory. Using the arithmetic above, she rules out a 70B model straight away, since even at 4 bits it would need around 35 GB. She downloads a free app for running local models and tries a 4-bit version of an 8B model, about 5 GB. It runs, not as fast as a cloud chatbot, but fast enough. It's good at turning scrappy bullet points into clean summaries, and noticeably worse than the big cloud models at reasoning through a tricky client problem. So she settles on a split: the local model handles anything confidential, and she uses a cloud model only for general questions containing no client details. Knowing what "8B, Q4" meant turned a vague worry into a working setup.
Try it yourself
You don't need to be technical to get a feel for parameters. Allow half an hour.
- Find your computer's memory. On Windows, open Settings, then System, then About, and look for "Installed RAM". On a Mac, open the Apple menu, then About This Mac, and look for "Memory". Write the number down. This is the single biggest limit on what size of model your computer can run.
- Do the size arithmetic. For any model you read about, multiply its billions of parameters by 2 to get gigabytes at full size, and by roughly 0.5 to 0.6 for a 4-bit version. A comfortable rule is that the model file should use no more than about half to two thirds of your memory, leaving room for your system and your conversation. With 16 GB, 4-bit models up to about 8B to 14B are realistic. With 8 GB, stay at 3B to 4B or below.
- Browse a real model library. Go to huggingface.co and search for a model family you've heard of, such as Llama, Gemma, Qwen, or Phi. Look at the model names and you'll see the sizes in the names, and often versions marked 4-bit, Q4, or 8-bit. Notice how many sizes a single family comes in.
- Try a local model, if you'd like to. Free desktop apps exist that download and run open-weights models for you with no coding, such as LM Studio or Ollama. At the time of writing they are free to download, but features and terms change, so check each one's current terms and only download from its official site. Pick a small model first (3B to 8B, 4-bit) so the download is a few gigabytes rather than tens.
- Run the same prompt on two sizes. If you can, run a small model and a bigger one, or a small local model and a big cloud chatbot, on the same tasks. Try one easy task and one hard one. Here are two to copy:
Turn these notes into a tidy three-sentence summary for a client email:
- met Tues, budget ok but tight
- launch slips 2 wks, supplier delay
- need sign-off on new logo by Fri
A shop sells notebooks at 3 for $10 or $4 each. I need 11 notebooks.
What is the cheapest way to buy them, and how much will it cost?
Show your reasoning step by step.
- Compare honestly. On the first prompt, you'll often find the small model does fine. On the second, which needs careful reasoning, differences between sizes tend to show up more clearly. Write down which jobs the small model handled well enough. That list is your personal answer to "how big a model do I need?"
- Ask a chatbot to explain a model card. Paste the description from a model's page into a chatbot and ask:
Here is the description of an AI model. In plain English, tell me:
1. How many parameters it has, and whether that is total or active.
2. Roughly how much memory I would need to run it at 4-bit.
3. What licence it uses and whether it allows business use.
Say clearly if the description doesn't give one of these.
Then check the answers against the page yourself, since chatbots can misread details.
Common mistakes and misunderstandings
"More parameters always means a better model." Not reliably. Training data, training method, and instruction tuning matter as much as size. Small, well-trained models regularly beat older, larger ones. Compare models on the tasks you care about, not on their size.
"Parameters are like a database of facts." They aren't. The model doesn't store sentences it can look up. It stores patterns spread across billions of numbers, which is why it can sound confident and still be wrong, a failure known as hallucination. If you need answers taken from specific documents, a technique like RAG that feeds those documents in is more dependable than hoping the facts are in the parameters.
"The model learns from my chats." Its parameters don't change while you talk to it. It uses what's in the current conversation, and some apps add a separate memory feature that stores notes about you, but that isn't the model retraining itself. Whether a company later uses your conversations to train future models is a question of its data policy, which you should check.
Confusing parameters with tokens or with the context window. Parameters are the model's learned numbers and are fixed. Tokens are the pieces of text it reads and writes. The context window is how many tokens it can consider at once. A model can have many parameters and a small context window, or the reverse.
Confusing training data size with model size. "Trained on 15 trillion tokens" describes how much text the model learned from during pretraining. "70B" describes how many numbers it learned. They're separate choices, and getting the balance between them right matters.
Forgetting that total and active parameters differ. For mixture-of-experts models, the headline total can be huge while each word uses only a small share. The total tells you the memory needed. The active count tells you roughly how fast and cheap each word is.
Assuming 4-bit means a quarter of the quality. Quantization rounds the numbers. It doesn't delete three quarters of the model. A 4-bit model usually behaves much like the original, with some loss, and more loss the further you shrink. Test it on your own tasks rather than assuming either way.
Believing parameter counts you see online for closed models. When a company hasn't published the size of its model, any figure you read is an estimate. Treat it as a guess, not a fact.
Assuming "open" means you can do anything. Open-weights models come with licences, and those licences can restrict commercial use, certain uses, or large companies. "Free to download" isn't the same as "free to use for anything".
Related elements
- Neural Network: the structure whose connection strengths the parameters are.
- Language Model: the kind of model whose size is most often quoted in billions of parameters.
- Pretraining: the stage where most of a model's parameters are learned from huge amounts of text.
- Fine-tuning: adjusting an existing model's parameters for a narrower task.
- Inference: running a trained model, where the parameter count sets the memory and cost.
- Mixture of Experts: a design where only some of the parameters work on each word.
- Tokens: the units of text that every parameter is used to process.
- Context Window: the model's short-term working space, separate from what its parameters learned.
- Llama: the model family whose leaked weights made running AI at home popular.
- Phi: Microsoft's small models that do a lot with few parameters.
- Interpretability: the research effort to understand what billions of parameters actually encode.