How LLMs work, without the math

The pipeline: what happens when you press send

Step one is tokenization. The model never sees letters or words. Your text is chopped into tokens, common fragments from a fixed vocabulary, so 'strawberry' might become two or three pieces, each with an id number. This is why models are billed per token and why counting letters inside a word is famously hard for them.

Step two is embedding. Each token id looks up a long list of numbers, its position on a learned map of meaning, where similar meanings sit near each other. From here on, everything is arithmetic on those number lists.

Step three is the transformer itself: dozens of stacked layers where attention lets every token look at the other tokens and pull in the ones that change its meaning, so 'bank' near 'river' ends up carrying a different vector than 'bank' near 'money'. Step four turns the final vector into a score for every token in the vocabulary, and a softmax turns scores into probabilities. Step five samples one token from that distribution, appends it, and the whole thing runs again. A 500-word answer is that loop executed a few hundred times, fast enough to look like typing.

Where the 'knowledge' comes from: training

All those weights start as random numbers. Pretraining fixes that with one brutally simple exercise, repeated trillions of times: show the model a slice of real text, hide the next token, let it guess, measure the miss, nudge the weights to miss less. Do this across trillions of tokens of web pages, books and code, and the weights are forced to absorb grammar, facts, style and code patterns, because absorbing them is the only way to keep guessing well.

A raw pretrained model is a continuation machine, not an assistant. Ask it a question and it might continue with three more questions, since that is a plausible continuation. Post-training turns it into a product: it is shown examples of helpful dialogue, then tuned on human (and increasingly AI) preference judgments, a process whose best-known ingredient is RLHF, reinforcement learning from human feedback. That is where 'predict text' becomes 'answer the user, decline harmful requests, admit uncertainty'.

The split matters for what you can expect. Training happened in the past, once, at enormous cost. When you chat, nothing is learning: the weights are frozen, and your conversation changes the model's behavior only while it sits in the context window. Tomorrow it starts blank again, unless the product deliberately saves memory for you.

How big are these models, in real numbers?

Exact figures for frontier models are trade secrets, but the public record gives honest anchors. The table mixes disclosed historical numbers with commonly reported figures as of mid-2026.

• A parameter is one learned number. 'Billions of parameters' means billions of dials the training process tuned.
• Context windows grew about a thousandfold in six years, which is why models can now read whole books or codebases in one prompt.

Why does it sometimes make things up?

Because nothing in the loop checks the sentence against reality. The model always emits the most likely next token, and fluent, confident prose is the likely shape of an answer whether or not the underlying fact was ever in the training data. When the fact is well represented, likely and true coincide. When it is rare or absent, the model fills the gap with the most plausible pattern, an invented citation, a wrong date, produced by exactly the same machinery as a correct one. This failure has a name, hallucination, and it is managed, not cured: products ground answers in retrieved documents and web search, cite sources, and train models to abstain more, but the prediction engine underneath has no built-in line between remembered and plausible.

This is also the honest way to read the model's confidence. Its tone is a property of the writing it predicts, not a measurement of certainty. The practical rule for anything that matters: ask what the answer is grounded in, and check the source it cites.

What did reasoning models change?

Since late 2024, most frontier systems can spend tokens thinking before they answer: they generate a private chain of intermediate steps, explore, backtrack, then write the reply. Nothing about the core loop changed, thinking tokens are still next-token prediction, but budgeting extra compute at answer time turned out to buy real gains on math, code and multi-step problems. It is the same trick you use when you work a problem on scratch paper instead of blurting the first thing.

The catch is cost and fit. Thinking multiplies tokens, so it multiplies latency and price, and on easy questions it buys nothing, occasionally even talks the model out of a right answer. That is why products ship fast and thinking modes, or route between them automatically. More thinking is not more knowing: a reasoning model still hallucinates facts it never learned, it is just better at working through the ones it has.

What an LLM is not

• It is not a database. There is no table of facts inside, only weights that make good guesses likely. Deleting or editing one specific fact is an open research problem.
• It is not searching the internet, unless the product wraps it in a search tool and pastes results into the prompt. The same model can be current in one app and stale in another.
• It does not remember you between chats by itself. Continuity comes from the product re-sending history or storing memory, both of which live outside the model.
• It does not run your code or check its arithmetic natively. When it gets math right at scale, a calculator or code tool is usually involved.
• It is not conscious, and 'think' is a metaphor. What streams out is a probability distribution being sampled, one token at a time.

What people get wrong

Where you see it in real products

Common questions

Related explainers

More in Foundations