What an LLM Really Is

Welcome to the first episode of the NEXUS AI Literacy Series. The whole idea here is simple: by the end of this series, you'll be able to walk into any room — a boardroom, a classroom, a conversation with a skeptical client — and talk about artificial intelligence like someone who actually understands what's happening under the hood. Not buzzwords. Not hype. The real thing, explained in plain English.

So let's start at the very beginning, with the thing everybody's talking about and almost nobody can actually define: the large language model. The LLM. It's the engine inside ChatGPT, inside Claude, inside Gemini. And here's the funny part — the simplest honest description of what it does sounds almost insulting.

A large language model is, at its core, an extremely sophisticated autocomplete.

That's it. That's the secret. When your phone suggests the next word as you're typing a text message — "I'll be there in a..." and it offers "minute" — that's a tiny, dumb version of the exact same idea. A large language model is that same trick, except instead of being trained on your last few text messages, it was trained on a huge slice of everything humanity has ever written down. Books. Articles. Websites. Code. Conversations. Scientific papers. And instead of guessing one word at a time from a handful of options, it's weighing the probability of the next word against billions of patterns it has absorbed.

Now, when people first hear "it's just predicting the next word," they tend to relax a little. They think, oh, so it's a parlor trick. It doesn't really understand anything. And I want to push back on that gently, because this is where it gets genuinely interesting — and it's the single most important idea in this whole episode.

Here's the thing. To get really, really good at predicting the next word, the model is forced to learn something much deeper than just words. Think about it like this. Imagine I gave you a sentence and asked you to fill in the blank: "The defense attorney objected because the prosecutor's question was..." To fill that in well — to say "leading" or "out of order" — you don't just need to know which words usually come next. You need to understand courtrooms. You need to understand that there's a defense and a prosecution, that they're adversaries, that questions have rules. The only way to reliably predict that next word is to have built, somewhere inside you, a working model of how a courtroom actually operates.

That's what happened to the LLM, at an unimaginable scale. In the process of getting good at "guess the next word" across the entire internet, it was forced to build internal models of grammar, of logic, of cause and effect, of how a recipe flows, of how a legal argument is structured, of how Python code has to be indented. Nobody programmed those rules in. They emerged — automatically — as a side effect of the model relentlessly trying to predict what comes next, billions and billions of times. Understanding turned out to be the most efficient strategy for prediction.

Let me give you the analogy I like best for this. Imagine a brand-new employee who somehow has to do their entire job by listening at the door. They can't ask questions. They can't read the manual. All they can do is stand outside the office and hear the first half of every sentence, and they have to guess the second half. At first they're terrible at it. But they do this for years, for millions of conversations. Eventually, to survive, that person ends up understanding the business better than almost anyone — the clients, the deals, the personalities, the way a sentence that starts with "unfortunately" is going to end. They never got the manual. They reconstructed the entire world of that company just from predicting how sentences finish. That's an LLM. It reconstructed a working model of the world from the shape of our language.

Okay. So how does it actually do this? I'm not going to drown you in math — we'll go deeper on the machinery in later episodes — but I want you to have the right mental picture.

The model is a giant network of what we call parameters. You'll hear people throw around numbers — "this model has seventy billion parameters," "this one has four hundred billion." Don't let that intimidate you. A parameter is just a tiny adjustable dial. Picture a mixing board in a recording studio, but instead of a few dozen knobs, it has hundreds of billions of them. During training, the model reads a piece of text, tries to predict the next word, checks whether it got it right, and then nudges those billions of dials — just a hair — in whatever direction would have made its guess a little better. Then it does it again. And again. Trillions of times. That slow, patient tuning of billions of dials is what we call training, and it's where essentially all the cost and all the magic lives.

And here's a distinction that will instantly make you sound like you know what you're talking about: the difference between training and inference.

Training is the model going to school. It's that massive, expensive, months-long process of reading everything and tuning all those dials. It happens once, it costs millions of dollars, and it requires warehouses full of specialized chips. Inference is what happens every single time you actually use the model — every time you type a question and get an answer. Inference is the model taking the test. The dials are frozen now; it's just using what it already learned to predict its way through your specific question, one word at a time.

This is why, when you ask Claude or ChatGPT a question, you often see the answer appear word by word, almost like it's typing. That's not a visual effect to make it feel human. That's literally what's happening. It's predicting the next word, then feeding its own answer back into itself to predict the word after that, then the word after that — building the response one token at a time, in real time, right in front of you.

That word — token — is worth knowing, because you'll hear it constantly and it's a small thing that trips people up. A token is just a chunk of text the model works with. Sometimes it's a whole word, sometimes it's part of a word. The word "understanding" might be two tokens — "under" and "standing." A rough rule of thumb: a token is about three-quarters of a word. When you hear that a model has a "context window of 200,000 tokens," that just means it can hold roughly 150,000 words in its working memory at once — and we'll devote a whole episode to why that matters so much.

Now let me close the loop on the big idea, because I want this one to stick.

The reason this matters — the reason any of this is a revolution and not just a clever toy — is that for the first time we have a single system that absorbed a huge fraction of human knowledge and turned it into something you can simply talk to. You don't need to learn a programming language. You don't need to know where the information lives. You ask, in plain English, and a model that quietly built an internal map of how the world works gives you an answer drawn from that map.

But — and this is the honest, grown-up part — that same mechanism is exactly why these models can be confidently wrong. Remember, the core drive is to predict a plausible next word. It is not, at its heart, looking something up in a database of verified facts. It's generating what sounds right based on everything it absorbed. Usually what sounds right is right, because truth is the most common pattern in good writing. But when it isn't sure, it doesn't stop and say "I don't know" — it does what it always does, which is produce the most plausible-sounding continuation. We call that a hallucination, and it's not a bug they forgot to fix. It's the flip side of the very thing that makes the model so powerful. We'll spend a whole episode on that, because understanding it is the difference between using these tools wisely and getting burned by them.

So let's bring it home. What is a large language model, really? It's a system that learned to predict the next word so well that, in the process, it was forced to build a working model of language, logic, and the world — encoded across billions of tiny adjustable dials, tuned by reading a huge portion of everything we've ever written. It learns once, in training. It performs every time you use it, in inference. It thinks in tokens, one at a time. And its greatest strength — generating what's plausible — is also the root of its most famous weakness.

Hold onto that core image: not a database, not a search engine, not a person. An autocomplete that got so good it accidentally learned to understand.

In the next episode, we're going to zoom in on one of the most beautiful ideas in all of this — how the model turns words into numbers, into coordinates on a giant map of meaning. It's called embeddings, and once you see it, you'll never think about language the same way again.

That's Episode 1. I'm glad you're here for this. Let's keep going.