What Is an LLM (Large Language Model)? (2026)

Skim to the part you need:

1. A plain-English definition.

2. Tokens — how text becomes something the model can process.

3. Next-token prediction — the one objective behind everything.

4. Training — pretraining and alignment, at a high level.

5. Inference — what happens when you send a prompt.

6. Why LLMs hallucinate (and what that means for you).

7. The 2026 model landscape — GPT-5.x, Claude 4.x, Gemini 3.x.

8. FAQs and Sources & further reading.

Provider pricing and model facts are tied to official pages, linked with dates in the final section.

'Large language model' breaks down literally. **Language model** — a system that assigns probabilities to sequences of words, and so can predict or generate text. **Large** — these models have many billions of parameters (the adjustable numbers learned during training) and are trained on enormous text datasets.

What makes modern LLMs powerful is scale plus an architecture called the Transformer, which uses an 'attention' mechanism to weigh how much each part of the input matters to each other part. You don't need the math to use them, but the key consequence is that an LLM reads your entire prompt in context and predicts a continuation that fits it.

Importantly, an LLM is not a database and not a search engine. It doesn't store and retrieve facts verbatim; it stores statistical patterns learned from text. That's why it can write fluently about almost anything — and also why it can state something false with total confidence. We come back to that below.

LLMs don't process raw letters or whole words — they process tokens, which are common chunks of text. A token might be a whole short word, part of a longer word, a space, or a punctuation mark. The model converts your text into a sequence of tokens, does its work on those, and converts tokens back into text for the output.

A useful rough estimate, per the major providers' documentation, is that **1 token is about 4 characters, or roughly 0.75 words in English** — so 1,000 tokens is on the order of 750 words. This is approximate and varies by language and content.

Tokens matter practically for two reasons. First, pricing: API costs are charged per token (input and output), so a longer prompt or response costs more — see the live pricing pages linked at the end. Second, context limits: every model has a maximum number of tokens it can consider at once (its context window), covered in our what is a context window explainer. For the token concept itself, see what is a token in AI.

Here's the core idea that explains almost everything an LLM does. Given a sequence of tokens, the model outputs a probability distribution over what the next token should be. It picks one (with some randomness controlled by settings like temperature), appends it, and repeats — generating text one token at a time.

That's it. Writing an essay, answering a question, and producing code are all the same operation under the hood: predict the next token, over and over, conditioned on the prompt and everything generated so far. The reason this produces useful behavior is that to predict the next token well across trillions of examples, the model had to internalize grammar, facts, reasoning patterns, and style.

This framing also explains why prompts matter so much: you're setting up the context that conditions every next-token prediction. A clearer, more specific prompt steers the distribution toward better continuations. That's the practical bridge our how LLMs work for prompt writers guide builds on.

LLMs are built in stages. **Pretraining** is the big one: the model is trained on a massive corpus of text to predict the next token. Across this process it adjusts billions of parameters until it's good at the prediction task — and in doing so absorbs broad knowledge and language ability. The foundational scaling insight that bigger models trained on more data become capable few-shot learners traces to work like Brown et al., 2020 (GPT-3) — arXiv:2005.14165.

**Alignment / fine-tuning** comes next. A pretrained model predicts plausible text but isn't necessarily helpful or safe. Additional training — including instruction tuning and learning from human (and AI) feedback — shapes it into a helpful assistant that follows instructions and declines harmful requests. This is why a deployed chatbot behaves differently from a raw next-token predictor.

A key consequence of pretraining: the model's knowledge is frozen at its training cutoff. It doesn't automatically know about events after that date unless it's given live tools (web search) or fresh context in the prompt. That's also why retrieval and prompting matter — see our fine-tuning vs prompting guide for how teams add behavior or knowledge after pretraining.

Inference is the model in use — generating output for your prompt. Your text is tokenized, fed through the network, and the model produces the next-token distribution; a token is sampled, appended, and the process repeats until it hits a stop condition or a length limit. This is why responses can 'stream' in word by word: they're literally being generated token by token.

Two run-time settings you'll meet often: **temperature** and **top_p** control randomness. Lower temperature makes the model pick high-probability tokens (more focused, repeatable); higher temperature allows more variety (more creative, less predictable). Provider API references document these — see OpenAI's API reference. Our temperature and top-p explained covers when to adjust them.

Inference cost scales with tokens in and out, which is why long prompts and long outputs cost more, and why techniques like prompt caching (reusing processed context cheaply) exist. The pricing pages linked at the end show current per-token rates.

Because an LLM generates statistically plausible text rather than retrieving verified facts, it can produce confident, fluent statements that are simply wrong — commonly called hallucinations. The model isn't lying; it's predicting a likely-sounding continuation, and sometimes the most likely-sounding thing isn't true.

This is a structural property, not a bug you can fully prompt away. You reduce it — ask for sources, give the model the reference material in context, let it use search tools, and verify anything that matters — but you don't eliminate it. Treat LLM output as a capable draft to check, not an oracle.

For prompting techniques that lower hallucination risk, see our reducing AI hallucinations guide. The practical rule: never rely on an unverified factual claim from an LLM for anything consequential.

Trust LLM output directly when: the task is generative or low-stakes — drafting, brainstorming, rephrasing, summarizing text you provide — where you can judge the result yourself.
Verify before relying when: the output is a factual claim, a citation, a number, code that touches production, or anything where being confidently wrong has real consequences.

As of June 2026, three providers dominate the frontier, each with a model family spanning a powerful flagship and cheaper, faster smaller tiers. Pricing below is per 1M tokens (input / output) from the official pages — confirm current figures before relying on them.

**OpenAI — GPT-5.x family.** Flagship gpt-5.5 ($5.00 / $30.00) and gpt-5.5-pro ($30.00 / $180.00); cost-efficient gpt-5.4 ($2.50 / $15.00) and smaller gpt-5.4-mini/nano; a coding-tuned gpt-5.3-codex; plus image (gpt-image-2) and video (Sora-2). Source: OpenAI pricing.

**Anthropic — Claude 4.x family.** Claude Opus 4.8 (flagship, $5 / $25), Sonnet 4.6/4.5 (balanced, $3 / $15), and Haiku 4.5 (fast/cheap, $1 / $5), with a 1M-token context window on recent models. Source: Claude pricing and API pricing detail.

**Google — Gemini 3.x family.** Gemini 3.1 Pro ($2.00 / $12.00 at ≤200k context), 3.5 Flash ($1.50 / $9.00), and 3.1 Flash-Lite ($0.25 / $1.50), plus the 2.5 line, all deeply integrated with Google's products. Source: Gemini pricing.

The pattern across all three: pick the flagship for hard reasoning, a mid tier for everyday work, and a small/fast tier for high-volume simple tasks. The table summarizes representative options.

Claims above are tied to these sources — confirm current details at the originals:

OpenAI — API pricing and API reference (temperature/top_p) (accessed June 2026).

Anthropic / Claude — pricing and API pricing detail (accessed June 2026).

Google Gemini — pricing (accessed June 2026).

Foundational research — Brown et al., 2020, 'Language Models are Few-Shot Learners' (GPT-3): arXiv:2005.14165. Chain-of-thought reasoning — Wei et al., 2022: arXiv:2201.11903.

On-site reading: how LLMs work for prompt writers, what is a token in AI, what is a context window, and reducing AI hallucinations.