How LLMs Work

0. So what is an LLM, really?

An LLM is a function. You hand it a sequence of text. It hands you back, for every possible next token, a number — how strongly it predicts that token comes next. Pick one of those tokens, append it to the sequence, and ask again. Keep going until you've grown the answer you wanted.

That's it. Everything else — attention, training, fine-tuning, quantization — is in service of making that one function and that one loop produce text you actually want.

1. Words don't fit in math — so we cheat: tokens, embeddings, and position

A model can't multiply "hello". It can multiply numbers. So before anything else, every piece of text gets converted into numbers in three layers.

Tokens

Text is chopped into small pieces called tokens, and each piece is mapped to an integer ID from a fixed vocabulary (typically 50,000–200,000 entries). Tokens are usually sub-word: "unhappiness" might become ["un", "happiness"] or even ["un", "happi", "ness"]. Common words are single tokens; rare words split into pieces.

Embeddings

Each token ID is then mapped to a vector — a list of (typically) a few thousand numbers. This vector is the token's embedding: its location in a high-dimensional "meaning space." The crucial property: tokens with related meanings end up near each other in this space.

Position

Here's a wrinkle most explanations skip too long: by themselves, embeddings don't tell the model which token came first. "Dog bites man" and "man bites dog" would look identical to the model. So position information has to be injected separately — either added to the embedding, or (in modern models) baked into the attention mechanism via a trick called RoPE (rotary positional embedding).

2. Tokens have a group chat: attention

Now we have a sequence of position-aware vectors. The next problem: how does each token know what other tokens in the sequence say? In "The cat sat on the mat because it was warm", what does "it" refer to — cat or mat? The model needs a way for tokens to look at each other.

That mechanism is attention. For every pair of tokens (A, B), attention computes a score: how much should A pay attention to B when refining its own meaning? Then A updates itself by taking a weighted average of all the other tokens, weighted by those scores.

Multi-head attention

A single attention computation captures one kind of relationship at a time. So real models run attention several times in parallel, with different learned Q/K/V projections. Each parallel run is a head. One head might learn to track grammatical subject-object relationships. Another might track "what entity is this pronoun referring to?". Another might track distance ("which word came right before me?"). The heads' outputs are concatenated and mixed.

3. Same conversation, sixty times in a row: the transformer block

One round of attention isn't enough. Modern LLMs stack the same operation dozens of times — Llama 3 70B has 80 layers; GPT-4 is reportedly more. Each layer is called a transformer block, and each block does roughly the same thing:

1. Attention — tokens look at other tokens (as in §2)
2. Add & norm — the result is added back into the running representation, then normalized
3. MLP — each token, on its own, runs through a small feed-forward neural network: think of it as the token "thinking privately" about what it just heard
4. Add & norm — again

The output of one block becomes the input of the next. Repeat N times.

The residual stream

Each block doesn't replace the token's vector — it adds to it. The vector flowing up through all the layers is called the residual stream. Every layer reads from it, computes a contribution, adds the contribution back in, and passes it on. Nothing is erased; everything is elaborated.

4. From hidden state to next token: the full inference loop

We've walked through the inside of the model. Now let's walk the full loop end-to-end — input text to next token to next next token. This is the part most explanations leave fuzzy.

One full pass produces one token. To produce a paragraph, the loop runs hundreds of times.

Prefill vs decode

The very first time you call the model, it processes your entire prompt in one parallel forward pass — every token at every layer at the same time. This is the prefill phase. It's expensive but parallel-friendly.

After that, every new token requires its own forward pass: feed in just the new token, get one new token out. This is decode, and it's serial — token N+1 depends on token N existing first. This is why streaming responses appear word-by-word, and why you pay different prices for input and output tokens.

The KV cache

If decode just kept re-running the whole forward pass over the entire sequence for every new token, it would scale terribly — generating 1,000 tokens would mean a thousand passes over a sequence that grows each time. The trick: most of the work for past tokens doesn't change. Their K and V vectors (from §2) can be cached and reused.

