AI Glossary

Every term you'll meet in papers, launch posts, and interviews — defined in plain English, with the practical “so what” included.

102 terms

A

Ablation: Removing one component at a time and re-measuring, to learn what actually contributes. Applies to prompts as much as architectures — most 4,000-word prompts fail their first ablation.
Adapter: A small trained module (like a LoRA) attached to a frozen base model to specialize it. Megabytes instead of gigabytes, hot-swappable per request in modern serving stacks.
Agent: An LLM run in a loop with tools: it observes a goal, chooses an action (like calling an API), sees the result, and repeats until done. The autonomy to choose and sequence actions is what separates an agent from a chatbot.
Agentic AI: The branch of AI focused on systems that act — planning multi-step tasks, using tools, and operating with varying levels of autonomy — rather than only answering questions.
AGI (Artificial General Intelligence): AI matching or exceeding human capability across most cognitive work, rather than narrow tasks. Definitionally contested — which is half the discourse about it.
AI Act (EU): The EU's risk-tiered AI regulation: prohibited uses, heavy obligations for high-risk systems (documentation, human oversight, testing evidence), transparency duties for chatbots and generated content.
Alignment: The problem of making AI systems reliably pursue what their operators (and society) actually intend, including training techniques like RLHF and DPO, and the broader research field studying it.
Attention: The transformer mechanism that lets each token look at every other token and pull in relevant context via learned relevance weights. The reason 'it' can find what it refers to three sentences back.
Autoregressive: Generating output one token at a time, each conditioned on everything before it. Why LLM latency scales with answer length, and why the first token takes longest to appear.

B

Base model: A model trained only to predict the next token on raw text, before instruction tuning. Fluent but not helpful — prompt it with a question and it may continue with more questions.
Batch inference: Processing many requests together without a latency requirement, typically at ~50% discount on provider batch APIs. The right home for any AI workload a user isn't actively waiting on.
Benchmark: A standardized test set for comparing models (MMLU, SWE-bench, GPQA). Useful directionally, but contaminated by training data often enough that your own eval set is the only score that matters.
BM25: The classic keyword-relevance algorithm behind traditional search. Still essential in hybrid retrieval because embeddings miss exact identifiers like error codes and SKUs.

C

Canary deployment: Rolling a change to a small traffic slice first, with automatic rollback on metric regression. For LLM systems: the safety net for prompt, model, and index changes alike.
Chain-of-thought (CoT): Prompting a model to reason step by step before answering, which measurably improves accuracy on math and logic. Reasoning models now do this internally.
Chunking: Splitting documents into pieces before embedding them for retrieval. Chunk size, boundaries, and overlap are the highest-leverage (and least evaluated) knobs in most RAG systems.
Constitutional AI: Anthropic's technique of training models to critique and revise their own outputs against a written set of principles, reducing dependence on human labels for harmlessness.
Context engineering: The discipline of deciding what goes into a model's context window — retrieval, memory, tool results, instructions — and in what order. The successor buzzword to prompt engineering, and genuinely broader.
Context window: The maximum tokens a model can consider at once — prompt plus output. Exceed it and the request fails or history silently truncates, which is how chatbots 'forget' early instructions.
Continuous batching: The serving technique where finished sequences exit a GPU batch and new requests join every decode step, instead of waiting for the whole batch to finish. Standard in vLLM-class servers; 2–4x throughput vs static batching.
Cosine similarity: A measure of the angle between two embedding vectors — 1 means same direction, 0 unrelated. The standard way to score semantic similarity in retrieval.
Cross-encoder: A model that reads a query and a document together to score relevance — far more accurate than comparing embeddings, but too slow for first-pass search. Used to re-rank retrieval candidates.

D

