What is a large language model (LLM)?

A large language model is a neural network that uses transformer architecture and stores what it learns in parameters (i.e., the numeric weights that are adjusted during training). Transformer architecture detects dependencies between parts of a sequence regardless of how far apart they sit. That is what lets a model connect a pronoun to a noun several paragraphs earlier.

Large language models cover the range of natural language processing (NLP) tasks: sentiment analysis, conversational question answering, translation, classification, summarization, and generation. One model does all of them, because all of them reduce to predicting text.

You have probably already used one. ChatGPT, Claude, Gemini, and Microsoft Copilot are consumer and workplace products built on large language models, and the coding assistant in your editor most likely is, too. Behind each product sits the same pattern: a model trained on text, asked to continue text.

A large language model works by predicting one token at a time and then feeding its own output back in and predicting again. Each step feeds the next, so a change at tokenization changes everything downstream.

1. Tokenization: The tokenizer splits your input text into tokens: words, word fragments, or single characters. Models process numbers rather than characters, so each token maps to an integer index in a fixed vocabulary. Byte-pair encoding, the most common method for building that vocabulary, starts from individual characters and repeatedly merges the most frequent adjacent pair.
2. Embedding: Each integer index maps to an embedding vector: a list of numbers that positions the token relative to every other token the model knows.
3. Processing: The transformer layers process those vectors together and output a probability distribution over the entire vocabulary for the next token.
4. Sampling: A sampling step selects one token from that distribution. Settings such as temperature decide how strictly the model favors the highest-probability option.
5. Repetition: The selected token joins the input, and the loop runs again until the model emits a stop token or hits a length limit.

Everything the model can see while doing this lives in its context window, the maximum number of tokens it can hold at once. Anything outside that window is invisible to it.

The model predicts statistically likely continuations of text, and it has no internal check for truth. Fluency and accuracy are separate properties. A model can be wrong and still sound right, and that is where hallucination comes from.

A large language model is shaped at three points: pretraining, fine-tuning, and alignment, in decreasing order of cost and permanence.

• Pretraining is self-supervised and does the heavy lifting. The model reads books, articles, websites, and code; predicts masked or next words; and adjusts its weights by backpropagation when it gets them wrong. No human labels the data; the next word in the text is the label. This phase consumes most of the compute budget and produces a base model that knows language structure but follows no instructions.
• Fine-tuning continues training on a much smaller labeled dataset built for a task or a domain: medical notes, legal contracts, support tickets, one company's code. It adjusts the same weights, so the change is permanent, and a model trained on narrow data can drift away from general capability.
• Alignment turns a predictor into an assistant. In reinforcement learning from human feedback (RLHF), people rank alternative model responses. Those rankings train a separate reward model, and the language model is then tuned to score well against it. RLHF is why a modern chat model answers your question instead of continuing your sentence.

The quality of the data the model is trained on will reflect directly in the quality of the outputs it produces. Teams perform preprocessing to clean up the data before training begins, including deduplicating near-identical documents, striping boilerplate, and filtering low-quality or harmful text.

Training data also must stop at a certain date. That date is the model's knowledge cutoff, which means it can’t tell you about an event, a release, or a document that appeared afterward, including anything inside your own organization.

Scaling laws describe the predictable part of making a model bigger, and emergent abilities describe the unpredictable part.

• Scaling laws are empirical relationships linking compute, parameter count, and training tokens to a model's loss (a numerical value representing the errors it makes). Researchers analyzing the optimal model size and number of tokens for training language models found an influential result with the Chinchilla model, which reported that parameters and training data should grow together, and that several earlier headline models were undertrained rather than too small.⁴ Under that finding, a smaller model fed more tokens can beat a larger model fed fewer, for the same compute.
• Emergent abilities are capabilities absent in smaller models that appear abruptly once a model passes some size threshold, rather than improving gradually. Researchers originally claimed in a 2022 preprint that such jumps cannot be predicted from smaller models.⁵ But a later analysis pushed back, arguing that apparent emergence is largely an artifact of scoring with discontinuous, all-or-nothing metrics rather than a real property of the model.⁶ A separate study showed that some apparent emergence reflects in-context learning, where the model picks up the task from examples in the prompt, rather than a capability that appears abruptly at scale.⁷ Neither line of research settles the question.

For anyone choosing a model, the takeaway is practical: Capability does not scale smoothly with spend. Benchmark candidate models on your own task instead of extrapolating from a size number or a leaderboard.

Generative AI is the umbrella term for artificial intelligence models that create content of any kind, including text, code, images, video, and music. Large language models are the text-trained subset of that category. All LLMs are generative AI, but not all generative AI is an LLM.

