Does a model learn from what you tell it?
For a fixed model file, inference reads its weights without changing them. Training or fine-tuning creates updated weights. What looks like memory during a conversation is often text supplied again as context; whether prompts are stored or later used for training depends on the service.
Training writes the file. Using it only reads.
Training is a search. A program shows the model text, compares what it predicted against what actually came next, and nudges billions of numbers a fraction of a step in the direction that would have been less wrong. Repeat that across a corpus for weeks on a rack of accelerators and you have a finished set of weights: a large file of numbers, and nothing else.
Inference is the other operation. Your words are turned into numbers, multiplied through those weights, and turned back into words. Nothing is written back. For a fixed model version, ordinary inference leaves the weight file unchanged; a service may separately update its model or retain prompts. The weights are written once, at the end of training, and read forever after; that boundary, not anything about a particular conversation, is what separates the two operations.
Then why does it seem to remember?
The surrounding software may supply earlier turns, summaries or saved notes in the model’s context window. The context window limits what can be processed at once; the software decides what prior material to include.
Weights do change, but only when someone decides to change them.
Models are updated. Fine-tuning and preference tuning rewrite weights; adapter training leaves the base weights frozen and adds a small set of new ones beside them. Either way the file you run changes, and a new version can be trained on data gathered since the last one. All of it is deliberate: someone assembles a dataset, runs a job, evaluates the result, and ships a different file. No conversation triggers any of that on its own.
A correction can influence later replies while it is supplied in context, but ordinary inference does not update the base weights and the model may still make mistakes. Whether the correction appears in later context depends on the surrounding software.
Whether your words are kept is a separate question.
The question people usually mean is not whether the model learns, but whether what they typed ends up in the next training set. That is a question about storage, not about how a model works, and the answer is different for every service. Text that never leaves your device cannot be received by a remote provider through that path. Local software can still store or use it on the device. The rest depends on the service and app.
Policy is knowable, and worth reading rather than guessing, because it is written down. It can also be changed later, which is the difference between a promise and a property. And even where text is kept, storage is not the same event as training: a saved conversation sits in a database until someone assembles a dataset and runs a job, the same deliberate process described above, on their own schedule rather than the model's. For any service that receives your text, four things decide whether it can end up in a future training run:
- Whether the operator receives the text at all.
- How long the operator keeps what it receives, and whether deleting a conversation deletes the logs behind it.
- Whether retained text is eligible for training, which is a policy choice and often a per-account setting.
- Whether people read samples of it, which is a normal part of safety and quality work and is separate from training.
Training writes the weights; using a model only reads them. Anything that looks like memory is text being stored and handed back.