What is a large language model?

A large language model, or LLM, is the technology behind chat assistants such as ChatGPT, Claude and Gemini, and behind a growing share of the software you use at work. This guide explains what an LLM is without the math, what it can and can't do, how it's trained, and the kinds you'll run into. By the end, you'll be able to read a model announcement and know what it actually means for you.

What an LLM is, in plain English

An LLM is a program that has learned to continue text. You give it some words, and it predicts the most plausible next piece of text, then the next, one small chunk at a time. Those chunks are called tokens; in English, a token averages about four characters, or roughly three-quarters of a word.

The "large" refers to two things. The model contains billions to trillions of internal numbers, called parameters, and it was trained on trillions of tokens of text. DeepSeek, for example, reports pretraining one of its 2026 models on 45 trillion tokens, more than a person could read in thousands of lifetimes.

Under the hood, an LLM is a neural network built on the transformer architecture, which Google researchers introduced in 2017. One idea matters more than the details: the model doesn't look facts up in a database. It generates text that fits the patterns it absorbed during training, which is why it can be fluent and wrong at the same time. Our guide to how LLMs work walks through the mechanics step by step.

What LLMs can and can't do

Because so much work runs through language, next-token prediction covers a surprising amount of ground. Modern LLMs are useful whenever the input or output is text, code or structured data, and the leading models also read images, audio and documents.

The pattern behind the table is simple. LLMs are strong at transforming and generating language, and weak wherever correctness depends on facts they can't see or calculations they can't check. Connecting a model to tools, such as web search, a calculator or your own database, closes much of that gap, which is why serious products wrap the model in software rather than using it bare.

How LLMs are trained

Training happens in stages, each building on the last. The early stage gives the model its knowledge, and the later stages turn a raw text predictor into a helpful assistant.

Pretraining

In pretraining, the model reads a vast mix of web pages, books, code and other text and repeatedly guesses the next token. Each wrong guess nudges its parameters slightly. This stage uses most of the computing budget, often months on thousands of specialized chips, and produces a base model that knows a great deal but simply continues whatever text you give it.

Instruction tuning

Next, the model trains on many examples of instructions paired with good responses, a step called instruction tuning or supervised fine-tuning. This teaches it the shape of a conversation: answer the question, follow the requested format, stop when done. The examples come from human writers and, increasingly, from other models.

Preference training

Finally, the model learns from comparisons. People, or AI judges following written guidelines, rank pairs of answers, and techniques such as reinforcement learning from human feedback (RLHF) or direct preference optimization (DPO) push the model toward the preferred style. OpenAI's 2022 InstructGPT paper showed how much this matters: evaluators preferred answers from a tuned 1.3-billion-parameter model over those from the original 175-billion-parameter GPT-3, a model more than 100 times larger.

Reasoning models add one more ingredient: reinforcement learning on problems with checkable answers, such as math and programming tasks. Rewarding correct final answers teaches the model to work through a problem step by step, which is why the newest models pause to "think" before replying.

The kinds of LLMs you'll meet

Model names rarely tell you what you're getting. Four distinctions explain most of the differences between them.

Base, instruct and reasoning models

A base model is the raw result of pretraining; it continues text and is mostly used by researchers and teams who fine-tune. An instruct, or chat, model has been through instruction and preference training, and it's what you talk to in apps. A reasoning model spends extra tokens working through a problem before it answers, which improves results on math, code and multi-step planning at the cost of speed and money.

The line between instruct and reasoning models is blurring. As of October 2026, most flagship models let you dial the amount of reasoning up or down per request instead of choosing a separate model.

Closed API models and open-weight models

Closed models, such as OpenAI's GPT-6 and Anthropic's Claude families, are available only as a service: you send text to the provider's servers and pay per token. Open-weight models, such as Google's Gemma, Alibaba's Qwen, DeepSeek's V4 series and OpenAI's gpt-oss, publish their parameters so you can run them on your own hardware. Open weights give you control and privacy, while closed models usually lead on raw capability and are easier to start with. Our guide to open-source vs closed LLMs covers the trade-off and the license fine print.

Text-only and multimodal models

Early LLMs read and wrote only text. Most current flagships are multimodal: they accept images, PDFs, audio or video alongside text. Check the output side carefully, because many models that read images still reply only in text.

Frontier and small models

Frontier models are each lab's largest and most capable systems, and they're priced accordingly. Small language models, from a few hundred million to a few tens of billions of parameters, are faster and cheaper and can run on a laptop or phone. For narrow jobs such as classification or extraction, a small model is often good enough, and it can cost one-hundredth as much per token.