Image generators make the distinction concrete. DALL-E and Midjourney produce pictures rather than text, and they rely on diffusion models: an architecture that learns to reverse the gradual addition of noise to an image. That is a different design from the transformer stack behind a text model.

Generic, instruction-tuned, and dialog-tuned models share the same underlying architecture but differ in how they were adapted after pretraining.

1. Generic or raw language models: A generic model predicts the next word from the distribution it learned in training, with no instruction-following behavior layered on top. It suits completion and retrieval-style tasks, and it is the starting point for the other two model types.
2. Instruction-tuned language models: An instruction-tuned model is trained to carry out the instruction stated in the prompt. That adaptation is what makes classification, summarization, and code generation work from a plain request.
3. Dialog-tuned language models: A dialog-tuned model is trained on multi-turn exchanges and predicts the next response rather than the next passage. Chatbots and conversational assistants run on this type.

Large language models handle any task that can be expressed as text in and text out, from enterprise search to code generation. Each task carries a different tolerance for error, and that tolerance is what decides whether a person must check the output before anyone sees it:

Large language models appear across industries.

• Tech teams use them to improve search responses and help developers write code.
• In healthcare and science, models analyze sequence data from proteins, DNA, and RNA to support research and vaccine development.⁸ Medical chatbots also handle patient intake and basic triage, which typically requires human oversight.
• Customer service runs chatbots and conversational AI.
• Marketing teams use them for sentiment analysis, content drafts, and campaign brainstorming.
• Legal staff search large document sets and draft filings.
• Banks analyze transactions and customer communications for signals of fraud, usually inside a broader detection system.

Related: How to make a chatbot: Dos and don'ts for developers

Large language models offer four advantages that older, task-specific NLP systems could not: breadth, adaptation without retraining, a natural-language interface, and speed to a working prototype.

1. One model, many tasks: A single pretrained model handles translation, summarization, classification, and generation. The previous approach needed a separate trained system, and often a separate labeled dataset, for each one.
2. Adaptation without retraining: In-context learning lets a model take on a new task from a few examples in the prompt, or from none at all. The cost of trying a new idea is writing a prompt rather than funding a training run.
3. Natural-language interface: People can query a system without learning its query syntax. That widens who can use it, from the analyst who knows SQL to the support agent who doesn’t.
4. Fast time to value: Pretrained hosted models are callable through an API on day one, with no training infrastructure to stand up. You can find out whether the idea works before you commit to any training hardware.

Large language models give the impression of understanding, but they need supervision. Six challenges apply to any deployment.

1. Hallucinations: A hallucination is a fluent, syntactically sound output that is factually wrong or unfaithful to its source. It follows directly from next-token prediction: The model optimizes for likely continuations, not true ones. In addition to keeping a person in the loop to spot inaccuracies, hallucinations can be prevented by using retrieval augmented generation (RAG), which grounds the output in retrieved source material. Models can also require citations which help if the application shows the retrieved passage next to the answer, so a reader can check the claim against the source rather than against the model.
2. Security: LLMs leak private information from training data or from conversations when they are not managed and monitored, and attackers use them to draft phishing messages or generate spam at scale. Prompt injection, where hostile text in a retrieved document redirects the model, is a risk specific to applications that read untrusted content.
3. Bias: Training data shapes output, and a model trained on skewed data produces skewed output in confident prose.
4. Consent: Some training corpora were assembled without explicit consent or clear copyright permission. That raises intellectual property questions when content is reproduced without attribution, and privacy questions when personal data is scraped.^⁹ Getty Images sued Stability AI in January 2023 over the use of its content; the suit, Getty Images (US), Inc. v. Stability AI, Inc., was filed February 3, 2023, in the U.S. District Court for the District of Delaware.¹⁰
5. Scaling: Training and serving large models consumes substantial computational power, and keeping them useful means continuous updates, optimization, and monitoring.
6. Deployment: Running a model in production takes expertise in deep learning and transformer architectures alongside specialized hardware, which is why most teams start with a hosted API.

A base model knows only what it was trained on up to its knowledge cutoff. But there are four methods you can use to extend a large language model with your own data: prompting, retrieval, tool calling, and fine-tuning, in roughly increasing order of cost.

