Two phases, one of them frozen
Everything an AI model does happens in one of two phases, and almost every misunderstanding about AI comes from mixing them up. Training is when the model is built: it reads enormous quantities of text and is adjusted, very slightly, millions of times. Inference is when you use it: it reads your question and produces an answer. Training changes the model. Inference does not.
Put plainly, the model you talk to today is finished. It was finished before you opened the tab, it will be identical when you close it, and it is identical for every other person using it at the same moment. Inside an LLM walks through what happens during inference, one token at a time. This article is the other phase - where the thing doing that came from.
It is worth naming the output directly. What a training run produces is an LLM - a file of numbers that can continue text.
An LLM is what a training run produces. Training is the process, the LLM is the artifact - the same thing at two different moments.- what the word actually names
That also explains version numbers. Every named model on a vendor's page is one finished run. A newer version is not the previous model having studied more in the meantime; it is a separate run over a newer pile of text, producing a different file that then replaces the old one behind the same product name. Nothing upgrades in place, and the model you used last month did not quietly get better - it got swapped.
Training builds the model. Inference uses it. Nothing you do at inference changes the model.- the distinction the rest of this article rests on
The lifecycle in order: pretraining, then fine-tuning, then preference training, then release. After release the file stops changing and the serving phase begins. Retrieval, memory, and the vector databases in section 07 all live in that last phase, which is why they teach the model nothing - a point worth holding on to before anyone proposes training a model on the company wiki.
What a weight actually is
A model is a file. Inside that file is a very long list of numbers called weights or parameters, and nothing else that matters - no documents, no sentences, no database of facts you could open and read.
Think of each weight as one dial on an implausibly large mixing desk. Each dial controls how strongly one signal inside the network pushes on another. A single dial means nothing on its own. Set billions of them to the right positions and the whole desk turns "The capital of the UK is" into a strong vote for " London".
Learning is nothing more than adjusting those dials. That is the entire mechanism, and it is worth being blunt about how unromantic it is. There is no moment of comprehension in there. There is a number that was 0.0421 and is now 0.0419, repeated across billions of dials and trillions of tiny corrections, until the collective behaviour of the desk is useful.
Two consequences follow immediately. You cannot look up a fact inside a model, because facts are not stored anywhere as facts - they are smeared across the dial positions. And you cannot delete one, for the same reason.
Pretraining: predict the next token
Pretraining is the long, expensive first pass that produces nearly all of a model's knowledge and nearly all of its cost. The task it is trained on is almost comically simple: given some text, predict what comes next.
No human labels this data. The text labels itself, because the right answer is simply the word that actually came next in the document. That is why it can be done at a scale no labelling team could match.
That is one step. Run it across a corpus of web pages, books, code, and documentation - trillions of tokens - and the nudges accumulate into something surprising. To predict text well you end up needing grammar, then facts, then the shape of an argument, then how a function signature tends to continue. None of that was taught directly. It is all a side effect of getting better at one guessing game.
The measurement of the error is called the loss, and the nudging procedure is gradient descent. You can build an accurate mental model without either word: guess, check against reality, adjust slightly, repeat.
What comes out of pretraining is a base model. That file is already an LLM in the full technical sense - the complete size, nearly all of the knowledge it will ever have. It is knowledgeable and fairly useless - ask it a question and it may continue with three more questions, because that is what a page of questions usually does.
Fine-tuning and preference training
The gap between a base model and something you would ship is closed by two much smaller passes over the same weights.
- Instruction tuning (also called supervised fine-tuning) trains on curated examples of a request followed by a good response. Thousands or tens of thousands of them, rather than trillions. This is what teaches the model to answer the question instead of continuing the document.
- Preference training shows the model two candidate responses to the same request with a human judgement of which is better, and adjusts the weights toward the preferred one. Done with reinforcement learning it is called RLHF, reinforcement learning from human feedback; there are simpler variants now, but the ingredient is the same - human preference, at scale. This is where tone, refusals, hedging, and formatting habits come from.
Both passes are cheap next to pretraining and both are shaping rather than teaching. Here is the part that costs companies real money when they get it wrong: fine-tuning is how you change behaviour, not how you add facts. Fine-tune on your support tickets and you get a model that sounds like your support team. It will not reliably know your refund policy, and worse, it will now be confidently wrong in your house style.
Why there is a cutoff date
Training runs on a fixed pile of text collected up to a particular day. Everything after that day is simply not in the pile, so it cannot be in the dials. That day is the training cutoff, and it is a hard edge, not a gradual fade.
This is also why the edge is blurry in practice rather than crisp. Events near the cutoff are underrepresented - the internet had not finished writing about them yet - so a model often knows a recent thing exists without knowing how it turned out.
The fix is never to retrain. It is to put the current information in front of the model at question time, which is what RAG and web search tools do, and what section 08 is about.
Why your chat teaches it nothing
You correct the model. It says "you are right, my apologies" and does better. It feels exactly like teaching. It is not.
What actually happened is that your correction is now part of the text the model reads on the next turn. It is behaving differently because its input changed, not because it changed. Start a new conversation and the correction is gone, because the weights never moved. What's in an agent's context covers that block of text in detail.
The same goes for everything marketed as memory. A CLAUDE.md file, a saved-preferences feature, a project instruction - these are files that get pasted back into the input each time. Useful, worth setting up, and not learning. The model is not remembering you; something is re-reading a note to it.
There is one real exception, and it runs on a different clock: providers may use conversations as training data for a future model, subject to whatever your plan and settings say. That is a new training run producing a new file months later, not the model in front of you updating itself.
Embeddings are trained too
This is where vector databases enter, and the relationship is more interesting than it first looks.
An embedding model is a second trained model, usually much smaller than a chat model. Its job is not to write text but to turn a piece of text into a list of numbers - an embedding - positioned so that texts with similar meaning land near each other. It gets that ability the same way: a training run, this one rewarded for putting related passages close together and unrelated ones far apart.
So the chain runs: a training run produces an embedding model; the embedding model converts your documents into vectors; those vectors go into a vector database, which is ordinary infrastructure for finding the nearest ones quickly.
The distinction worth keeping: training produced the embedding model; the vector database only stores its output. Adding a thousand documents to the database changes no weights anywhere. Nothing has learned anything. You have built an index, and an index is a filing cabinet, not an education.
One practical consequence falls straight out of that. Embeddings are only comparable with others from the same model, so switching embedding models means re-embedding every document you stored.
Your documents: train or retrieve?
"Can we train it on our data?" is the most common question in the room, and the honest answer is usually that you do not want to. Compare the two options on what each one actually does.
For company knowledge - policies, docs, tickets, a product catalogue - retrieval wins on every line that matters. The information stays in a system you can edit, the answer can point at its source, and removing a document actually removes it.
Fine-tuning earns its place when the thing you want is a behaviour: a rigid output format, a domain vocabulary, a house tone, a classification task where a smaller cheaper model can be trained to match a larger one. Notice that none of those are facts.
The reliable rule: facts belong in retrieval, behaviour belongs in weights. Teams that try it the other way spend a quarter fine-tuning and end up adding retrieval anyway.
What it costs
Pretraining a frontier model is an industrial undertaking: thousands of specialised chips running for months, an electricity bill to match, and a bill that lands in the tens of millions of dollars or beyond. A failed run is a very expensive way to learn that a hyperparameter was wrong. This is why a handful of labs pretrain and everyone else builds on what they publish.
The later stages are a different world. Fine-tuning an open model on a modest dataset is hours on rented hardware and can cost less than a team lunch, which is precisely why it gets reached for - it is the affordable option, not the correct one.
So the practical shape of working with AI in 2026 is this: somebody else paid for the dials, you supply what goes in front of them. Training is where the capability came from. What you put in the input at question time is where your answer comes from, and unlike the training run, that part is entirely yours to get right.