So during decode, the model only computes Q, K, V for the new token. The new token's Q attends over all the cached past K's and V's. Past tokens are never recomputed — but they're still attended over. That's the KV cache.

5. Four lenses for thinking about LLMs

Before we look at training and the levers, here's a sorting framework. When something interesting (or broken) happens with an LLM, it's almost always one of four categories. Confusing them is the single most common source of wrong diagnoses.

Why this matters

Same complaint, very different fixes:

• "The model gave a different answer this time." → decoding (temperature). Set temp=0.
• "The model forgot what I said earlier." → almost always context (rolled out of window) or scaffolding (history not passed in). Almost never the model itself.
• "The model is confidently wrong about a fact." → likely weights (it never knew). Fix with retrieval (scaffolding) or fine-tuning (weights).
• "The model ignored my tool definition." → scaffolding (your tool description) or weights (model wasn't trained well for tool use). Almost never decoding.

6. How a model goes from "predicts the internet" to "answers your email"

Everything above describes how the model runs. Now: how does a model become any good in the first place? Modern LLMs go through three roughly distinct training stages — and each stage shapes the model in a different way. weights

Pretraining

Take an enormous pile of text — hundreds of billions to trillions of tokens scraped from the internet, books, code, papers. Train the model to do one thing: predict the next token. For every token in the corpus, ask "given everything before, what's the next one?" and nudge the weights to be a little less wrong each time. Repeat for weeks on thousands of GPUs.

What emerges, surprisingly, is not just next-token prediction — it's understanding. To predict the next word in a math problem, the model has to learn arithmetic. To predict the next line in a code file, it has to learn programming. To predict the next sentence in a story, it has to learn narrative structure. Capability is a side effect of really good prediction.

Supervised fine-tuning (SFT)

A pretrained model is a strange creature: ask it "What is the capital of France?" and it might continue "is a question often asked in geography classes…" — because that's a plausible internet continuation. To make it answer questions instead of continuing them, train it on a curated dataset of (prompt, ideal-response) pairs. Same loss function as pretraining; just very different data.

RLHF / DPO

SFT teaches the model what helpful answers look like, but it can't teach preferences — concise vs verbose, careful vs confident, this style vs that style. So a final stage shows the model pairs of its own outputs and tells it which one humans preferred, then nudges it toward producing more of the preferred style. Reinforcement Learning from Human Feedback (RLHF) does this via a reward model; Direct Preference Optimization (DPO) does it more directly without a separate reward model. Either way, the model learns the judges' taste.

7. How do we know a change helped?

Every lever we're about to discuss is a change to the model or the system. Fine-tuning, quantizing, extending context, swapping decoding settings — each one is supposed to make things better. How do we tell? That's evaluation.

There's no single right answer. Different evals measure different things, and all of them have known holes:

• Perplexity — how well the model predicts held-out text. Cheap to compute. Measures raw prediction quality but not instruction-following, helpfulness, or safety.
• Multiple-choice benchmarks (MMLU, ARC, GSM8K) — a battery of test questions. Easy to score, easy to game. Often contaminated: the test questions leak into training data, so high scores don't always mean real capability.
• LLM-as-judge (MT-Bench) — one model grades another's outputs against criteria. Cheap and fast. Biased toward the judge's preferences.
• Preference / arena (LMSYS Chatbot Arena) — humans pairwise-rank outputs from two anonymous models. Captures real-world taste. Slow, expensive, hard to attribute scores to specific capabilities.

The crucial pairing: each lever needs a matching eval. Quantize? Run perplexity + your task eval before/after. Fine-tune? Preference plus a held-out general eval (so you catch forgetting). Extend context? Long-context retrieval probes like Needle-in-a-Haystack. Without a matched eval, you're shipping a change blind.

Picking a model is rarely "look at one number." It's a basket of evals plus your own task-specific testing plus, honestly, vibes. Eval doesn't change the model — it's how you measure changes from any of the other lenses.

8. Knobs you can turn after the model is trained

Once a model exists, you have several distinct ways to change what it does. Each one touches a different lens.