On this page
Read
The useful mental model
An LLM is a context-conditioned token predictor used repeatedly. It converts the available context into probabilities for the next token, selects a token, appends it, and runs again. Training shapes those probabilities; the surrounding product supplies current evidence, tools, limits, and validation.
In plain English
It predicts a useful next piece of language, adds that piece to the context, and repeats the process until it has produced a response.
Where builders use it
- 01Conversational assistants
- 02Summarization and structured extraction
- 03Drafting and code generation
Why it matters
An LLM can perform many language tasks through one general interface, but its output is generated from learned patterns and current context. Product reliability still depends on evidence, evaluation, validation, and the workflow around the model.
Why now
LLMs increasingly sit inside products that also retrieve documents, call tools, process long context, and enforce structured outputs. Builders therefore need to distinguish the language model from the larger application that supplies evidence and controls actions.
A common misconception
“Calling an LLM a next-token predictor means it behaves like simple phone autocomplete.”
Next-token prediction describes the generation mechanism. A large neural network can use extensive context and learned representations to perform many transformations, but that capability still does not guarantee factual or logically correct output.
See
See the mental model
The visual is generated from the same structured knowledge as the written explanation.
An LLM receives tokenized context, estimates probabilities for the next token, appends a selected token, and repeats that cycle until it produces a response.
Watch
Watch the explainer
A short visual explanation built from the same reviewed knowledge object.
Large Language Model: predict, append, repeat
See how tokenized context becomes next-token probabilities, how repeated prediction builds a response, and why the surrounding application must verify consequential claims.
Read transcript
A customer asks a support assistant if they can get a refund. A large language model writes the reply. It does not look the answer up. It predicts the next small piece of text, called a token. It reads the question and the refund policy, then scores which tokens could come next. One token is picked and added to the text. Then it predicts again. Repeat that many times, and a full reply appears. That is like phone autocomplete, but far more capable, because it uses much more context. Still, a fluent reply is not a verified one. So the application around the model supplies current evidence, checks key claims, and controls any action. The model writes the language. Your application decides what it is allowed to become.
Builder example
Draft a support answer without confusing fluency with truth
A support assistant receives a customer question and an approved policy passage, then asks an LLM to produce a concise answer.
Failure
The application treats the model's fluent response as a database lookup and displays a plausible exception that the supplied policy does not support.
Intervention
Give the model only the relevant policy evidence, require a structured answer with supporting excerpts, and validate consequential claims before displaying them.
Observable result
Supported answers include the policy evidence used, while unsupported requests produce an explicit uncertainty or review path instead of an invented rule.
Sources
Go deeper
- Google for Developers - Introduction to Large Language Models
- Google for Developers - What's a large language model?
Last researched 11 October 2026