The word is doing a lot of work
Everything else in this collection sits on top of one word. Agents call a model. Context is assembled for a model. Cost is measured per model call. If that word is vague, every sentence built on it stays vague too.
The ordinary meaning is a good place to start. A model is a made thing that stands in for a real thing well enough to be useful: a model airplane, a weather model, a financial model of next year’s revenue. Nobody confuses the model for the thing. It is a working approximation, and its value is that you can do something with it that you could not do with the real thing.
An AI model is the same idea applied to patterns in language, images, or code. It is a working approximation of how those things tend to go, built well enough that it can continue them.
What it is made of
A model is a file. A very large one — often hundreds of gigabytes — filled with numbers.
Those numbers are called parameters, or weights. Nobody typed them in. Nobody can point at one and say what it means. They are the residue of a training process, tuned until the file, when run, produced text that looked like the text it was trained on. A model is that file, plus a fairly small program that knows how to push input through it.
That framing rules out three things people commonly assume it is.
It is not a program full of rules. No engineer wrote “if the customer is angry, apologize.” The behavior emerged from the numbers, which is why it can be steered and adjusted but not simply looked up and edited.
It is not a database. The model does not contain the documents it trained on and cannot be queried for them. It absorbed patterns from them the way a person who has read widely retains the shape of an argument without retaining the pages.
It is not a search engine. Nothing is being looked up at the moment you ask. If a system appears to search the web, something outside the model did that and handed the results in.
Where it came from: training
Training is the process that produced those numbers, and it is worth understanding at one level of detail, because it explains most of the model’s behavior.
The system is shown an enormous volume of text with a piece hidden, and asked to predict the hidden piece. It guesses. The guess is compared with the real answer, and every parameter is nudged slightly in whichever direction would have made the guess better. Then it happens again, across an amount of text no person could read in many lifetimes.
Nothing in that description involves understanding, and nothing involves a stored library of facts. What accumulates is a very detailed sense of what tends to follow what — which is enough to write a coherent paragraph, and also enough to write a coherent paragraph that happens to be wrong.
Training is expensive, takes months, and then it ends. What ships is frozen. AI and Agents in Plain Terms covers why that single fact corrects the two most expensive assumptions organizations make about these systems.
What it does when you use it: inference
Running a trained model is called inference. It is a different activity from training, it costs far less, and it changes nothing about the model.
Text goes in. The model predicts a small piece of text to come next — a token, roughly a word or a fragment of one. That piece is added to the input, and the model predicts again. The paragraph you read arrives one token at a time, each one chosen with the whole conversation so far in view.
Two consequences follow directly, and between them they explain a surprising amount of day-to-day behavior.
The model keeps no working state between calls. Each request is answered from the text in front of it and nothing else. What looks like memory of a conversation is the earlier conversation being sent again, every time.
And the prediction is not fixed. The model produces a ranked set of plausible next tokens and one is sampled from that set, which is why the same question asked twice can return two different answers. The setting that governs it is usually called temperature: lower for consistency, higher for variety.
The vocabulary that comes with it
These terms turn up constantly, and each one is smaller than it sounds.
- Parameters — the numbers in the file. Model sizes are quoted in billions of them. More is roughly more capable, and reliably more expensive to run.
- Tokens — the units text is chopped into, going in and coming out. Usage is billed by the token, so a token count is a cost estimate.
- Context window — how much text the model can be shown at once, counted in tokens. Everything the model knows about your task has to fit inside it.
- Prompt — the text sent in. In a real system it is assembled from instructions, history, and retrieved documents rather than typed by a person.
- Inference — one run of the model. The thing you pay for.
- Fine-tuning — extra training on a narrower set of examples, to shift style or format. It teaches a manner of responding, not a body of facts, and it is usually not the answer to “the model does not know our data.”
- Reasoning model — one trained to work through a problem in steps before answering. Slower and more expensive, better on problems that have steps.
- Multimodal — handles images, audio, or video alongside text.
- Open weights — the file is published, so it can be run on hardware you control. The alternative is calling someone else’s model over the internet, which is simpler to start with and means your input leaves your building.
Why “which model” is a real decision
Models come in families and sizes, and vendors release new versions often. The differences that matter in practice are unglamorous: how capable, how fast, how large a context window, how much per token, and whether it can run on hardware you control.
Those trade against each other. The largest model is not the automatic default, because much of the work in a real system is small, repetitive, and well specified — the sort of thing a cheaper and faster model does acceptably at a fraction of the cost. Mature systems commonly use more than one, sending the hard steps to the expensive model and everything else elsewhere.
What a model is not: the product
A model on its own can only produce text. It cannot look anything up, remember yesterday, send an email, or check whether it was right.
Everything useful comes from the software built around it — the part that decides what to put in front of the model, which actions it is allowed to take, and what happens when it gets something wrong. That surrounding software is where the engineering lives, and where projects succeed or fail.
Agents in One Paragraph picks up exactly there, and Build AI Agents with Three Fundamentals covers how to design it.