A large language model (LLM) is an AI system trained on a huge amount of text whose core skill is predicting what text comes next — done so well, at such a large scale, that the predictions turn into writing, answering, summarising, translating and coding. “Large” refers to two things at once: the sheer volume of text it learned from, and the billions of internal settings, called parameters, that store what it learned. When you chat with a tool like ChatGPT or Claude, you are not talking to a database or a search engine. You are prompting an LLM, and everything it says is generated, one small piece at a time, from patterns absorbed in training.

This article explains that in full: what each word in the name means, how next-token prediction produces a paragraph, what tokens, embeddings and parameters are, where training ends and your conversation begins, examples you already know, how an LLM differs from “AI” as a whole, and what these models cannot do.

LLM meaning, word by word

  • Model. A model is a trained pattern, stored as numbers. After training, the model is the finished artefact: you give it an input, its numbers do their work, and an output comes out. Training is the expensive part; using the model afterwards is called inference.
  • Language. The model’s material is human language — chiefly text. It learns how words follow each other, how a question differs from an instruction, how code differs from poetry. Some newer models also handle images and audio alongside text, but language remains the core.
  • Large. There is no official line where a language model becomes “large”: the word describes scale, not a separate species. As NVIDIA’s glossary puts it, large language models are deep learning algorithms that can recognise, summarise, translate, predict and generate content using very large datasets. In practice, “large” today means trained on internet-scale text and carrying billions — in the biggest cases, hundreds of billions or more — of parameters.

IBM’s definition is a good one to keep: LLMs are a category of deep learning models trained on immense amounts of data, making them capable of understanding and generating natural language and other types of content to perform a wide range of tasks. Note the phrase “understanding” — its limits are covered below.

How LLMs work: predicting the next token

Strip away the size, and an LLM does one thing: given some text, it works out how likely each possible next piece is, picks one, adds it to the text, and repeats. IBM describes LLMs exactly this way, as giant statistical prediction machines that repeatedly predict the next word in a sequence, learning patterns in text and generating language that follows those patterns.

A tiny example shows why this is more powerful than it sounds. Give a model the text “The capital of France is” and the most likely next piece is ” Paris” — not because the model looked anything up, but because in its training text, that sequence was overwhelmingly followed that way. Now extend the trick: a system that can reliably continue any text can continue a question with an answer, an instruction with a completed task, half a program with working code, and a conversation with a plausible reply. Answering, writing and coding are all, mechanically, continuing text well. That is the whole engine. Everything impressive — and everything unreliable — about LLMs follows from it.

Two consequences matter for everyday use. First, the model does not plan the finished answer and then write it down; it commits piece by piece, which is why a reply can start confidently and wander. Second, because output is built from likelihood rather than lookup, the same prompt can produce different answers on different runs — Google makes the same point, noting they are prediction engines, not databases or deterministic retrieval systems, so they can create different outputs in response to the same prompt.

Tokens: the pieces the model actually sees

An LLM does not read letters or whole words. Before anything else happens, text is split into tokens — small chunks that are often a word, part of a word, or a punctuation mark. “Unbelievable” might be several tokens; ” the” (with its space) is commonly one. Tokenisation lets the model handle rare and invented words by assembling them from familiar pieces, and it explains several limits:

  • Context windows are counted in tokens. The context window is how much text the model can consider at once — your prompt, the conversation so far, and any document you pasted. When a chat “forgets” the start of a long conversation, the early tokens have usually fallen out of the window. File and length limits in chat products come from this same token economy.
  • Costs are counted in tokens. Services that charge for model use typically meter input and output tokens, which is why long documents cost more than short ones.
  • Odd failures are token failures. Models can stumble on spelling, letter counting and rhymes partly because they see tokens, not letters — the word as you see it is not the unit the model works with.

Once split, each token becomes a list of numbers — an embedding. IBM defines vector embeddings as numerical representations that express data such as words as an array of numbers a model can process, while still capturing the original meaning. Tokens used in similar ways end up with similar numbers. That is how the model treats “king” and “queen” as close, and “king” and “cabbage” as far apart, without anyone writing those rules down.

Parameters: where the learning is stored

If tokens are the model’s alphabet, parameters are its memory of training — billions of numbers, adjusted again and again during training, that together encode the patterns of the training text. When training data says, in effect, “after a question about a capital city, a city name is likely,” that adjustment is not stored as a sentence anywhere. It is spread across tiny changes to many parameters. A parameter count is therefore a rough measure of capacity: more parameters can hold finer patterns, at the cost of more computing power to train and run. It is not a quality guarantee — a well-trained smaller model routinely beats a poorly trained larger one.

The transformer: the design that made scale work

Almost every modern LLM is built on one architecture, the transformer, introduced by Google researchers in 2017. NVIDIA’s glossary summarises it as a neural network that learns context and meaning by tracking relationships in sequential data, like the words in a sentence. Its key mechanism is attention: as the model processes each token, it weighs which other tokens matter most to this one. In “The animal didn’t cross the street because it was too tired,” attention is what ties “it” to “animal” rather than “street.” Earlier designs read text strictly in order and forgot distant context; transformers consider relationships across the whole window at once, which made training on truly huge collections practical.

Training, then tuning, then your prompt

An LLM’s life has distinct stages, and confusing them causes most misunderstandings about what the model “knows.”

