The AI conversation has too many words and not enough definitions. Most articles assume you already know what "fine-tuning" means, or use "embedding" without ever telling you what an embedding is. This glossary fixes that.
It is not exhaustive. It is the working vocabulary you need to read AI news, follow technical blog posts, and not feel lost in a meeting where someone uses three of these in one sentence.
Each entry has a one-line definition and a one-line "why it matters". Skim the categories. Come back when you hit a term in the wild that you cannot place.
The big picture
AI (Artificial Intelligence). Any system that does something we'd call "smart" without being explicitly programmed for that exact case. Why it matters: the umbrella term. Almost everything else here lives under it.
ML (Machine Learning). A technique for building AI by showing a system labelled examples and letting it learn the pattern itself, rather than writing rules by hand. Why it matters: most modern AI is ML. If something "learned" anything, it is ML.
Deep learning. ML using neural networks with many layers. The technique that made modern AI work. Why it matters: every notable AI system since 2012 (image recognition, translation, chatbots) is deep learning.
Neural network. A function made of many simple math operations stacked in layers. Each layer transforms its input. With enough layers and enough data, the function can approximate anything. Why it matters: it is the engine inside every modern model. You do not need to know the maths, just that this is the shape.
Models
Model. A trained file full of numbers (parameters) that turns inputs into outputs. The output of training. Why it matters: when someone says "we are using GPT-4", "GPT-4" is the model.
Parameters. The numbers inside a model. Adjusted during training. A "70B model" has 70 billion of them. Why it matters: parameter count is a rough proxy for capability and cost.
LLM (Large Language Model). A model trained to predict the next token in text, on internet-scale data. Examples: GPT, Claude, Gemini, Llama. Why it matters: it is the model behind most of what people call "AI" in 2026.
Foundation model. A large general-purpose model that gets used as the base for many specific applications. Why it matters: same model can power a chatbot, a code assistant, and a summarisation tool, depending on prompting.
Open-weight model. A model whose parameters are publicly downloadable. Llama, Mistral, DeepSeek. Why it matters: you can run them on your own hardware, no API needed.
Closed model. A model only available through an API. GPT-4, Claude, Gemini. Why it matters: more capable in 2026 but you pay per call and your data goes to the provider.
Training and data
Training. The expensive process where a model is built by showing it examples and adjusting parameters until output matches expected. Why it matters: it is what makes the model. Costs millions for large models. Done once per version.
Inference. Running a trained model to get an answer. Cheap relative to training. What happens when you use ChatGPT. Why it matters: when you "use AI", you are paying for inference, not training.
Pre-training. The first phase: train the model on a giant general dataset to learn language and reasoning patterns. Why it matters: it is the slow, expensive phase. The bulk of a foundation model's capability.
Fine-tuning. The second phase (optional): train an already-pre-trained model on a smaller, specific dataset to specialise it. Why it matters: how you turn a general model into a domain expert (legal, medical, your company's tone).
RLHF (Reinforcement Learning from Human Feedback). A specific fine-tuning technique where humans rate the model's outputs and the model is trained to produce more of what humans liked. Why it matters: it is why ChatGPT feels polite and helpful instead of cold and robotic.
Dataset. The collection of examples a model is trained on. Why it matters: the model can only learn what is in its dataset. Garbage in, garbage out.
Training cutoff. The date after which the model has no knowledge. Why it matters: if you ask about events past the cutoff, the model has no idea. It will guess.
Tokens, context, and prompting
Token. A chunk of text the model actually sees. About 3 to 4 characters of English. "Hello world" is two tokens. Why it matters: pricing is per token. Context limits are measured in tokens.
Tokenizer. The bit of code that splits text into tokens. Why it matters: same prompt costs different amounts in different models because they tokenise differently.
Context window. The maximum number of tokens a model can hold in mind at once. Modern frontier models: 200,000 plus. Why it matters: anything past it falls out of the model's "memory".
Prompt. The text you send to the model. Why it matters: prompting is a skill. See Talking to AI well.
System prompt. A special prompt that sets up the model's role and rules, sent before any user message. Why it matters: the persona, format and constraints live here. Users do not see it.
Few-shot prompting. Putting one or more example input-output pairs in the prompt before the actual task. Why it matters: easiest way to get consistent formatted output without fine-tuning.
Chain of thought. Asking the model to reason step by step before giving the final answer. Why it matters: improves accuracy on hard reasoning tasks. "Let's think step by step" is the canonical phrase.
Output and behaviour
Hallucination. When the model confidently states something false, often with made-up citations or details. Why it matters: the most important failure mode to know. Verify anything that matters.
Temperature. A knob (0 to 1+) that controls randomness in the output. 0 is deterministic, 1 is creative. Why it matters: low temperature for facts and code, higher for brainstorming.
Top-p / top-k. Other knobs for the sampling step that picks the next token. Less commonly tuned than temperature. Why it matters: rarely worth fiddling with. Defaults are usually fine.
Streaming. Sending tokens to the user as soon as they're generated, instead of waiting for the full response. Why it matters: lower perceived latency. Why ChatGPT "types" as it answers instead of dumping the whole reply at once.
Embeddings and search
Embedding. A numeric representation of text where similar meanings live close together in vector space. Why it matters: it is how a computer can know that "cat" and "kitten" are related. Foundation of semantic search.
Vector database. A database optimised for storing embeddings and finding nearest neighbours. Why it matters: the storage layer for RAG (next entry).
RAG (Retrieval-Augmented Generation). A pattern where you retrieve relevant documents from your data, paste them into the prompt, and let the model answer using them. Why it matters: how you ground a model in private or up-to-date information without fine-tuning.
Semantic search. Searching by meaning instead of exact keyword match. Powered by embeddings. Why it matters: why "how do I cancel" finds a document titled "Subscription termination process".
Agents and tools
Agent. An LLM that has been given tools (functions it can call) and a loop, so it can take actions and iterate, not just answer. Why it matters: the difference between "explain how to deploy" and "deploy it for me".
Tool calling / function calling. The capability where a model can output a structured request to call a function, get the result back, and continue reasoning. Why it matters: every modern agent system depends on this. ChatGPT uses it for search, code execution, etc.
MCP (Model Context Protocol). A standard for connecting models to external tools and data. Anthropic's open spec, increasingly adopted across providers. Why it matters: gives a single integration target instead of one shape per provider.
Multi-agent system. A system where several agents specialise in different roles and pass work between each other. Why it matters: where current research is heading. Often more reliable than one agent doing everything.
Evaluation and safety
Eval / evaluation set. A standardised set of test inputs with expected outputs, used to measure if a model is improving. Why it matters: without an eval set, you cannot tell if your prompt change made things better or worse.
Benchmark. A public eval suite for comparing models. Examples: SWE-bench (coding), MMLU (general knowledge), HumanEval. Why it matters: leaderboards run on these. Useful but should not replace your own evals.
Bias. When a model produces systematically different outputs for different groups (gender, race, language) in ways that disadvantage some. Why it matters: a real problem in production AI. Has to be measured deliberately, will not show up in casual testing.
Alignment. The general project of making models do what we want, including being honest, helpful, and safe. Why it matters: not an abstract concern. RLHF is alignment in practice.
Jailbreak / prompt injection. Tricks that bypass a model's safety training, getting it to produce content it would normally refuse. Why it matters: any AI system that processes untrusted user input has to defend against these.
Operational
API (Application Programming Interface). The way you talk to a model from your own code. Why it matters: every production AI integration is an API call.
Rate limit. A cap on how many requests you can make per minute / per day. Why it matters: production systems have to handle being throttled.
Latency. How long the model takes to respond. Why it matters: real-time UX needs sub-second; batch jobs do not. Trade off against model size.
Cost per token. Models charge per input token and per output token, often at different rates. Why it matters: long contexts and verbose outputs add up fast at scale.
Cache. Storing the model's response to a given prompt so you do not pay to regenerate it next time. Why it matters: cuts cost dramatically for repetitive workloads.
Specific to building applications
Structured output. Forcing the model to return JSON (or another machine-parseable format) that matches a defined schema. Why it matters: it is how AI fits into existing software pipelines without you parsing English text.
Schema. The shape of the structured output you want. Usually expressed in JSON Schema or a similar format. Why it matters: lets you treat the model's output like any other API response.
Guardrails. Code or libraries that wrap a model and refuse outputs that violate rules (length, content, format). Why it matters: the model alone is not safe to put in front of users. Guardrails are how you ship.
Eval-driven development. Building AI features by writing the eval set first, then iterating on the prompt or pipeline until eval scores improve. Why it matters: the only honest way to know your "improvement" actually improved things.
How to read this list
Two passes:
-
Skim it now. Do not memorise. Just notice the categories. You now have rough mental shelves to put new terms on when you encounter them.
-
Come back to it. When you read an article tomorrow that says "we used a 7B fine-tuned model with RAG over a vector DB and tool calling for the agent loop", every word in that sentence has an entry here. Look them up. Two minutes of glossary, then back to the article.
Vocabulary is half the battle when learning any field. Especially in a field that talks about itself as much as AI does.
Next stop on the roadmap: the prompt engineering toolkit. The one skill that moves you from "I have read about AI" to "I get useful work out of AI".