Training: What This Means for You

Your Model Already Graduated

This is the practical companion to episode three of Actually, AI, training.

In the main episode and the deep dive, we walked through how training works. Billions of examples, trillions of predictions, knobs nudged downhill in the dark. That process is fascinating, but it happened before you showed up. The model on the other end of your chatbot is already trained. Its knobs are frozen. When you type a question, nothing in the model changes. No knobs get nudged. No learning happens. You are talking to a snapshot.

This matters more than it sounds. Because if the model is a snapshot, then the question becomes: a snapshot of what? And the answer is, a snapshot of human text up to a certain date. Everything written in books, on the internet, in code repositories, in academic papers, in forum posts, in Wikipedia, up to a cutoff. After that date, the model has seen nothing. It is not watching the news. It is not browsing the web while you wait. It is frozen in time.

So when you ask it about something that happened last week, and it gives you a confident, detailed, completely wrong answer, now you know why. It is not lying. It is not hallucinating in some mysterious way. It is doing what it was trained to do, predicting plausible next words, using patterns from text that predates the event you are asking about. The confidence is real. The knowledge is not.

This is the first practical thing to internalize. The model knows Shakespeare because Shakespeare was in the training data. It does not know last Tuesday because last Tuesday was not. And it will never tell you "I do not know about that because it happened after my training." It will just generate something that sounds right based on whatever patterns come closest.

Three Ways to Fill the Gap

So the model is frozen. But you need it to know things it was not trained on. Your company's internal documentation. Last week's earnings report. The specific way your codebase handles authentication. There are three approaches, and picking the wrong one is one of the most common mistakes people make with AI tools.

The first is prompting. You put the information directly into your message. "Here is the document. Now answer questions about it." This is the simplest approach and often the most underrated. The model does not learn from your prompt, its knobs do not change, but it can use whatever you put in the context window right now as material for generating its response. Think of it like handing someone a reference sheet during a conversation. They have not memorized it. But they can look at it while they talk to you.

Prompting works beautifully when the information fits in the context window and when you need the model to reason about specific text you can provide. It costs nothing beyond the tokens you send. It requires no technical setup. And it disappears after the conversation ends, the model retains nothing.

The second is retrieval augmented generation, which people in the industry call RAG. Instead of you manually pasting documents into the prompt, a system automatically searches a database when you ask a question, finds the most relevant chunks, and stuffs them into the prompt before the model sees it. The model still does not learn anything. The knobs are still frozen. But the system around the model feeds it fresh, relevant information on every query.

RAG is the right choice when the information is too large to paste manually, when it changes frequently, or when you need the model to draw from a specific knowledge base rather than its general training. Most enterprise AI products, the ones that promise your chatbot "knows" your company wiki, are doing RAG under the hood. The model does not know your wiki. It gets handed relevant excerpts from your wiki at query time and generates answers based on those excerpts.

The third is fine-tuning. This is the only approach that actually changes the model. You take a pretrained model and run additional training on your own data. The knobs move. The model's behavior shifts. This is powerful and almost always overkill.

Fine-tuning makes sense in a narrow set of cases. When you need the model to adopt a specific tone or style consistently. When you need it to perform a specialized task, like classifying medical images or extracting data from a particular document format, and prompting alone does not get the accuracy high enough. When you have hundreds or thousands of examples of the input-output pattern you want.

Fine-tuning does not make sense, and this is where people waste enormous amounts of money, when what you actually need is better prompting or RAG. If the model needs to know facts, give it facts at query time. Do not bake facts into the weights. Facts change. Weights are expensive to change.

What "Trained On" Means for Your Data

Here is a question that keeps legal departments awake. When you send a message to an AI service, does it become training data?

The answer depends on the service and the terms. But the mechanics are worth understanding separately from the legal fine print. Training, as we covered, requires running the full loop. Forward pass, loss calculation, backpropagation, knob adjustment. That process takes enormous compute, runs on enormous datasets, and happens on a schedule measured in weeks or months. Your individual conversation is not being fed into a live training loop in real time. That is not how any of this works.

