What Are Large Language Models?

Large language models (LLMs) are the engines behind tools like ChatGPT and Claude. Ask around and you'll hear two confident stories: one says these systems "think," the other says they'll replace everyone by next quarter. Both are selling something.

This guide skips the pitch and shows you the machine. You don't need any math or coding background. By the end, you'll understand what an LLM actually does, why it can feel so smart, and why it sometimes states a wrong answer with a completely straight face. One simple idea explains all of it, so let's start there.

The one thing an LLM does

Strip away the branding and an LLM does exactly one job: given some text, predict what comes next.

That's it. You give it a run of words, and it guesses the most likely continuation, one piece at a time. People call this "fancy autocomplete," and that's directionally right, just badly undersold. The autocomplete on your phone guesses the next word from the last two or three. An LLM runs that same guessing game after reading a huge slice of the public internet, books, and code. The idea is the same; the scale is so different that it starts to behave like a different kind of thing entirely.

There's even a date for when this leap became possible. In 2017, a team at Google published a paper called "Attention Is All You Need," which introduced the transformer — the design that lets a model weigh how every word in a passage relates to every other word. Almost every modern LLM is built on it.

Takeaway: An LLM is a next-word prediction engine. Hold onto that one sentence; everything else in this article hangs off it.

What "predicting the next word" really looks like

The phrase "predict the next word" sounds almost too simple to matter, so let's slow it down with a sentence a five-year-old could finish.

(Developed example — a simple scenario.)

You type: "The capital of France is ___"

Here's what happens inside, in plain terms:

1. The model has read enormous amounts of text where the words "capital of France" are followed by "Paris." Not a database entry that says France → Paris, but millions of ordinary sentences that happen to pair those words.

2. So when it reaches the blank, it runs the numbers on what usually comes next. "Paris" scores far higher than "London," "Tuesday," or "banana."

3. It picks "Paris" and adds it to the sentence. Then it does the whole thing again to decide the word after that, and the word after that. It builds its answer one piece at a time, always asking the same question: what's likely to come next?

Notice what did not happen. The model never looked up a fact in a table. It never "knew" Paris the way you know your own address. It produced "Paris" because, across everything it read, that's the word that usually follows. Most of the time this works beautifully, because likely text and true text overlap a lot.

But watch where it breaks. Ask "The capital of the fictional country of Zandar is ___" and the model still has to predict something. There's no real answer, but its job isn't to stay silent — its job is to continue the text. So it may confidently invent a plausible-sounding city name and present it exactly as surely as it said "Paris." Same engine, same confidence, wrong answer. This is what people mean by a "hallucination": not a glitch, but the prediction machine doing precisely what it was built to do in a spot where likely text and true text part ways.

Takeaway: An LLM answers by predicting likely text, not by looking up stored facts. That single distinction is the most useful thing to remember, because it explains both the magic and the mistakes.

Prediction, not lookup — the idea worth keeping

That last point deserves its own moment, because it's the lens that makes an LLM's behavior stop feeling random.

An LLM is predicting likely text, not retrieving facts. When the likely words and the true words line up — capital cities, common definitions, well-worn explanations — it looks like a knowledgeable expert. When they drift apart — an obscure detail, a made-up premise, a very recent event it never read about — it can produce fluent, confident nonsense. Same machine, both times.

This is why "it sounds sure of itself" tells you nothing about whether it's right. Confidence is a feature of the writing style it learned, not a signal that it checked anything. Understanding this early saves you from the two classic beginner mistakes: trusting it blindly, or dismissing it entirely. If you want a fuller tour of what falls in that second bucket, see what LLMs can't do and why that matters.

Takeaway: Treat every answer as a very well-informed guess. Great starting point, not a final source — verify anything that actually matters.

Three words that explain the whole system

You'll meet three terms everywhere people discuss LLMs: tokens, training, and inference. They're just the three stages of the prediction machine — how it reads, how it learns, and how it answers. Here's each in plain English, then a table you can keep.

