An AI model is a large set of numbers — called weights or parameters — that a training process has adjusted until the model reliably turns inputs into useful outputs, and it "learns" when those numbers are updated based on examples rather than when you type a new question into it.
That second half trips people up constantly, so it's worth separating the two ideas early. The numbers are the model. The updating of the numbers is learning. Everything else — chat windows, memory features, "it remembers me now" — sits on top of those two things and often gets mistaken for them.
What a model actually is
Think of a model as a very long list of dials. When you send it a prompt, the text gets converted into numbers, those numbers flow through the dials, and the settings of the dials decide what comes out. A model with billions of parameters has billions of those dials, each holding a small number, usually something like 0.0231 or -1.447. None of them mean anything on their own. The meaning lives in the pattern across all of them at once.
This is why a model file is huge and why two models of the same size can behave completely differently. Same architecture, same number of dials, different values in them — different personality, different strengths, different failure modes. When people say a model was "trained on code" or "tuned for chat," they're describing how those values ended up where they are. The model itself is inert. It doesn't think between prompts. It doesn't sit there reflecting. It's a fixed mathematical object until someone changes the numbers.
How training changes the weights
Training works by showing the model examples, comparing its output to the desired output, and nudging every dial slightly in the direction that reduces the error. Do that across a very large number of examples and the dials settle into a configuration that produces good answers on similar inputs. This is the whole mechanism, just at a scale that's hard to picture.
A concrete example: imagine training a model to finish sentences. You feed it "The cat sat on the" and the correct next word is "mat." If the model predicts "roof," the training process calculates how wrong that was and adjusts the dials a tiny amount so "mat" becomes marginally more likely next time. One example barely moves anything. Millions or billions of examples, repeated, move the dials a lot. That's why training takes so long and costs so much — it's not one clever step, it's an enormous number of very small corrections.
Two consequences follow from this, and they explain a lot of confusing behavior. First, a model can only be as good as its training examples allow. Feed it narrow data, get a narrow model. Second, the training data is frozen into the weights at the end. A model doesn't keep learning from your conversations unless someone deliberately runs another training round — and that's a separate, expensive decision made by the company, not something that happens because you had a long chat.
Session context is not learning
Here's the part that causes the most misunderstanding. When a chatbot seems to "remember" what you said ten messages ago, the model's weights have not changed at all. What's happening is that the earlier messages get packaged up and sent along with your new message, so the model sees them as part of its input. The dials are identical to what they were before you started. The context is doing the work, not the model.
You can see this clearly with a worked example. Ask a chatbot your name in message one, then ask "what's my name?" in message twenty. It answers correctly — but start a brand-new conversation and it has no idea. The information never entered the weights. It lived in the conversation, and when the conversation ended, so did the memory. Features marketed as "memory" typically store notes about you somewhere outside the model and paste them into future prompts. That's a filing cabinet next to the model, not the model learning.
I should flag a limit here: I have no source for how any specific vendor handles your data, whether they train on your conversations, or how their memory features are built internally. Those details vary by company, change often, and the vendor's own documentation is the only reliable place to check. The reasoning above is general — it describes how these systems are typically structured, not a verified account of any particular product.
Where this matters in practice
Understanding the distinction changes how you use these tools. If you need a model to handle a new domain well, you can't teach it by chatting. You either supply the relevant information in the prompt or context, or you use a system built to retrieve it. That's why so much practical AI work is about feeding the right context rather than "training" anything.
It also explains why a model can be brilliant on one task and useless on a near-identical one. The dials were shaped by specific examples, and outside that shape, there's nothing to fall back on. Our internal database of 360 AI tools records pricing and capability snapshots at verification time, and capability differences between tools often trace back to exactly this — different training, different tuning, different dials. The model is not a general reasoning engine that happens to know things. It's a pattern shaped by data, and it behaves like one.