What Is a Large Language Model: A Plain-English Guide

A visitor opens the chat on your pricing page and types, "does the Pro plan include SSO, and can I be invoiced annually?" A few seconds later a clear, correct answer comes back, in full sentences, phrased around the visitor's own question. No human typed it. A large language model did, and it did the same for the four hundred other visitors who asked something that day.

The technology behind that reply is easier to understand than the acronyms suggest. Underneath, a large language model is a very large statistical machine that has read a great deal of text and learned to predict what word comes next. Almost everything it does, from drafting emails to answering support questions, falls out of that one trick repeated at scale.

This guide covers what a large language model is, how it turns your prompt into a response, how it gets trained, what it can and cannot do, why it sometimes makes things up, and how sales and support teams use it in practice.

What is a large language model?

A large language model (LLM) is an AI system trained on enormous amounts of text so it can predict and generate human language one piece at a time. IBM groups these models as a type of foundation model, trained on immense amounts of data and capable of understanding and generating natural language and other content across a wide range of tasks.

The "large" in the name points to two things. One is the number of parameters, the internal values the model adjusts during training, which commonly run into the billions. The other is the volume of text it learns from, often measured in trillions of tokens. AWS describes an LLM in the same terms, as a model built on the transformer architecture that can recognize, summarize, translate, predict, and generate language.

The word "understanding" needs a caveat. An LLM holds no beliefs and carries no picture of the world the way a person does. What it has is a detailed statistical map of how language fits together, accurate enough that its output usually reads as though it understood. Britannica traces the modern line of these systems to the shift toward transformer designs and steadily larger training runs, a change that began in the late 2010s.

For a business, the practical definition is simpler. An LLM is the engine that lets software answer an open-ended question in plain language, whether that question is "summarize this thread" or "does your widget work on Shopify."

How does a large language model generate responses?

A large language model generates a response by breaking your prompt into tokens, turning them into numbers, and then predicting the next token over and over until the answer is complete. Each new token is chosen from everything that came before it, added to the running sequence, and fed back in for the next round.

The first step is tokenization. The model does not read words the way you do; it splits text into tokens, which can be whole words, parts of words, or punctuation. Microsoft's developer guidance gives a working rule of about four characters per token in English, so a short phrase like "refund policy" is a couple of tokens, while a longer word can split into pieces such as "un," "happy," and "ness." Each token maps to a number the model can process.

Those numbers become embeddings, vectors that place each token in a space where related meanings sit near each other, and they flow through the transformer. The transformer is the design introduced in the 2017 paper "Attention Is All You Need," whose central idea is self-attention: a mechanism that lets the model weigh how much every token should influence every other one. That is how it keeps "it" attached to the right noun three sentences back, or links "invoiced" to "annually" in the visitor's question.

At the end of the stack, the model produces a probability for every possible next token. Say a support prompt ends with "Your refund will be processed within 5 business ___." The model might assign 0.71 to "days," 0.09 to "weeks," 0.06 to "hours," and thin slivers to thousands of other options. It picks one, usually the likeliest, though a setting called temperature can add controlled randomness so two replies are not identical, then appends it and runs the loop again. Word by word, that is how the whole answer appears.

This left-to-right, one-token-at-a-time process explains a lot about how an LLM behaves. It has no draft to revise and no outline it commits to in advance. The same prompt can produce slightly different wording on two tries, and a long answer can start out accurate and drift, because every token is a fresh bet placed on the tokens before it.

How is a large language model trained?

A large language model is trained by feeding it huge amounts of text and asking it, billions of times, to predict the next token, then nudging its parameters whenever it guesses wrong. Over enough passes, those internal weights settle into patterns that capture grammar, facts, writing styles, and the statistical shape of language itself.

The scale is the headline. GPT-3, the model that made this approach famous, carries 175 billion parameters, which its authors noted was ten times more than any comparable dense model before it, in the 2020 paper "Language Models Are Few-Shot Learners." Newer systems train on datasets measured in trillions of tokens, roughly the text of millions of books, and a single training run can cost millions of dollars in compute.

Training happens in stages. First comes pretraining, the raw next-token task run across a broad corpus, which is where the model absorbs most of what it knows. After that comes a tuning phase, often guided by human feedback, that shapes the raw model into something which follows instructions and stays on topic. The base model learns language, and the tuning teaches it manners.

One consequence matters for anyone deploying an LLM: training ends on a fixed date. The model knows nothing that happened after its data was collected, and it has never seen a line of your internal documents. A general model can write a polished paragraph about refunds without knowing your refund window is 14 days, and closing that specific gap is the whole job of the grounding techniques covered later.

What can and cannot a large language model do?

A large language model can generate, summarize, translate, classify, and answer questions across nearly any topic in fluent language, yet it cannot reliably know current facts, perform exact arithmetic, or guarantee that what it says is true. The dividing line runs between working with language and knowing the ground truth.