What some providers do is save conversations to use as training data later, in the next training run. Whether they do this, under what conditions, and whether you can opt out varies by provider and changes frequently. The important thing is the distinction between using the model and training the model. Using the model means your text goes in, a response comes out, and the model is unchanged. Training the model means your text is included in a dataset that adjusts the knobs during a future training run.

Most commercial providers now offer tiers where your data is explicitly excluded from training. OpenAI's API does not train on your data by default. Anthropic's API does not either. The free consumer tiers often have different terms. Read the terms, but also understand the mechanics. The model you are talking to right now is not learning from you in real time.

There is one more nuance. Even when your data is not used for training, your messages are typically processed on the provider's servers. The text travels over the internet, gets tokenized on their hardware, runs through the model on their GPUs, and the response travels back. If the information is sensitive enough that it should not leave your building, running your own model locally or on private infrastructure is the only real solution. That is a different tradeoff, because local models are generally less capable than the frontier hosted ones, but for some use cases the capability gap matters less than the privacy guarantee.

The Knowledge Cutoff in Practice

Every model has a training data cutoff, the date after which it has seen nothing. For the models available in early twenty twenty six, these cutoffs range from mid twenty twenty three to early twenty twenty five, depending on the provider and the model. The exact dates are published, though not always prominently.

This creates a practical pattern worth learning. For anything that changes, verify. If you ask the model about a software library's API, check whether the API has changed since the cutoff. If you ask about a company's leadership, check whether there have been changes. If you ask about a legal ruling, a scientific finding, or a world event, ask yourself whether it could have happened after the cutoff.

For anything that does not change, the model is remarkably reliable. The rules of calculus have not changed since the training cutoff. Shakespeare's sonnets are the same. The syntax of Python three point eight is stable. The history of the Roman Empire is not going to be revised next quarter. The model's knowledge of stable domains is extensive and generally accurate, because it was trained on enormous amounts of text about those subjects.

The practical habit is simple. Before trusting any specific claim, ask yourself: could this have changed? If yes, verify with a current source. If no, the model's answer is likely solid. This is not different from how you would treat any reference book published a year or two ago. Useful for principles. Suspect for current events.

Try This

Here is something you can do in your next conversation with any AI chatbot. Ask it to tell you about a major event that happened last week. Something that was widely covered in the news. Watch what happens.

The model will almost certainly generate a response. It might hedge slightly, or it might present its answer with full confidence. Either way, check what it says against a real news source. Notice the gap. The model is not refusing to answer. It is generating plausible text based on patterns from before the event happened. Sometimes it will get lucky, because events follow patterns too. More often, it will be confidently, fluently wrong.

Now try the opposite. Ask it something timeless. Ask it to explain how a combustion engine works, or why the sky is blue, or what the Treaty of Westphalia established. Notice how much more reliable and detailed the answer is. That is the same model, the same knobs, the same frozen snapshot. The difference is not intelligence or effort. The difference is whether the answer was in the training data.

That gap, between the timeless and the timely, is the most useful mental model you can carry out of this episode. The model is a library, not a newspaper. Use it as a library and it will rarely disappoint you. Use it as a newspaper and it will disappoint you constantly.

The Coffee Shop Version

If you had to explain all of this to someone over coffee, here is what you would say.

The model was trained once, a long time ago relative to internet time, and it has not learned anything since. When you talk to it, you are not teaching it. You are consulting a frozen snapshot of human text. It knows everything that was written before its cutoff and nothing that happened after.

If you need it to know something new, paste it into the conversation or set up a system that does the pasting automatically. That is prompting and RAG. Do not fine-tune unless you have a very specific reason and a lot of examples.

Your data probably does not train the model in real time, but it might be saved for future training depending on your plan. Read the terms. If privacy matters, look at the API tiers or run a local model.

And the single most useful habit you can build is asking yourself, before you trust any answer: could this have changed since the model was trained? If so, check. If not, you are probably fine.

That was the practical companion to episode three.