Major model families as of October 2026

The lineup changes every few weeks, so treat this table as a snapshot from early October 2026 and check our model directory for current details. Prices are list prices in US dollars per million input and output tokens on each provider's own API.

Two patterns matter more than any single name. First, every major provider now sells a ladder of sizes, and at OpenAI and Anthropic the cheapest rung costs about 1% of the top one per token. Second, the strongest open-weight models, several of them from Chinese labs, have trailed the closed frontier by months rather than years, which gives you real alternatives when privacy or cost dominates.

Availability also varies within a family. As of early October 2026, for example, Google's Gemini 4 Argon wasn't yet listed among the models in its Gemini API documentation.

How to start using an LLM

There are three ways in, and most people should try them in this order. Each step gives you more control in exchange for more setup.

Chat apps

The quickest start is a chat app such as ChatGPT, Claude, Gemini, Grok or Meta AI, each available on the web and on phones, most with a free tier and paid plans. Paid plans raise usage limits and unlock the strongest models. If you use one for work, check whether your conversations may be used for training and whether your company has an approved business plan, which usually comes with stricter data terms.

APIs

To build an LLM into your own product, you call a provider's API: your code sends the prompt, and you're billed per token in and out. Most providers use similar request formats, publish SDKs for popular languages, and offer a batch API at roughly half price for work that can wait. Our LLM cost calculator estimates the monthly bill before you write any code.

Running a model locally

Open-weight models can run entirely on your own machine, so no data leaves it. Free tools such as Ollama and LM Studio handle the download and setup; with Ollama, the command ollama run gemma4:e4b fetches a small Google model and opens a chat in your terminal. Small models run on a recent laptop, while larger ones need a GPU with plenty of memory, and the VRAM calculator shows what fits.

Whichever route you take, a structured first week teaches you more than a month of casual use. Use this checklist as a starting point.

Key limits to plan around

Hallucination

LLMs sometimes state false things with complete confidence, a failure called hallucination. A 2025 paper by Kalai and colleagues argues that standard training and benchmark scoring reward confident guessing over admitting uncertainty, so the behavior is built into how models are optimized. Ground answers in sources you supply, ask for citations you can check, and keep a person in the loop where errors are costly.

Knowledge cutoff

A model knows only what was in its training data, which ends at a knowledge cutoff some months before release. Anthropic, for instance, lists June 2026 as the reliable cutoff for its current Claude models. Anything newer has to come from a search tool or from documents you provide, a pattern called retrieval-augmented generation (RAG).

Context limits

The context window is the maximum amount of text the model can consider at once, including your prompt, any documents and its own reply. As of October 2026, the current GPT-6 and Claude models and Google's Gemini 3.1 Pro and 3.8 Flash accept about one million tokens, roughly 750,000 words, though replies are capped far lower, at 64K to 128K tokens. Bigger isn't automatically better: long prompts cost more, run slower and can bury the detail you care about.

Cost

API pricing is per token, and output tokens cost several times more than input tokens. Consider a support assistant handling 10,000 conversations a month, each with 2,000 input tokens and 300 output tokens: that's 20 million input and 3 million output tokens. At $2 and $10 per million, the bill is $40 plus $30, or $70 a month; at $10 and $50 it's $350, and at $0.10 and $0.50 it's $3.50.

How to talk about LLMs: a mini glossary

These terms appear in nearly every model announcement and pricing page. Each links to a fuller entry in our glossary.

Common mistakes

Most early disappointments with LLMs trace back to a handful of avoidable errors. Each is easy to fix once you know to look for it.

• Treating fluent output as verified. Confident wording says nothing about accuracy, so check facts and citations.
• Asking about recent events without search. A model without a search tool can't know what happened after its cutoff.
• Choosing by leaderboard rank alone. A top-ranked model can be slower and 100 times pricier than one that handles your task just as well.
• Pasting sensitive data into consumer apps. Read the data terms first, or use a business plan or a local model.
• Assuming the same prompt gives the same answer. Outputs vary between runs and between model versions, so test before you depend on them.

Next steps

Once the basics click, go one level deeper. Read how LLMs work to see what happens between your prompt and the reply, then use how to choose an LLM to pick a model for a real project. If you'd rather start from a shortlist, the LLM picker asks a few questions and suggests models that fit your use case and budget, and if you want hands-on help with a first build, you can get expert help.