Tokens are the chunks a model reads and writes. They're often whole words, but longer words get split into pieces — "understanding" might become "understand" + "ing." The model's memory is measured in tokens, not sentences. When you hear a model has a "128K context window," that's roughly 96,000 words it can hold in view at once — a small book. Push past that limit and the earliest text quietly falls out of view, which is why a very long chat can seem to "forget" how it started.

Training is how the model learned to predict in the first place. It read an enormous body of text and adjusted itself, over and over, to get better at guessing the next token. This stage is expensive and slow — training a frontier model can cost on the order of tens of millions of dollars in computing power — and it happens once, in advance. The finished model is frozen; it isn't learning from your chat.

Inference is what happens every time you actually use it — the model running its prediction to generate a reply for you. It's fast and cheap compared to training, and it's the only stage most people ever touch.

Concept	Plain-English meaning	Why you'd care
Tokens	The word-chunks a model reads and writes; its memory is counted in these	A "128K context" ≈ 96,000 words; go past it and early text drops off, so it can "forget"
Training	The one-time, costly process where the model learned to predict, from lots of text	The model is frozen after training — it doesn't learn from your conversation or know today's news
Inference	The model running to answer your prompt, right now	This is every reply you get; it's fast, and it's where your wording steers the result

Takeaway: Tokens are how it reads, training is how it learned, inference is how it answers. Those three cover almost every LLM conversation you'll overhear.

Why the same engine can feel brilliant and be wrong

Put the pieces together and the odd behavior of these tools stops being mysterious.

Because it was trained on so much text, an LLM has seen countless examples of good explanations, clean code, and clear writing, so its predictions often land as genuinely helpful. Because it works only with tokens in a limited context window, it can lose the thread of a long document. And because every answer is inference — prediction, not lookup — it will sometimes fill a gap with something that merely sounds right.

None of this makes LLMs useless; it makes them predictable. Once you expect confident-but-unverified output, you use them the smart way: for drafting, explaining, brainstorming, and summarizing, with a human check on anything where being wrong has a cost. Your wording matters too — because the model is continuing your text, clearer prompts steer better predictions, which is the whole idea behind prompting 101: how to talk to AI.

Takeaway: The strengths and the failures come from the same mechanism, so the same rule handles both — lean on it for a strong first draft, and verify what counts.

Where LLMs fit in the bigger picture

An LLM is one important kind of AI, not the whole field. If you'd like to see how it fits alongside other approaches, what is artificial intelligence: a practical guide zooms out to the full map. And once you're comfortable with the basics, a natural next question is where the model should run — on your own machine or in the cloud — which comes with real tradeoffs in privacy, cost, and control, laid out in local vs. cloud LLMs: tradeoffs explained.

Takeaway: "LLM" is one powerful tool in a larger AI toolbox — knowing what it is makes the neighboring topics much easier to pick up.

What to remember

A large language model is a next-word prediction engine, trained once on a vast amount of text and then run, at inference time, to continue whatever you give it. It reads and writes in tokens, holds a limited window of them in view, and produces every answer by predicting likely text rather than retrieving stored facts. That one idea explains why it can be so useful and why it can be so confidently wrong — and it hands you a simple habit: use it freely for first drafts and explanations, and verify anything that has to be correct.

Sources

• Vaswani et al., "Attention Is All You Need," 2017 — the original paper introducing the transformer architecture behind modern LLMs. Published at NeurIPS; widely available via arXiv.

• The "capital of France" walkthrough and the Zandar example are illustrative scenarios written for this article to show how next-token prediction behaves; they are not records of a specific model run.

• Token counts (128K context ≈ 96,000 words) and training-cost figures (tens of millions of dollars) are given as rounded, order-of-magnitude ranges that vary by model; treat them as ballpark, not exact specifications.

Keep learning. This article is part of the Start Here path in the ShiftQuality Learning Center.