Glossary
Large language model (LLM)
A large language model is software trained on enormous amounts of writing to continue text convincingly, predicting what comes next one small piece at a time, which is what lets it answer questions, draft documents and hold a conversation.
In plain terms
It is a very well-read machine that finishes your sentences. Show it the beginning of anything and it produces a plausible continuation, and because plausible continuations of a question look like answers, the same trick covers drafting, summarising and explaining. Nothing is being looked up and nothing is being reasoned about in the way a person would.
Why it matters
Almost every AI product you will meet at work is one of these with a different interface bolted on. The chat window, the writing assistant inside your documents, the support bot on a supplier's website and the coding helper in an editor are largely the same kind of software addressed differently. That is worth knowing because it means their strengths and their failure modes travel together: all of them are fluent, all of them are fast, and all of them will produce something confident and wrong when they have nothing good to draw on. Understanding the one mechanism underneath tells you more than learning each product separately.
How it works
The training runs in two broad stages. In the first, the software reads an enormous quantity of text and is repeatedly asked to guess the next piece, scored on how close it came. Doing that billions of times pushes it towards internal settings that make good guesses. The by-product of guessing well across that much material is a working grasp of grammar, facts as they appeared in the text, styles of argument and the shape of most kinds of document.
The second stage teaches it to be useful rather than merely fluent. People supply examples of good answers, and rank competing answers so the software learns which sort is preferred. This is what turns a text continuer into something that responds to instructions, declines certain requests and adopts a helpful register. A model that has only had the first stage will happily continue your question with three more questions, because that is what the text it read tends to do.
In use it works strictly forwards. It reads everything it has been given, produces a score for every piece of text that could plausibly come next, picks one, appends it, and reads the whole thing again. There is no plan, no draft and no revision pass unless the surrounding product adds one. What looks like structured thinking is the accumulated effect of each small choice being made in the light of all the choices before it.
Everything it can see at once has to fit inside a fixed budget, and everything outside that budget effectively does not exist for the current answer. Your files, the earlier turns of the conversation and any instructions the product set are all competing for the same space. This is the usual reason a long session starts producing worse answers than a short one.
What it knows is what it read, frozen at the point training stopped. It has no awareness of events since, no access to your systems, and no way to check a claim unless the product around it gives it one. Where recent or private material matters, the product supplies that material as part of the request rather than the model having known it.
Two stages, in the order they happen
Seen in the wild
Ask a general assistant to turn rough meeting notes into a structured summary, then ask it to rewrite the same summary for a customer. The second version is the same trick as the first.
ChatGPTPaste a long document into an assistant built for large volumes of source material and ask what it argues, which is the same continuation mechanism applied to a much bigger reading window.
ClaudeSend one prompt to several model families through a single routing interface and compare the replies, which makes the family-to-family differences concrete rather than theoretical.
OpenRouterDownload a published model and run it on your own machine, where the same mechanism operates with nothing leaving the hardware.
Ollama
Common misconceptions
People assume
It looks things up when it answers.
In fact
By default it does not. It produces a continuation from patterns learned in training, which is why it can be fluent and wrong at once. Products that do look things up are combining the model with a search or retrieval step, and that is an addition to the model rather than something it does on its own.
People assume
A bigger model is always the better choice.
In fact
Larger models are generally more capable and reliably slower and more expensive to run. Plenty of everyday work, classifying a message, extracting fields from a form, tidying prose, is handled well by a smaller one at a fraction of the cost and wait. Matching the size to the task beats reaching for the largest available.
People assume
It remembers our previous conversations.
In fact
The model itself remembers nothing between requests. Any continuity you experience is the product resending earlier turns, or storing notes and re-supplying them. Where that feature is absent, each conversation genuinely starts from nothing.
Telling them apart
Large language model vs AI
Large language model
One specific kind of system: trained on text, works by predicting what comes next, and produces language. It is the thing underneath the general-purpose assistants people now use daily.
The umbrella over the whole field, including things that have nothing to do with language: fraud scoring, image recognition, route planning, recommendation. Decades of it predate anything that writes prose.
If it writes back to you in sentences, a language model is almost certainly involved. If it silently sorts, scores or spots something, it is probably a different kind of system entirely.
Large language model vs Foundation model
Large language model
Named for what it handles: language. The category is defined by the medium, so a model that only reads and writes text is squarely one of these.
Named for how it is used: a large general-purpose model trained once and then adapted to many downstream jobs. The category is defined by the role, and covers models for images, audio and code as well as text.
The two overlap heavily and most large language models are foundation models. Reach for the second term when the point you are making is about reuse across tasks rather than about text.
Questions
- What does the large in large language model refer to?
- Both the quantity of text it was trained on and the number of internal settings adjusted during that training. Neither is a formal threshold, so the word is descriptive rather than technical. In practice it separates the current generation from earlier language software that handled narrow tasks like spell-checking or simple classification.
- Does a large language model understand what it is saying?
- It has a working grasp of how language behaves and of regularities in what it read, which is enough to produce accurate and useful answers on plenty of subjects. Whether that constitutes understanding is genuinely disputed among researchers. For practical purposes, treat it as a system whose output must be checkable rather than trusted.
- Why does it sometimes state things that are wrong?
- Because its job is producing a plausible continuation, and plausible is not the same as true. When the training material was thin, contradictory or absent on a subject, the most plausible-sounding continuation can be an invention. The output carries no signal distinguishing the two, which is why the confident tone is not evidence.
- Can it use my company's own documents?
- Not by itself. It knows only what it read during training. Getting it to work from your material means supplying that material as part of the request, which is what document upload, connected knowledge bases and retrieval features do. The model reads what it is handed rather than reaching for anything.
- How do I choose between the models a product offers me?
- Start with the cheapest one that clears your quality bar on a sample of your own work, not on a demo. Larger models earn their cost on ambiguous, multi-step or high-stakes tasks. For classification, extraction and tidying prose the difference is often invisible while the cost and the wait are not. Re-test when a product changes its lineup.
- Is a chatbot the same thing as a large language model?
- No. The model is the engine; the chatbot is one product wrapped around it. The same engine also powers writing assistants inside documents, coding helpers in editors and features with no conversation at all. Recognising the shared engine explains why such different products fail in the same characteristic ways.
Key takeaways
- It is trained to continue text, and answering is that same continuation applied to a question.
- Training gives it a broad grasp of language and of what it read, frozen at the point training stopped.
- It works forwards one piece at a time, with no plan and no revision unless the product adds one.
- Everything it can see at once shares a fixed budget, which is why long sessions degrade.
- Most AI products you meet at work are this one mechanism behind different interfaces.
Tools that use this
- ChatGPT
The assistant that made this kind of model familiar to a general audience.
- Claude
Large reading window, so the fixed-budget constraint is visible at a bigger scale.
- OpenRouter
One interface across many model families, which makes family differences concrete.
- Ollama
Runs published models on your own machine, where the mechanism is the same and nothing leaves it.
Last checked July 2026