A Map of AI Terms
Put the high-frequency terms on one map: what each is, which problem it solves, and how it relates to you.
This field is dense with jargon, but not because the subject is complicated—each term grows on a different stage of a single call. Walk through the four stages and most of the words fall into place.
Signs you'll recognize:
- Four unfamiliar terms in one article leave you unsure what it said.
- Someone at the meeting says "just RAG it" and you don't know what to ask without sounding lost.
- You can explain Token, Agent, and fine-tuning separately, but not how they relate.
What happens in one call
Every time your product asks the model a question, it runs through four stages.
Stage one: load the input. The model doesn't fetch material on its own. Your code sends everything it needs in this one request: rules (system prompt), history (conversation), retrieved fragments (retrieval, aka RAG), and the user's message—all packed into the context window, measured in tokens.
Stage two: the model computes. It does one thing: predict the most likely next word, append, recompute. Repeat a few hundred times and a reply is written. The only knob is something like temperature; parameter count, capability, and knowledge were fixed at training.
Stage three: it outputs text. Generated on the spot, not looked up from a store—the most fundamental difference from a search engine. Where it doesn't know, it fills gaps with the most plausible-sounding content in the same tone as the truth: that's hallucination. It also has no idea what happened after training.
Stage four: it acts. Talking isn't enough. Tool descriptions in stage one let it output "call this tool with these arguments." Your code executes, pushes the result back, and it computes again. Round and round for dozens of turns—that's the agent loop.
The key is the return path: every turn recomputes the first three stages. Context grows, and each round resends and rebills everything before it. That's why agents are slow and expensive, and why saving money means controlling context length, not a cheaper model.
The six pairs people mix up
Memorizing definitions won't help. What actually breaks your judgment in meetings are these six pairs—they sound alike and differ a lot.
One: a token is not a character. It's the model's way of splitting text; a common English word may be one token, an obscure Chinese character three. Billing, context length, and rate limits all run on tokens, so "this 20,000-character document can't be expensive" won't hold—you have to tokenize it.
Two: parameter count is not context length. One says how big the model is (7B, 70B); the other says how much it reads at once (128K, 1M). They're unrelated and pair up in any combination, but get conflated most in model selection.
Three: fine-tuning is not feeding documents. It changes how the model speaks, costs real training money, needs thousands of samples, and cannot teach new facts. To make it know your policies, the answer is almost always RAG—retrieve docs into stage one, not fine-tune. Teams fine-tune for months and discover retrieval would have solved it.
Four: an agent is not a smarter model. It's the layer around the model: loop, tools, permissions, termination conditions. The same model with a good loop works; with a bad loop it spins. "It keeps skipping steps" is usually a vague process, not a dumb model.
Five: a Skill is not MCP. A Skill is a packaged bundle of knowledge and workflow, loaded into context only when needed—it solves "I keep re-explaining everything." MCP is a protocol for agents to connect external systems—it solves "how do I reach your database and third-party services." One carries knowledge, the other interfaces.
Six: open-source is not free. Open-source models usually publish only the weights; training data and code stay private. You can run it yourself, but you supply the GPUs, operations, and concurrency. Add it up and self-hosting at small scale usually costs more than calling an API. What it buys is control—data stays in-house, and the model won't be discontinued or repriced out from under you.
A term-by-term table
Arranged in the order of the four stages: one line for what it is, one for why you care. Anthropic's glossary makes the same point—term boundaries vary across vendors. claude-glossary
Stage one — the context side
| Term | What it is, in one line | Why you care |
|---|---|---|
| Prompt | All the text you send in one request. | It's a requirements doc, not a spell. Where you're unclear, it fills in. |
| System prompt | The rules placed first and repeated every turn. | Your product's personality, boundaries, and restrictions live here; it's also the most cacheable part. |
| Context window | The upper limit of what one request can hold, in tokens. | Past it you truncate or compress. What gets cut off it truly can't see—and won't tell you. |
| Token | The model's minimum unit, neither a word nor a character. | Billing, context length, and rate limits all run on it. Convert before estimating cost. |
| Lost in the middle | With long context, the start and end are remembered, the middle is ignored. | Put critical instructions first or last, not buried among documents. |
| Embedding | Text turned into coordinates; similar meanings land close. | Semantic retrieval is built on it. It measures "similar," not "correct." |
| RAG / knowledge base | Retrieve relevant fragments from your documents, then hand them to the model with the question. | The most effective anti-hallucination move, and the real body behind most "enterprise knowledge bases." |
| Context compaction | Summarize the earlier conversation into a short block to replace it. | Saves money and loses detail—often the very constraints set early on. |
| Long-term memory | Store what matters externally, inject it on the next conversation. | The model has no memory; what we call memory is your system storing and loading it. |
Stage two — the model itself
| Term | What it is, in one line | Why you care |
|---|---|---|
| Next-token prediction | At each step, pick the most likely next token and repeat. | The one mechanism. Every strength and limit traces back to it. |
| Training / inference | Training feeds data once; inference runs it on every call. | Your bill is all inference; your capability ceiling is set at training. |
| Training data | All the text, images, and code fed in during training. | What's not in the corpus, it can only guess. Your internal concepts are exactly that. |
| Parameter count | The number of weights, written like 7B or 70B. | Not the same as intelligence, and unrelated to context length. |
| Temperature | The knob for sampling randomness: low is steady, high is wild. | Lower it for stable output. The default is often not the setting you want. |
| Reasoning model | Generates a long chain of thought before answering. | More accurate on hard problems, but that thinking is billed as output—waste on simple tasks. |
| Open-source model | Weights are public and you can deploy it yourself. | You buy control, not cheapness. Self-hosting at small scale is usually pricier. |
Stage three — output and its boundary
| Term | What it is, in one line | Why you care |
|---|---|---|
| Hallucination | Fills what it doesn't know with the most plausible-sounding content, in the same confident tone. | An inevitable product of the mechanism, not a bug. You can only defend, not wait for a fix. |
| Knowledge cutoff | The last point of training data; nothing after it is known. | Anything "latest" has to be fed in by you. |
| Multimodal | Models that read images, audio, and video, often as later additions. | Small text, table lines, and precise coordinates are failure hotspots. |
Stage four — the agent side
| Term | What it is, in one line | Why you care |
|---|---|---|
| Agent | A program that decides its next step and calls tools to act. | Not a smarter model; it's the loop and permissions around the model. |
| Tool calling | You provide tool specs; it outputs which tool and arguments; your code executes. | Wherever tools reach is its capability boundary. |
| Agent loop | Think, act, observe, repeat until it converges. | Cost and latency scale with rounds. A non-converging loop is the most expensive failure. |
| Skill | A packaged bundle of knowledge and workflow, loaded only when needed. | Captures the experience of re-explaining things, without occupying the window. |
| MCP | A standard protocol for agents to connect external systems. | Connect once, use everywhere. Audit third-party MCPs like granting permissions. |
| Multi-agent | Split the task among several agents, then merge the results. | More robust, but context is duplicated across copies and cost climbs fast. |
| Prompt injection | A hidden instruction inside material the model reads—and it complies. | The model can't separate instructions from data. A fundamental gap no prompt can patch. |
| API vs web app | One is for programs, the other for people. | Retention, controllable parameters, and billing all differ. Separate them when talking compliance. |
The one question to ask when lost
One more thing: term boundaries aren't uniform. The same "agent" means one thing to a vendor, another to an engineer, yet another in a news article. Some call a tool-enabled chat window an agent; others insist it must run dozens of rounds.
So what works isn't memorizing definitions—it's asking in the meeting: "Which specific step do you mean?" Have the other person place it on one of the four stages. Most misunderstandings dissolve in that question.
If you carry away one sentence: the model only predicts the next word; every other term is something people invented to work around that limitation. Know which limitation each dodges, and you won't need definitions.