What is an LLM?

The most straightforward definition

A large language model (LLM) is a statistical model that takes text as input and predicts what text should come next.

That sounds small, but it scales into something surprisingly flexible. If you ask it to draft a sales email, it predicts the next tokens of a sales email. If you paste a contract clause and ask for risks, it predicts the next tokens of a risk review. If you ask for a plan, it predicts the next tokens of a plan.

Here’s the key: the model doesn’t “look up” an answer the way a search engine does. It generates an answer by building a probability distribution over possible next tokens, step by step, until it reaches a stopping point.

What makes it “large”

When people say “large,” they usually mean three things:

• Lots of parameters: The model stores what it learns inside millions to hundreds of billions of numeric weights. Those weights don’t store sentences like a database does, but they do shape how the model maps input text to output text.
• Lots of training data: Training works best when the model sees a wide range of writing styles, topics, and formats.
• A big context window: The model reads a limited amount of text at once, called its context window. Bigger context windows let it keep more of your prompt, instructions, and documents “in mind” while it writes.

In business terms, “large” usually correlates with broader coverage, better instruction following, and better handling of messy inputs, but it also raises practical questions about cost, latency, privacy, and governance.

A high-level view of how an LLM works

You don’t need to know the math to use an LLM well, but it helps to understand the pipeline:

1. Tokenize the text. The system breaks your text into tokens, which often look like short word pieces.
2. Run the transformer. Most modern LLMs use a transformer architecture that lets the model pay attention to different parts of the input at once.
3. Predict the next token. The model produces a probability distribution over the next token.
4. Choose a token and repeat. The system picks the next token (sometimes greedily, sometimes with sampling), appends it, and repeats.

Training usually happens in stages:

• Pretraining: The model reads huge text corpora and learns to predict the next token across many domains.
• Instruction tuning: Trainers fine-tune the model on examples that look more like real prompts and helpful responses.
• Preference tuning (often RLHF): Trainers collect human preferences between model outputs and push the model toward the styles people prefer, like being clearer, safer, and more aligned with instructions.

That combination explains why modern systems often feel more like assistants than like raw autocomplete.

A small vocabulary table that clears up a lot of confusion

Term	What it means in plain English	Why it matters at work
Token	A chunk of text the model processes	Affects cost, speed, and how the model “counts” input and output
Context window	The maximum text the model can consider at once	Determines how much of a doc set, chat, or instructions it can track
Parameters	The learned weights inside the model	Often correlates with capability, but training quality matters too
Pretraining	Broad training on general text	Gives the model wide coverage and general language ability
Fine-tuning	Extra training for a task or style	Helps the model follow your org’s tone, formats, or domain
Retrieval (RAG)	The app fetches relevant docs and feeds them into the prompt	Improves grounding and lets you update knowledge without retraining
Tool use	The app lets the model call functions (search, calculators, CRM)	Turns “text generator” into “workflow engine,” with guardrails

“Isn’t it just autocorrect?” and the Markov chain debate

You’ll hear two common takes:

• “It’s just fancy autocorrect.”
• “It’s just a fancy Markov chain.”

Both statements point at something real, and both miss something important.

An LLM does predict what comes next, like autocomplete does. The difference comes from scale and flexibility: a modern LLM learns patterns across many writing tasks and formats, and it can condition on long instructions, examples, and documents.

A Markov chain predicts the next state based only on a limited history. If you let the history grow without bound, the distinction blurs, because both systems model conditional probabilities. In practice, LLMs use a learned, high-dimensional representation of context, and the transformer lets them route “attention” across that context in ways a fixed-order Markov model can’t match. So you can treat an LLM as a next-token predictor, but you shouldn’t treat it as a simple one.

Also, none of this settles the “does it think?” argument, and you don’t need that debate to use the tool responsibly. For business decisions, you mostly care about capability, reliability, and controls.

Why LLMs sometimes sound smart and sometimes fail

LLMs optimize for plausible continuation, not for truth.

That design creates a predictable pattern:

• They excel at form and structure. They write clean prose, mimic tones, draft outlines, and transform text.
• They often help with reasoning-like tasks. They can plan, compare options, and explain concepts, especially when you give constraints and examples.
• They can still hallucinate. When the model doesn’t “know” something, it may still generate a fluent answer that stitches together likely-sounding pieces.

Even “web-enabled” systems can still fail. A tool might fetch the wrong page, retrieve irrelevant snippets, or mix sources. Sometimes the model also misreads what it retrieved, or it blends retrieved facts with guesses.

So, treat the model as a partner that needs grounding, not as an oracle.

“LLMs write boring text” and “LLMs can’t create anything original”

Those critiques made sense in specific eras and setups.

Early systems often produced repetitive or generic text when developers used decoding methods like greedy selection or beam search. Researchers later showed that sampling methods and training changes could reduce that degeneration and improve diversity.

On originality, LLMs recombine patterns from training data, but they don’t simply copy-and-paste by default. They can generalize and produce novel combinations, and they can also memorize and regurgitate exact spans under certain conditions. That tension explains why people can use them for creative work and why privacy and IP governance still matter.

The practical takeaway: you shouldn’t assume everything the model writes counts as unique, and you also shouldn’t assume it can only output bland filler.

Why LLMs keep improving so fast

Progress tends to come from a few levers that compound:

• More and better data: Teams filter, deduplicate, and mix data more carefully.
• Smarter scaling: Researchers study how to allocate compute across model size and training tokens.
• Better alignment training: Instruction and preference tuning help models follow intent.
• Better systems around the model: Retrieval, tools, evaluation harnesses, and monitoring matter as much as the raw model.

This pace explains why old “always true” claims about LLM behavior often age badly. It also explains why you should evaluate tools in your own workflows instead of relying on vibes from last year.

A grounded way to use LLMs in business

If you want the benefits without the surprises, set up a workflow that assumes the model can draft fast but still needs checks.

Where LLMs usually shine

• First drafts: emails, proposals, briefs, landing pages, scripts
• Transformation: summarize, reformat, translate, change tone
• Knowledge work support: brainstorm options, critique a plan, map pros and cons
• Extraction: pull structured fields from messy text, then validate

Where you should add extra guardrails

• High-stakes facts (legal, medical, financial): require sources and human review
• Brand or compliance-sensitive writing: enforce templates and approvals
• Anything that touches private data: limit inputs, log access, and use the right deployment

A simple playbook that works in most orgs

1. Start with a tight prompt: goal, audience, constraints, examples.
2. Ask for uncertainty: “List what you’re least sure about.”
3. Ground it: add retrieval over your internal docs, or provide a source pack.
4. Validate: spot-check numbers, names, dates, quotes, and policy claims.
5. Keep a paper trail: save prompts, sources, and versions for audits.

If you treat an LLM as a fast collaborator with a consistent failure mode, you’ll get a lot of leverage and fewer unpleasant surprises.