Data flywheel: The loop where product usage generates outcome-labeled data that improves the model, which improves the product, which generates better data. Mechanical pipelines, not aspiration, make it real.
Decoding: The token-by-token generation phase of inference, after the prompt is processed. Sequential and memory-bound, it's where most serving latency lives.
Distillation: Training a small model on a large model's outputs so the small one approximates the big one's behavior on a narrower task at a fraction of the cost.
DPO (Direct Preference Optimization): A preference-tuning method that trains directly on chosen-vs-rejected response pairs, replacing the more complex RLHF-with-PPO pipeline for most alignment work.
Drift: Gradual change degrading a deployed system: input distributions shift, providers update models, indexes stale. Caught by canary probes and baseline-relative monitoring, not by user complaints — ideally.

E

Embedding: A dense vector representing text (or images) so that similar meanings land close together in vector space. The foundation of semantic search, clustering, and RAG retrieval.
Emergent capability: An ability that appears at scale without being explicitly trained — in-context learning being the canonical example. Contested territory: some 'emergence' is an artifact of how benchmarks are scored.
Eval / eval set: A versioned collection of test inputs with expected outputs or grading rubrics, scored on every change to a prompt, model, or pipeline. The unit test suite of LLM engineering — no eval, no launch.

F

Few-shot prompting: Including worked examples of a task in the prompt. Beats zero-shot whenever format or edge-case handling is easier to show than describe; costs tokens on every call.
Fine-tuning: Further training a model on your own examples to change its behavior — format, style, tool use, narrow-task skill. Unreliable for adding factual knowledge; that's retrieval's job.
Frontier model: The most capable model generation available at a given time (GPT, Claude, Gemini flagships). Frontier status is a treadmill measured in months.
Function calling / tool use: The API pattern where a model returns a structured call like getWeather(city='Paris') instead of prose; your code executes it and feeds back the result. The building block of agents.

G

GGUF: The standard file format for quantized models in the llama.cpp/Ollama ecosystem — the reason a 7B model runs on a laptop.
Golden dataset: A frozen, versioned eval set drawn from real traffic, covering the ugly tail, sized for signal. The difference between measuring quality and performing measurement.
Grounding / groundedness: Whether an answer's claims are supported by provided sources. The core quality metric for RAG systems, checkable automatically by a second model pass.
Guardrails: Checks around a model rather than in its prompt: input filters, output validators, PII scanners, tool allowlists, approval gates. The prompt asks nicely; guardrails enforce.

H

Hallucination: A model producing fluent, confident, wrong output — the inherent result of training for plausible next tokens rather than verified facts. Mitigated by retrieval, citations, validation, and honest UX; never fully eliminated.
HNSW: Hierarchical Navigable Small World — the graph-based index behind most fast approximate nearest-neighbor vector search.
Human-in-the-loop (HITL): System designs where a person reviews or approves AI outputs before they take effect. Done well, it's engineered attention (risk-ranked queues, canary items); done badly, it's rubber-stamping theater.
Hybrid search: Combining vector (semantic) and keyword (BM25) retrieval and merging results. The default for production RAG, because each catches what the other misses.

I

In-context learning: A model picking up a task from examples in the prompt alone, no weight updates. The capability that makes few-shot prompting work.
Inference: Running a trained model to get outputs (as opposed to training it). Where all production LLM cost and latency lives.
Inference-time compute: Spending more computation at answer time (longer reasoning, multiple samples, search) to improve quality — the scaling axis that reasoning models exploit.
Instruction tuning: The fine-tuning stage that turns a base text-predictor into an assistant that follows instructions — supervised examples plus preference optimization.

J

Jailbreak: A prompt crafted to make a model ignore its safety training or system instructions. Defense is layered (input screening, output filters, least-privilege tools), never prompt-only.
JSON mode / structured output: Provider features that constrain model output to valid JSON or a supplied schema. Always still validate in code — and handle the truncated-mid-object case.

K

KV cache: Per-token key/value tensors cached during generation so each new token doesn't recompute attention over the whole prompt. Its memory footprint — not compute — usually caps how many requests a GPU can serve.

L

