Definition: Model parameters, usually called weights, are the billions of numbers inside an AI model's neural network that training nudged into place one tiny step at a time, and they are the only place the model's own built-in knowledge lives while it is answering you.
TL;DR: Parameters are the numbers a model learned during training and then froze. They do not change while it answers you, which is why a model cannot learn anything from your chat. GPT-3 shipped with 175 billion of them in 2020. Anything specific to you has to be handed over fresh every time. Build an agent that does that free →
You already carry something like this. After enough years of cooking you salt a dish correctly without measuring, and you could not name the meal that taught you. What you have is not a stored recipe. It is a setting in your hand that thousands of dinners nudged into place, and it stays where it is until something new nudges it again. Parameters are that same idea written down as numbers.
Why Model Parameters Matter in 2026
Parameter count is the number the AI industry advertises most and the one that predicts least about whether a model will be useful to you. It does predict three concrete things. It sets how much memory the model needs to run, which decides whether it fits on a laptop or needs a room full of hardware. It sets roughly what a provider has to charge per answer. And it caps how much the model could have absorbed during training, because there is nowhere else for that knowledge to sit. What it does not predict is accuracy on your work. Scaling laws research showed that the volume of training data matters as much as the parameter count, and a well-fed smaller model routinely beats a badly-fed larger one. Distilled models made that outcome ordinary rather than surprising. The question worth asking in 2026 is not how many parameters a model has. It is what was fed into them, and what software is wrapped around them.
How Model Parameters Work
A parameter is one number attached to one connection inside the network. Your text goes in as tokens, each token becomes a list of numbers, and those numbers are multiplied by parameters layer after layer until what comes out the far end is a ranked guess at the next token. The parameters do all of the shaping, and while an answer is being written not one of them moves.
- Your text becomes numbers. A tokenizer chops what you typed into tokens, and each token is looked up as a list of numbers called an embedding. Nothing has been understood yet. It has only been converted.
- Every layer multiplies. Each number arriving at a layer is multiplied by the parameters on its connections and added to its neighbours. That single operation, repeated across a neural network of many layers, is the whole engine. The perceptron of 1958 was one artificial neuron doing exactly this with a handful of weights.
- Some parameters decide what to pay attention to. A large share of them live in the attention mechanism, which works out which earlier words in your message should influence the next one. That is where "understands the sentence" actually happens.
- The last layer scores every possible next token. The model picks from that ranked list, appends the winner, and runs the whole thing again for the token after it.
- Nothing gets written back. The parameters end the answer in exactly the state they started it. The model is stateless, and what it knew going in is its parametric knowledge, frozen at the moment training stopped.
Parameters only move during training. Pretraining sets the bulk of them, fine-tuning shifts a portion to specialise the model, and RLHF adjusts them again to make the model helpful and safe to talk to. All three are done before you ever see the model. None of them happen because you sent a message.
Because every parameter is a number that has to be held in memory to run, the count translates almost directly into hardware:
1 PARAMETER one number, roughly 2 bytes of memory
8 BILLION PARAMETERS about 16 GB runs on a strong laptop
70 BILLION about 140 GB needs a server
500 BILLION AND UP split across many machines, datacenter only
A mixture-of-experts model bends that arithmetic on purpose. It holds a very large total number of parameters but sends each token through only a slice of them, so it can be large in knowledge and cheap per answer at the same time. This is also why "open weights" is the precise term for an open-source model: what a lab publishes is the parameter file itself, the finished numbers, not the training data or the machines that produced them.
Parameters vs Context vs the Settings You Tune
Three different things get called a model's parameters, and confusing them is the most common reason people expect an AI to remember something it never could. Only the first of the three was learned. The other two are things you supply at the moment you ask.
| Question | Parameters (weights) | Context you send | Settings you tune |
|---|---|---|---|
| What it is | Billions of learned numbers | The text handed over this turn | A few dials like temperature |
| Where it came from | Training, months of it | You, your files, or a retrieval step | A menu in the product |
| Changes while it answers | No, never | Yes, every turn | Yes, per request |
| Holds your company's facts | No | Yes | No |
| Size limit | Fixed when the model shipped | The context window | Not applicable |
| Who can change it | Whoever trains the model | You | You |
Read the fourth row twice. If you want a model to know something specific to you, none of it goes in the first column. It goes in the second, which is why retrieval and good context engineering do more for answer quality than a bigger model does.
Connection to Taskade
You never pick a parameter count in Taskade, and you should not have to. The Auto setting routes each job to one of 15+ frontier models from OpenAI, Anthropic, Google, and open-weight providers, so a quick rewrite gets a fast model and a hard build gets a strong one without you tracking releases.
The more useful half is what Taskade keeps out of the parameters. Your policies, records, and project history live in your workspace, where you can read and edit them, which is the Memory side of Workspace DNA: Memory feeds Intelligence, Intelligence triggers Execution, and Execution creates more Memory. Point a Taskade AI Agent at a project and it reads the current version of those documents on every run instead of leaning on whatever some model absorbed in training. Its built-in tools and 100+ bidirectional integrations fetch the rest, pulling events in from the apps your team already uses and pushing updates back out. When an automation runs overnight, it works from today's records rather than a frozen snapshot.
What You Would Build in Taskade
Every team has a set of answers buried in documents nobody opens: the refund rule, the onboarding steps, which discount needs a second signature. People ask anyway, and someone answers by hand. No parameter count helps here, because no model was trained on your handbook and none ever will be.
In Taskade that becomes an answer desk you describe in one sentence. Your policies live in a project. An agent reads them, answers questions in chat or from a form, and points to the section it used so anyone can check it. When a policy changes you edit the project, and the next answer is correct that afternoon, with no retraining and no waiting on a model release. You watch the questions arriving in whichever of the 7 project views you actually think in, a list, a board, or a table. The desk stays current because your files are the source, not a number frozen in a lab last year.
Describe yours and build it free →
Related Concepts
- Model: what the parameters are actually inside of
- Neural Network: the structure the parameters sit on
- Model Training: the only process that moves them
- Parametric vs Contextual Knowledge: what a model knows versus what you hand it
- Scaling Laws: why bigger stopped being the whole answer
- Model Distillation: shrinking the count without losing the ability
- Open-Source AI Models: what "open weights" actually means
- Mixture of Experts: huge total parameters, small slice per token
- AI Agents in Taskade: the software wrapped around the numbers
Frequently Asked Questions About Model Parameters
What are parameters in an AI model?
Parameters are the numbers inside an AI model that training adjusted until the model produced good output. Each one sits on a connection between artificial neurons in a neural network. Together they hold everything the model learned, and they are the only place that learning is stored.
What is the difference between parameters and weights?
In everyday use the two words mean the same thing. Strictly, weights are the numbers on the connections between neurons, and parameters means weights plus a smaller set of adjustment values called biases. Since weights are the overwhelming majority, most people and most model cards use the two terms interchangeably.
Does more parameters mean a better AI model?
Not reliably. A larger count means more capacity to absorb training data, more memory to run, and a higher cost per answer. It does not mean better answers on your work. Scaling laws showed data volume matters as much as size, and distilled smaller models often beat larger ones on practical tasks.
Do model parameters change when I chat with a model?
No. The parameters are read-only during an answer, which is why a model is stateless and cannot learn from your conversation. Anything that feels like memory is software resending earlier messages, or an agent memory store outside the model, not the parameters changing.
Where does an AI model store what it knows?
Entirely in its parameters, which is called parametric knowledge. There is no searchable database of facts inside a model and no copy of the text it read. That is also why models invent details: a fuzzy setting can produce a confident wrong answer, the failure mode known as hallucination.
Are model parameters the same as settings like temperature?
No, and the shared word causes real confusion. Temperature and similar dials are request settings you change per message. Model parameters are the learned weights fixed when the model was trained. You can change the settings freely; only the lab that trained the model can change the weights.
What does a parameter count tell me about running a model myself?
Mostly the hardware bill. At common precision each parameter takes about 2 bytes, so an 8-billion-parameter model needs roughly 16 GB of memory and a 70-billion one needs about 140 GB. That arithmetic is the main reason open-source models ship in several sizes of the same family.
Which model size does Taskade use?
You do not choose one. Taskade's Auto setting routes each job across 15+ frontier models from OpenAI, Anthropic, Google, and open-weight providers, matching the model to the task instead of pinning a version. Your own facts stay in your workspace, where a Taskade AI Agent reads them fresh on every run.