What Is an LLM?

A large language model is a machine trained to predict the next token. Here is why that simple objective produces something that looks like thinking.

A large language model is a machine trained to do one thing: given a sequence of tokens, predict the next one.

That is not a simplification for beginners. That is the actual objective, and nearly everything else about these systems is a consequence of it.

The interesting question is not what an LLM does. It is why such a narrow objective produces something that can debug code and explain contract law.

The prediction machine

Feed the model The capital of France is. It does not return one answer. It returns a probability distribution over its entire vocabulary — tens of thousands of numbers, one per possible next token.

␣Paris might get 0.94. ␣the might get 0.01. Most tokens get almost nothing. A sampling step then picks one, it gets appended, and the whole sequence goes back in for another round.

Text comes out one token at a time, each one conditioned on everything before it. That loop is called autoregressive generation, and it is the entire generation process. There is no separate planning phase, no outline being followed, no internal draft. The paragraph you are reading from a model was built forward, one fragment at a time.

Why “predict the next token” is harder than it sounds

Here is the part that makes LLMs work, and it is easy to miss.

To predict the next token well across billions of varied examples, mere word statistics are not enough. Consider what a good prediction requires:

• The keys to the cabinet ___ → needs subject-verb agreement across an intervening phrase
• Sarah told Maria she had won. She ___ → needs to track who is who
• def fibonacci(n): if n <= 1: return ___ → needs to know what the function is supposed to do
• The murderer turned out to be the ___ → needs the whole plot in mind

You cannot do these with a lookup table. The only way to get good at next-token prediction across all of human text is to develop internal machinery that tracks grammar, entities, arithmetic, causality, and code semantics.

Capability is not the goal. It is what the goal forces. The objective is trivial; being good at it is not.

What “large” is doing

Three things scaled up together, and all three mattered:

Parameters — the adjustable numbers inside the model, now in the billions. See What Does “7B Parameters” Mean?.

Training data — a substantial fraction of accessible written text.

Compute — the processing required to tune those parameters against that data.

Scaling all three did not just improve output smoothness. Capabilities appeared that smaller models did not have at all: multi-step arithmetic, following instructions in unfamiliar formats, translating between language pairs never explicitly paired in training. Quantity of the same simple thing produced qualitative change, which is the observation that redirected the entire field.

What it does not have

Because prediction is the whole objective, several things people assume are present are absent.

No memory between conversations. Each request arrives fresh. The apparent memory in a chat interface is the entire prior transcript being re-sent every turn — which is also why long chats get expensive and eventually hit the context window.

No lookup. The model does not consult its training data at generation time. Whatever it retains is baked into its parameters as statistical structure. It cannot cite a source it cannot reconstruct, which is one root of hallucination.

No knowledge of its own confidence in the way you would want. It produces a distribution over tokens, but a sharply peaked distribution reflects a strong pattern, not verified truth. Fluent and wrong is a completely natural output state.

No learning from you. Corrections you offer influence the current conversation only because they are now in the context. Nothing persists.

Base models and chat models

A raw model trained purely on next-token prediction is a base model, and it does not behave like an assistant. Ask it a question and it might continue with more questions — because in its training text, questions are often followed by other questions.

Turning that into something helpful requires an additional training stage on demonstrations of instruction-following and preferred responses. That is what separates ChatGPT-style products from the underlying prediction engine, and it is covered in Base Models vs Chat Models.

Worth knowing that the assistant persona is a trained layer, not an inherent property. Underneath, it is still predicting tokens.

What to remember

• An LLM predicts the next token. That is the complete objective.
• Broad capability emerges because good prediction requires internal machinery for grammar, entities, logic, and code.
• “Large” means parameters, data, and compute scaled together — and that scaling produced new capabilities, not just polish.
• No cross-conversation memory, no lookup at generation time, no reliable self-assessment.

Next: What Is an Embedding? — how tokens become something a model can compute with.