Latency (TTFT / total): Time-to-first-token is how long before output starts appearing; total latency is the full generation. Streaming makes TTFT the number users actually feel.
LLM-as-judge: Using a model to grade another model's outputs at scale. Powerful but biased (position, length, self-preference) — calibrate against human labels and randomize comparisons.
LoRA: Low-Rank Adaptation: fine-tuning tiny adapter matrices while freezing the base model — under 1% of parameters, single-GPU training, megabyte artifacts you can hot-swap per task.
Lost in the middle: The measured tendency of models to recall information at the start and end of a long context better than the middle. Why retrieval discipline beats context stuffing.

M

MCP (Model Context Protocol): An open standard for connecting AI applications to tools and data sources, so integrations are built once rather than per-app. The USB analogy: one port, many devices.
Mixture of Experts (MoE): An architecture that activates only a few expert subnetworks per token, giving big-model quality at a fraction of the compute — but all experts must still fit in memory.
Model card: A model's documentation: training data character, intended use, limitations, benchmark results, license. Read the license twice.
Model routing: Sending each request to the cheapest model that clears its quality bar — small models for easy intents, frontier for hard ones. The workhorse of LLM cost optimization.
Multimodal: Models that accept more than text — images, audio, video — in the same conversation. Image inputs are tokenized too, and cost real money per image.

N

Needle in a haystack: The eval that hides a fact in a long context and asks the model to find it. Vendors ace the synthetic version; real-world long-context recall remains messier.

O

Observability (LLM): Traces, token costs, quality scores, and drift monitors for AI systems — seeing meaning, not just status codes. What separates debugging from guessing.
Open weights: Model parameters you can download and run on your own hardware (Llama, Mistral, Qwen, Gemma, DeepSeek). Distinct from open-source training data or code. Control and privacy in exchange for operating it yourself.
Orchestration: The code coordinating multi-step LLM workflows: sequencing calls, managing state, retries, tool execution. Frameworks help prototypes; production systems usually want it explicit and debuggable.
Overfitting: Learning the training data instead of the underlying task — great scores in practice, poor on new data. Its LLM-era cousin: prompts tuned to death on five examples.

P

Paged attention: vLLM's virtual-memory-style KV-cache management: non-contiguous blocks eliminate fragmentation, fitting far more concurrent requests per GPU.
PII redaction: Removing or pseudonymizing personal data (names, emails, account numbers) before it reaches a model, logs, or training sets. A compliance requirement and an easy place to fail silently.
Pipeline (LLM): Multiple model calls composed into stages — extract, then reason, then validate — each independently evaluable. The alternative to one mega-prompt doing many jobs badly.
Post-training: Everything done to a model after pretraining: instruction tuning, preference optimization, safety training. Increasingly where model quality differentiation comes from.
Prefill: The parallel processing of the entire prompt before generation begins. Compute-bound (vs memory-bound decoding); its duration sets time-to-first-token.
Prefix caching: Reusing the computed KV state of repeated prompt prefixes across requests, at steep discounts. Why stable content (system prompt, examples) should come first in your prompt and volatile content last.
Pretraining: The massive next-token-prediction phase over trillions of tokens that gives a model its raw capability, before any tuning makes it useful as an assistant.
Prompt engineering: Designing model instructions systematically: structure, examples, constraints — with versioning and evals, not vibes. Half craft, half software discipline.
Prompt injection: Untrusted content smuggling instructions into a model's context ('ignore previous instructions and…'). The web's XSS moment for AI; defended with delimiting, least-privilege tools, and output validation — never prompts alone.

Q

Quantization: Storing model weights at lower precision (4–8 bit instead of 16) to cut memory 2–4x with small quality loss. What makes local inference practical.

R