On the "can" side, LLMs are strong wherever the job is turning one piece of text into another. Drafting a reply, condensing a long thread into three bullets, rewriting a curt message in a warmer tone, pulling a shipping address out of an email, sorting tickets by topic: all of these play to the model's core skill. AWS points to the same range, noting that one model can handle translation, summarization, question answering, and content generation without being rebuilt for each task.

On the "cannot" side, three limits surface again and again. The model has a knowledge cutoff, so it is blind to anything recent unless you supply it in the prompt. It reasons by pattern rather than by rule, so precise math and long chains of logic are shaky. And it has no built-in sense of truth, so it can state something false with the same confidence it states something correct. There is also the black-box problem: even the teams that build these systems cannot fully trace why a given output appeared.

A quick contrast makes the boundary concrete. Ask an LLM to add two ten-digit numbers and it may hand back a plausible total that is off by a digit. Ask it to draft the email that reports that total to a customer, and it will write a clean, well-worded message. The language task lands, and the arithmetic is a coin flip.

Why do large language models make things up?

Large language models make things up, a behavior called hallucination, because they are built to always produce the most plausible next token, not to verify whether that token is true. When the model holds a real fact, plausible and correct line up. When it does not, it still generates the smoothest-sounding continuation, and that continuation can be wrong.

OpenAI researchers argue the habit is baked in by how models are graded. In their 2025 analysis, they liken a model to a student sitting a multiple-choice test: a guess might earn a point, while "I don't know" guarantees a zero, so standard scoring quietly rewards confident guessing over honest uncertainty. The peer-reviewed version of that work, published in Nature, makes the same case that accuracy-only evaluation incentivizes hallucination. A separate line of research goes further, arguing that a general-purpose LLM will always hallucinate at some rate and that the behavior can be reduced but never fully removed.

For a business, the takeaway is operational. A model answering from memory alone will now and then invent a policy or a price, and inside a customer conversation that invention can turn into a promise you did not make. The standard defense is to stop asking the model to recall and start handing it the facts, pulling the relevant passages from your own documentation into the prompt so the answer is built from your content. That is the idea behind grounding an assistant in a knowledge base, and it is why a careful setup has the assistant decline when it has no source to draw on.

How are large language models used in sales and support?

In sales and support, large language models power the assistants that greet visitors, answer product questions in plain language, qualify leads, draft replies, and summarize conversations for the human who takes over. The same next-token engine that can write an essay is able to hold a useful, on-brand exchange with a buyer.

Adoption has moved quickly. Gartner found that 85% of customer service leaders planned to explore or pilot customer-facing conversational generative AI in 2025, a sign that LLM-driven chat has crossed from experiment into standard practice. Most teams now run some version of it on the front line.

The common deployments are narrow and practical. An AI chat assistant grounded in your help center answers repeat questions instantly, at any hour, in the visitor's own language. Behind the scenes, an LLM can read an incoming message, tag its intent, and route a hot lead to the right rep. It can also draft a first-pass reply for an agent to edit, or write a two-line recap of a long chat so the next person is caught up in seconds. Setting the boundaries for what the assistant may say, and when it should hand off, is the practical work covered in an AI assistant setup.

Here is a rough month. Say 1,000 visitors start a chat. An LLM assistant handles the routine 70%, around 700 conversations, end to end: opening hours, pricing tiers, integrations, "where is my order." That leaves 300 higher-intent or higher-stakes conversations, and the model qualifies and routes each one, so a rep opens it already knowing what the buyer wants. The assistant closed nothing on its own. It made sure every visitor got an instant answer and every rep spent their time on the 300 conversations that actually needed a person.

The boundary matters as much as the capability. Because an LLM can hallucinate, the reliable pattern keeps it on high-volume, low-risk questions and hands anything touching a firm commitment (a refund, a contract, a custom price) to a human. On a sales site the handoff is the goal anyway, since reaching a person while a buyer is still interested beats keeping them talking to software.

Key takeaways

• A large language model predicts the next token. It is a statistical system trained on huge amounts of text to guess what word-piece comes next, and everything it produces is that guess repeated at scale.
• Generation is a loop. The model tokenizes your prompt, embeds it, weighs the tokens with attention, predicts one token, appends it, and runs again, which is why the same prompt can yield slightly different answers.
• Scale and a fixed cutoff define it. Models like GPT-3 hold billions of parameters trained on trillions of tokens, and their knowledge freezes on the date the training data was collected.
• Strong on language, weak on truth. LLMs draft, summarize, translate, and classify well, but they miss on recent facts, exact math, and any guarantee that an answer is correct.
• Hallucination is structural. Because the model always writes the most plausible continuation, grounding it in your own documents, rather than trusting its memory, is the practical fix.
• In sales and support, keep it on volume and hand off the stakes. Let the model answer the routine majority and qualify the rest, then route anything touching money or a commitment to a person.