# Large language model (LLM)

A large language model is an AI model trained on broad language data to predict and generate text, but it needs outside context and checks for dependable business work.

Source: https://rodamora.com/glossary/large-language-model
Updated: 2026-08-09

---

A large language model is the language engine inside products such as ChatGPT, Claude, and Gemini. It reads an input as pieces called tokens, weighs relationships among those pieces, and predicts one token after another to make a response. The 2017 Transformer paper established the attention-based architecture behind most modern LLMs. NIST's July 2024 Generative AI Profile explains the limit that matters in delivery: the same prediction process can produce accurate text, false facts, or an invented citation. A service firm still has to supply current client records, instructions, permissions, completion checks, and an owner for exceptions. The LLM supplies language ability. The delivery system supplies the rest.

## How does a large language model produce an answer?

An LLM turns text into tokens. A token can be a whole word, part of a word, or punctuation. The model turns those tokens into numbers and processes them through many learned settings called parameters. Each parameter helps shape the next prediction. A parameter is not a database row with one fact waiting inside it.

The model estimates which token should come next. It adds that token, reads the longer sequence, and repeats until the response ends. The answer takes shape during the request through repeated prediction.

[“Attention Is All You Need,” submitted June 12, 2017](https://arxiv.org/abs/1706.03762), introduced the Transformer architecture. Its attention mechanism lets the model weigh relationships among the tokens in the available input. In a proposal, “bank” may refer to a financial client. In a landscaping brief, it may refer to the side of a river. Nearby words help the model decide which pattern fits.

During training, the model sees broad language data. Its parameters change so its predictions improve. The [GPT-3 paper, submitted May 28, 2020](https://arxiv.org/abs/2005.14165), tested a 175-billion-parameter model across more than two dozen language tasks, including translation and question answering. The same model handled different tasks through instructions and examples placed in its input.

## What is the difference between an LLM and an AI application?

An LLM is one part of an application. The application decides what a user can send, which model receives the request, which tools are available, how conversation history is stored, and what happens to the result.

ChatGPT, Claude, and Gemini are applications. Their interfaces may add file handling, web access, saved preferences, safety controls, and tool calls around one or more models. A change in any of those layers can change the experience while the underlying model stays the same.

| Term | What it supplies | What it still needs |
| --- | --- | --- |
| Large language model | Language prediction and generation | Current context, tools, checks, and ownership |
| Chat application | Interface, conversation handling, and product controls | A defined business process and completion test |
| [AI workflow](https://rodamora.com/glossary/ai-workflow) | A fixed path that uses a model for bounded steps | Exception handling and a process owner |
| [AI agent](https://rodamora.com/glossary/ai-agent) | A goal plus allowed tools and room to choose actions | Permissions, evaluation, monitoring, and recovery |

Stanford's [August 18, 2021 foundation-model definition](https://hai.stanford.edu/news/introducing-center-research-foundation-models-crfm) sets the same boundary. A model trained on broad data can be adapted to many downstream tasks. It is a building block for applications. A broad model gives a firm more possible uses. The application determines what one use can safely do.

## What changes when you write a prompt?

A prompt supplies instructions and context for the current request. It can name the task, provide source material, show examples, set a format, and tell the model which constraints to follow.

The GPT-3 researchers used zero-shot, one-shot, and few-shot for these cases. A model could try a task from an instruction alone or infer the pattern from examples in the input. The model's parameters did not change during those requests. A good example can change the next answer without permanently teaching the base model a new skill.

These terms describe different ways of changing what a model can use:

| Method | What changes |
| --- | --- |
| Prompt | Instructions and examples in the current input |
| [Context window](https://rodamora.com/glossary/context-window) | The amount of input and generated output the model can consider at once |
| [Memory](https://rodamora.com/glossary/memory) | Selected information saved for later runs |
| [Retrieval-augmented generation](https://rodamora.com/glossary/retrieval-augmented-generation) | Outside records fetched and added to the current context |
| [Fine-tuning](https://rodamora.com/glossary/fine-tuning) | Model behavior changed through additional training |

A long conversation can look like learning because earlier messages influence later answers. That influence lasts while the application keeps those messages or a separate memory system brings selected details back. The base model's parameters stay unchanged.

## Why can an LLM sound sure and still be wrong?

Fluency and factual support are separate tests. The model is built to produce text that sounds likely to follow. A clean sentence can still lack a source.

NIST's [July 2024 Generative AI Profile](https://nvlpubs.nist.gov/nistpubs/ai/NIST.AI.600-1.pdf) calls false or internally inconsistent output a confabulation. It connects this risk to the model's statistical design. Predicting the next token can produce correct material or confident falsehoods. Open-ended work and tasks that need deep domain context carry more exposure.

Suppose a team asks for a summary of a client's market and leaves web access on. The model may return a polished paragraph with a study title, date, and percentage that look credible together. The output still fails if the study does not exist. The [hallucination](https://rodamora.com/glossary/hallucination) happened during generation. The polished wording made it harder to notice.

[Grounding](https://rodamora.com/glossary/grounding) gives the model approved source material. An [eval](https://rodamora.com/glossary/eval) tests the result against a written standard. Neither makes every answer true. Together they turn “this sounds right” into checks the firm can repeat.

## What must a service firm add around the model?

Production use needs six parts around the LLM: a named task, an authoritative source, selected context, limited permissions, a completion check, and an owner for exceptions.

Take a client-intake summary. The model can read an approved call transcript, extract requirements, and draft the summary. The surrounding system has to confirm that the transcript belongs to the right client, attach the current scope, block unsupported pricing promises, store the output in the correct record, and send missing information to someone who can decide.

A general chatbot without those connections stays [a better individual search and drafting tool](https://rodamora.com/blog/your-ai-is-just-a-better-google-search). It may save a person time. It cannot see the firm's current truth unless the firm supplies it.

The process also has to exist outside someone's head. [Document the process first](https://rodamora.com/blog/document-the-process-first-or-the-agent-scales-the-chaos) so the model receives the same source, rule, and stopping point the team uses. If two managers resolve the same exception differently and nobody records why, the LLM has no stable standard to follow.

Give less authority when a mistake costs more. A draft that a person can check in thirty seconds needs a different boundary from a client promise or deleted record. [Delegate based on whether the result can be checked and the action undone](https://rodamora.com/blog/delegate-the-inputs-own-the-outputs). That rule belongs in the system around the model.

## Does a firm need to train its own LLM?

Most service firms can test a first production use with an existing model. Start with one task, approved records, a clear prompt, and a small eval set made from real examples. Measure finished results and review effort across more than one model before changing the model itself.

Fine-tuning is worth its cost when repeated tests reveal a stable behavior gap that prompts, examples, retrieval, and workflow rules do not close. Private facts alone are usually a context problem. The system can retrieve them for the current run without placing them in model weights.

Model choice balances capability, cost, and review effort. A more capable model may reduce mistakes on a difficult task and cost more per request. A cheaper model may pass a narrow classification test and leave less review work than expected. Use the smallest model that passes the firm's own eval at the required consequence level. The right choice can differ by step inside the same workflow.

## Where does an LLM sit on the Delivery Model Ladder?

Direct use of an LLM belongs mainly at Stage 1, Enhanced, on the [Delivery Model Ladder](https://rodamora.com/delivery-model-ladder). One employee opens a chat application, assembles the input, reviews the response, and moves it into the next system. The person is faster while the delivery path stays mostly the same.

The work reaches Stage 2, Augmented, when a workflow supplies approved context, calls the model for a bounded task, checks the result, and moves it to the next step. The firm changed the delivery process instead of giving one employee a faster screen.

Stage 3, AI-native, needs the whole operating model. A larger LLM cannot create shared context, process ownership, evaluation, or recovery by itself. The gap between a model demo and that owned system is part of the [Production Gap](https://rodamora.com/production-gap).

## When is an LLM the wrong tool?

Use ordinary software when the answer must follow an exact rule. Arithmetic, fixed database lookups, stable routing tables, and irreversible account changes should not vary because a language model found another plausible response.

An LLM can interpret the messy request around an exact step. It might extract invoice fields from an email while ordinary code calculates tax and validates the total. Keep the model where language varies. Keep the rule where correctness has a precise definition.

This boundary assumes the firm can name the source of truth and test the output. Work without either condition stays manual until those parts exist.