RAG (Retrieval-Augmented Generation): Fetching relevant documents at query time and having the model answer from them — the standard pattern for giving LLMs current, private, or citable knowledge without retraining.
Re-ranking: A second-pass model scoring retrieved candidates more carefully than embedding distance can, keeping only the best few. Often the single biggest RAG quality upgrade.
Reasoning model: Models trained to spend variable 'thinking' computation before answering (OpenAI o-series, Claude extended thinking, DeepSeek-R1). Better at hard problems; slower and costlier per query.
Red teaming: Systematically attacking your own AI system — jailbreaks, injection, data extraction — before others do. A program with a cadence and regression suite, not a pre-launch checkbox.
Refusal: A model declining a request, by safety training or policy. Over-refusal is a product bug worth measuring alongside under-refusal.
Retrieval recall@k: The fraction of queries whose needed evidence appears in the top k retrieved chunks. The first metric to check when RAG answers go wrong — generation can't cite what retrieval never fetched.
RLHF: Reinforcement Learning from Human Feedback: humans rank outputs, a reward model learns those preferences, and the LLM is optimized against it. The technique that made raw predictors into helpful assistants.

S

Sampling (temperature / top-p): The randomness controls of generation. Temperature reshapes the token distribution; top-p truncates it to the most probable set. Near-zero for extraction and code; higher for creative work.
Sandbox: An isolated execution environment (containers, restricted networks, resource caps) where agent actions can't reach anything they shouldn't. The security boundary that prompts pretend to be.
Scaling laws: The empirical finding that model loss falls predictably with more compute, parameters, and data — and (via Chinchilla) that smaller models trained on more tokens often beat bigger undertrained ones.
Semantic layer: Governed definitions of business entities and metrics ('active customer', 'net revenue') that a text-to-SQL system targets instead of raw tables. Collapses the model's search space and the org's metric arguments simultaneously.
Semantic search: Retrieval by meaning (via embeddings) rather than keywords — finds relevant passages even with zero word overlap.
Serving: The infrastructure that runs models in production: batching, caching, routing, autoscaling. Where 'it works in the demo' meets physics and unit economics.
Shadow deployment: Running a candidate model/prompt on live traffic without serving its outputs, to compare behavior safely before cutover.
Speculative decoding: A small draft model proposes several tokens; the large model verifies them in one parallel pass. Identical output, 2–3x faster — a pure serving win.
Stale-while-revalidate: Serving cached content instantly while refreshing it in the background — the caching semantics behind ISR and most 'live' content sites, including this one.
Streaming: Sending tokens to the client as they're generated instead of waiting for completion. The difference between an 8-second wait and a 300ms one, perceptually.
Supervised fine-tuning (SFT): Training on curated prompt-response pairs so the model imitates demonstrated behavior — the first stage of turning a base model into an assistant, and the standard tool for teaching format and style.
Sycophancy: A model's tendency to agree with the user's stated views or flatter their premise rather than be accurate — a measured, trainable-against failure mode, and a real risk in judge models.
Synthetic data: Training data generated by models rather than collected from humans — now a major share of post-training corpora, powerful but prone to amplifying the generator's blind spots.
System prompt: Standing instructions framing an entire conversation: persona, rules, output format. Weighted heavily by training but not a security boundary — assume it can leak, and keep secrets out.

T

Token: The unit models actually read — subword chunks, roughly ¾ of an English word each. Context windows, pricing, and rate limits are all denominated in tokens.
Tokenizer: The algorithm (typically BPE) splitting text into tokens. Different per model family, which is why the same text costs different amounts on different providers.
Tool calling accuracy: How reliably an agent picks the right tool with valid arguments. The metric that decides whether an agent feels magical or maddening; improved with crisp tool descriptions, tight schemas, and per-tool evals.
Trace: The full recorded tree of one AI request: prompts, retrievals, model calls, tool executions, costs. The unit of LLM observability — without traces, debugging is archaeology.
Transformer: The neural architecture behind modern LLMs: stacked self-attention and feed-forward layers processing all tokens in parallel. Introduced in 2017's 'Attention Is All You Need'.

V

Vector database: A store optimized for embedding vectors and fast approximate nearest-neighbor search (pgvector, Qdrant, Pinecone, Weaviate). Under a few hundred thousand vectors, Postgres with pgvector is usually plenty.
vLLM: The leading open-source LLM serving engine, known for continuous batching and paged KV-cache management. The default answer to 'how do we self-host this model'.

Z

Zero-shot: Asking a model to do a task with instructions only, no examples. The baseline to beat before spending tokens on few-shot or money on fine-tuning.