1. Prompting: Prompting supplies the extra information in the request itself. Few-shot prompting includes examples that show the model the pattern you want. Given examples of positive/negative sentiment, the model infers what signals a given phrase. Zero-shot prompting drops the examples and states the task directly, relying on prior training alone. Prompt engineering writes those instructions deliberately, choosing the examples, the ordering, and the wording, and it costs nothing at the model level because nothing about the model changes.
2. Retrieval augmented generation: Retrieval gives the model facts it never saw. The application searches your own content and injects the matching passages into the prompt, and the model answers from them. RAG grounds output in current, private, access-controlled material and lets the answer cite its sources. It is the standard solution for both hallucination and the knowledge cutoff. The passages and their embeddings live in a search system or vector database that returns the most relevant matches for each query.
3. Tool calling: Tool calling lets the model act instead of answer. It emits a structured call that an external program executes, such as an API request, a database query, or a snippet of code. The result returns to the context for the model to use.
4. Fine-tuning: Fine-tuning is the more expensive option. It changes the model's weights and fits a fixed style, format, or domain vocabulary far better than it fits facts that move. The practical rule: retrieval for knowledge that changes, fine-tuning for behavior that does not.

Large language model evaluation happens at two levels: statistical measures of prediction quality, and task benchmarks that approximate usefulness.

1. Measures of prediction quality: Perplexity scores how well a model predicts held-out text, derived from the average negative log-likelihood per token, and lower is better. Perplexity depends on the tokenizer, so comparing the number across models with different vocabularies is unreliable. It also correlates only loosely with whether a person finds the output useful.
2. Task benchmarks: Benchmark suites cover the second level, testing reasoning, factual accuracy, coding, and safety with graded question sets. Their weakness is benchmark contamination: When benchmark questions appear in a model's training data, its score rises without its capability rising. Contamination is hard to rule out for any model trained on a broad web crawl, which makes leaderboard position weak evidence on its own.

Evaluate candidate models on a held-out sample of your own task, with your own data and your own definition of a good answer, because published scores do not transfer.

LLM is the category and GPT is one branded family inside it; every GPT model is an LLM, and most LLMs are not GPT. Open-weight families publish their parameters, so you can run the model on your own hardware, while proprietary families are reachable only through an API.

Licensing is not always one or the other. OpenAI relies on closed, proprietary access for ChatGPT and GPT-4o, but it released the gpt-oss-120b and gpt-oss-20b models under the open Apache 2.0 license in August 2025.¹²

Organizations also fine-tune these foundations for a single domain, such as customer relationship management or financial data. The family that holds the lead can change within months, while the encoder, decoder, and encoder-decoder distinction has held since 2017.

Related: Choosing an LLM: the getting started guide to open source LLMs

Grounding a large language model in your own data is a search problem before it is an AI problem. If retrieval returns the wrong passage, the answer is wrong, and the model sounds just as confident. Elasticsearch, a distributed search and analytics engine, stores your content alongside its vector embeddings and returns the passages that get passed to the model, using semantic, keyword, or hybrid matching. Once your application is running, LLM observability in Elastic Observability tracks the cost, latency, and errors of those model calls. To start, index a sample of your own content with its embeddings and run a semantic query against it before you wire a model in. Semantic search in Elasticsearch has the implementation steps.

• Language models in Elasticsearch
• The LLM Safety Assessment
• Get started with generative AI in enterprise
• Overview of natural language processing (NLP) in the Elastic Stack
• Compatible third-party models with the Elastic Stack
• Guide to trained models in the Elastic Stack

1. Meta, "Introducing Llama 3.1: Our most capable models to date," July 2024.
2. OpenAI API pricing,platform.openai.com/docs/pricing, accessed September 2026.
3. Vaswani, Ashish, et al., "Attention Is All You Need," NeurIPS 2017 / arXiv preprint, June 2017.
4. Hoffmann, Jordan, et al., "Training Compute-Optimal Large Language Models," NeurIPS 2022 / arXiv preprint, March 2022.
5. Wei, Jason, et al., "Emergent Abilities of Large Language Models," Transactions on Machine Learning Research (TMLR), 2022.
6. Schaeffer, Rylan, Brando Miranda, and Sanmi Koyejo, "Are Emergent Abilities of Large Language Models a Mirage?," NeurIPS 2023 (Outstanding Paper Award) / arXiv preprint, May 2023.
7. Lu, Sheng, et al., "Are Emergent Abilities in Large Language Models just In-Context Learning?," ACL 2024 / arXiv preprint, September 2023.
8. Sarumi, Oluwafemi A., and Dominik Heider, "Large Language Models and Their Applications in Bioinformatics," Computational and Structural Biotechnology Journal, vol. 23, April 2024, pp. 3498–3505.
9. Sheng, Ellen, "In generative AI legal Wild West, the courtroom battles are just getting started," CNBC, April 2023.
10. Getty Images (US), Inc. v. Stability AI, Inc., no. 1:23-cv-00135 (D. Del., filed Feb. 3, 2023); Getty Images statement, January 2023.
11. Brown, Tom B., et al., "Language Models are Few-Shot Learners," section 6.2, NeurIPS 2020 / arXiv preprint, May 2020.
12. OpenAI, "Introducing gpt-oss," August 2025.