Pretraining is the giant stage. The model reads enormous collections of text — books, articles, websites, code — with a simple self-teaching task: hide a token, guess it, check, adjust. No person labels the answers; the text itself supplies them, which is why this stage can scale so far. Pretraining fixes a knowledge horizon: the base model has read nothing published after its training data was gathered, and it cannot browse unless a product connects it to tools.

Fine-tuning comes after, on far smaller, curated sets. In instruction tuning, the model is trained on instructions paired with good responses, so the raw text-continuer becomes something that follows requests. In reinforcement learning from human feedback, people rank alternative answers and the model is adjusted toward the preferred ones — which shapes helpfulness and tone, and why models share a certain polite house style.

Inference is your turn: the finished model, parameters frozen, generating token by token in response to your prompt. Nothing you type in an ordinary chat retrains the model. The next user gets the same frozen model you did.

Microsoft’s developer guide describes the same division from the application side: generative AI models are trained on large sets of content, and use the patterns identified in that training data to produce new, statistically similar content when you prompt them. “Statistically similar” is the honest core of it — new text, built to resemble the patterns of old text.

Examples of LLMs

Well-known LLMs and model families include OpenAI’s GPT family (behind ChatGPT), Anthropic’s Claude family, Google’s Gemini family — and its earlier BERT and PaLM models — and Meta’s Llama family, which is released openly for others to run and adapt. IBM likewise points readers to Claude, ChatGPT, Microsoft Copilot, Meta’s Llama models and Google’s Gemini as the public faces of LLMs. If you are choosing between the two best-known chat products rather than studying the technology, Claude vs ChatGPT compares them directly.

A product may add web search, file handling, memory and safety filters around the same underlying model, so two products can behave very differently while sharing LLM technology underneath.

AI vs LLM: what is the difference?

This is the most common mix-up, and it mirrors the nesting explained in AI vs machine learning. AI is the whole field. An LLM is one specific kind of AI system — a deep learning model, trained on language, that generates text by prediction. Many AI systems are not LLMs at all: a spam filter, a face-recognition system, a recommendation engine and a chess engine are all AI, and none is a language model. Conversely, everything an LLM does is AI, but calling an LLM simply “the AI” hides the mechanism — and the mechanism, next-token prediction, is exactly what explains both its fluency and its failures.

A useful shorthand: AI is the goal, machine learning is a method (learning patterns from data), deep learning is a technique within it (large layered networks), and an LLM is one product of that technique, specialised for language. Generative AI — systems that create new content — is the wider family the LLM belongs to on the output side, covered in what is generative AI.

What LLMs cannot do

A clear-eyed list of limits is part of the definition:

  • They do not look facts up. An LLM generates what is likely, not what is verified. It can state a falsehood in perfect, confident prose because false and true statements can be equally plausible as text. This failure has its own name and article: what is AI hallucination. Google’s own explainer concedes the point plainly: LLMs do not inherently understand the words they are generating or their accuracy, which is why they can produce answers that sound plausible but contain factual errors.
  • They do not know current events by themselves. Without a connected search or data tool, the model’s world ends at its training horizon, and it rarely volunteers that a question falls beyond it.
  • They do not reason like a person, even when the text looks like reasoning. The model produces reasoning-shaped text because such text was useful in training. It can follow multi-step patterns impressively, and still fail a simple problem whose wording differs from familiar patterns — fluency is pattern mastery, not understanding in the human sense.
  • They cannot cite their real sources, because there usually isn’t one. An answer is blended from patterns across millions of texts; when a model produces a neat reference list, the references themselves are generated text and must be checked.
  • They inherit the flaws of their training text. Biases, errors and outdated views in the data can surface in outputs, softened but not removed by fine-tuning.
  • They do not remember you between separate products or sessions unless the product adds a memory feature around the model — the model itself, frozen at inference, carries nothing from your last chat into the next one.

None of this cancels the usefulness. It defines the safe way to use it: draft with the model, verify against real sources.

Frequently asked questions

Is ChatGPT an LLM? ChatGPT is a product built on LLMs from OpenAI’s GPT family. The product adds a chat interface, and depending on the version, tools such as search or file handling; the LLM underneath is the text-generating model.

What is the difference between an LLM, GPT and a chatbot? An LLM is the category: a large model trained on text to predict the next token. GPT is one family of LLMs — OpenAI’s, named for “generative pre-trained transformer.” A chatbot is a product: an LLM wrapped in a conversation interface, sometimes with search, memory or file tools added. A chatbot may run on an LLM, and that LLM may be a GPT — three words at three different levels, which is why they get swapped so often.

Is an LLM the same as generative AI? No — an LLM is one kind of generative AI, the kind that works in language. Image, audio and video generators are generative AI too, but they are not LLMs.

Why do LLMs sometimes make things up? Because their job is to produce the most plausible continuation, not a verified one. Where training patterns are thin or conflicting, plausible invention fills the gap — fluently, with no warning label.

Does a bigger model always answer better? Not always. Parameter count measures capacity, not training quality. Data quality, fine-tuning and the product around the model all matter, and smaller recent models often outperform larger older ones.

This article is general information, based on the official explainer pages of IBM, NVIDIA, Google and Microsoft linked above and checked in November 2026. Model families change quickly — the mechanism described here, prediction over tokens with parameters learned in training, is the stable part.