A large language model does one thing: given some text, it predicts what should come next. Not the answer, not the meaning. The next fragment of text, chosen from a probability distribution over every fragment it knows.
Run that trick a few hundred times in a row, feeding each prediction back in as part of the input, and you get a paragraph. Everything a model appears to do sits on top of that loop.
Text becomes numbers first
A model cannot read letters. Before anything happens, text is chopped into tokens, which are roughly word-pieces. "Understanding" might become "Under" plus "standing". Common words are usually one token; rare ones break into several.
Each token is then turned into a long list of numbers, a few thousand of them, called an embedding. The useful property of this list is that tokens used in similar ways end up with similar numbers. Nobody hand-wrote those numbers. They fell out of training.
Training: prediction, repeated an absurd number of times
Take an enormous quantity of text. Hide a token. Ask the model to guess it. Compare the guess with the real answer, and nudge every one of the model's internal numbers a fraction in whatever direction would have made the guess slightly better.
Repeat. Trillions of times.
Those internal numbers are the parameters, and there are typically hundreds of billions of them. They are not facts and not rules. They are the settings that happened to minimise prediction error across the training text.
This is the part people find hardest to accept, so it is worth stating flatly: nobody programmed the model to know that Paris is in France. Predicting text well enough, often enough, produced a configuration in which that association is encoded somewhere among the parameters, in a form no one can point to.
Attention: which earlier words matter
The mechanism that made modern models work is called attention, and the idea is simpler than the name.
When predicting the next token, the model weighs every previous token by how relevant it is right now. In "The trophy would not fit in the suitcase because it was too big", deciding what "it" refers to requires looking back at "trophy" and "suitcase" and weighing them. Attention is the machinery that does that weighing, for every token, at every layer, in parallel.
Do this across many stacked layers and the earlier layers end up handling grammar and local structure while the later ones handle something closer to topic and intent.
Training and inference are different activities
People conflate two very different phases.
| Phase | What happens | Cost |
|---|---|---|
| Training | Parameters are adjusted. Happens once, over weeks or months. | Enormous, concentrated |
| Inference | Parameters are frozen. The model just runs. This is every question you ask it. | Small each time, vast in aggregate |
A model does not learn from your conversation. When you correct it, it adapts within that conversation because your correction is now part of the text it is predicting from. Start a new conversation and the correction is gone. Both phases run in the data centres that make the physical internet so energy-hungry, and inference is now the larger share of the bill.
Why it is confident when it is wrong
The model is not consulting a store of facts and reporting what it finds. It is producing text that is statistically plausible given everything before it.
A plausible-sounding wrong answer and a plausible-sounding right answer look identical from the inside. There is no separate step where the model checks. This is why a model will invent a citation with a convincing author, journal and year: that pattern of text is exactly what a real citation looks like, and looking right is the entire objective.
A language model is not a database with a chat interface. It is a very good guess about what text comes next, and a very good guess is sometimes wrong in a way that reads exactly like being right.
What they are genuinely good and bad at
Good: rephrasing, summarising, translating, drafting, explaining a concept in different words, spotting patterns in text, writing and debugging code. Anything where fluency is the substance of the task.
Bad: arithmetic beyond small numbers, anything requiring a fact it has no reliable exposure to, knowing what it does not know, and staying consistent across a long document. Models are also poor at slang whose meaning depends on who is in the room, which is why they mishandle terms like IYKYK, and they are the source of a great deal of the low-effort filler that made brain rot a word people use.
The honest limit
How these systems produce a specific output is not fully understood, including by the people who build them. The architecture is public and the training procedure is documented. Which parameters encode which capability is largely not, and interpretability research exists precisely because that gap is uncomfortable.
Treat a language model as a fast, fluent, well-read assistant with no memory and no way of telling you when it is guessing. Used that way it is genuinely useful. Trusted further than that, it will eventually embarrass you.