Glossary

164 technical words the lessons use, in plain language. Each lesson also lists the ones it uses.

A

A/B test: Showing two versions to different groups of real users and comparing a measured result, such as clicks or sales.
A2A: Agent2Agent: a protocol for agents from different makers to find each other and exchange tasks.
activation function: A simple curve such as ReLU applied after a neuron's sum. It lets stacked layers represent complex functions.
Adam: The most common optimizer. It smooths gradients and adapts the step size for each parameter.
agent: A model run in a loop that chooses its own tools and steps until the task is done.
AGENTS.md: A shared convention for a repo file with instructions for coding agents.
AGI: Artificial general intelligence: a loosely defined label for AI as capable as people across most tasks. There is no agreed test.
allowlist: A list of the only actions or sites something is permitted to use. Everything not on it is refused.
ANN: Search that returns vectors that are almost always the closest ones, much faster than checking every vector.
anomaly detection: Finding cases that look unlike normal ones, often without labeled examples of the bad kind.
API: Application programming interface: a way for one program to call another, usually over HTTP.
attention: The mechanism that lets each token weigh all earlier tokens by relevance when computing its next representation.

B

backoff: Waiting longer after each failed attempt before retrying, for example 1, 2, then 4 seconds.
backpropagation: The method that computes the gradient for every parameter by applying the chain rule backward through the network.
baseline: A simple method, such as "same as last week", that any model must beat to be worth its cost.
batch: A group of examples processed together in one step.
benchmark: A fixed test with a score used to compare models.
BM25: A classic keyword scoring method that ranks documents by matching terms.
BPE: Byte-pair encoding: a common way tokenizers build their vocabulary by merging frequent pairs of characters.

C

C2PA: A standard for attaching a signed record of where an image or video came from and how it was edited.
calibration: Whether a model's confidence matches how often it is right. A well calibrated model is right about 90 percent of the time when it says 0.9.
chain of thought: Having the model write out intermediate reasoning steps before the final answer.
chunk: A small piece of a document, sized for indexing and retrieval.
CI: Continuous integration: automatically running tests on every code change. CD deploys passing changes.
class imbalance: When one outcome is far rarer than the other, such as 100 frauds in 100,000 payments. Plain accuracy then misleads.
CLAUDE.md: A file at a repo root that Claude Code reads at the start of every session. AGENTS.md is the shared equivalent.
CNN: A network that slides small filters over an image to detect edges, shapes and objects.
cold start: The problem that a new user or item has no history, so a recommender has nothing to match.
collaborative filtering: Recommending items by finding people with similar past choices: if they liked it, you probably will too.
compaction: Summarizing older conversation so a long task fits in the context window.
computer vision: Getting models to work with images and video: classifying, locating objects and reading text.
context engineering: Deciding what goes into the model's context window, and when.
context rot: Answers getting worse as the input gets longer, even on simple tasks.
context window: The maximum number of tokens a model can look at in one call: your prompt, the conversation, tool results and the answer together.
cosine similarity: A score from -1 to 1 for how much two vectors point the same way, ignoring their length.
cross-encoder: A model that reads a query and a passage together and scores how relevant the passage is. Used for reranking.
cross-entropy: The standard loss for next-token prediction: minus the log of the probability given to the correct token.

D

data drift: Real-world inputs slowly changing from what a system was tested on, so quality falls with no code change.
decode: The second stage of generation, where the model writes one token at a time.
deepfake: A realistic fake image, video or voice made with AI to look like a real person or event.
diffusion model: An image generator trained to remove noise step by step. Generation starts from pure noise.
distillation: Training a small model to imitate a larger one.
Docker: A tool that packages software and its dependencies into a portable container.
dot product: Multiply matching entries of two vectors and add them up. Large when they point the same way.
DPO: Direct preference optimization: a simpler way to tune a model toward answers people prefer, without a separate reward model.

E

embedding: A list of numbers that represents the meaning of a piece of text or an image, so similar things sit close together.
epoch: One full pass through the training data.
eval: A repeatable test of AI output quality, run before and after every change.

F

F1: A score that combines precision (how many flagged items were right) and recall (how many right items were found).
few-shot: Giving a few worked examples in the prompt.
fine-tuning: Further training on a smaller, targeted set of examples to change behavior or style.
forecasting: Predicting a future number, such as sales, from past values.

G

git: The standard tool for tracking changes to code.
GPU: Graphics processing unit. A chip with thousands of cores, ideal for the matrix math in AI.
gradient: The direction and rate at which the loss changes when each parameter changes. Training steps against it.
gradient descent: Repeatedly nudging parameters opposite to the gradient to reduce the loss.
GraphRAG: Retrieval that first builds a graph of entities and relations, for questions that span many documents.
GRPO: Group relative policy optimization: a reinforcement learning method that scores each answer against the other answers sampled for the same prompt.
guardrail: A rule or check that limits what a system may do or output.

H

hallucination: A confident answer that is not supported by the model's knowledge or the provided sources.
harness: Everything around the model that makes it an agent: prompts, tools, rules, sandboxes, hooks, memory and checks.
HNSW: A graph-based index that finds approximate nearest neighbors quickly by jumping through layers of connections.
hook: A script the harness runs automatically at a fixed point, such as before a tool call. It enforces rules in code.
Hugging Face: A hub for sharing open models, datasets and demos, and the maker of widely used libraries.
human-in-the-loop: A design where a person approves risky steps.
hybrid search: Combining keyword search and vector search.
hyperparameter: A setting you choose before training, such as the learning rate, rather than a value the model learns.

I

in-context learning: A model picking up a task from examples inside the prompt, without any retraining.
inference: Running a trained model to produce output, as opposed to training it.
IoU: A score for a predicted box: the overlap area divided by the combined area of the predicted and true boxes. 1 is a perfect match, 0 is no overlap.

J

jitter: A little randomness added to retry waits so many clients do not retry at the same moment.
JSON: A text format for structured data: keys and values in braces, like {"name": "Ada"}.

K

knowledge cutoff: The date after which the model has seen no training data.
KV cache: Stored keys and values of earlier tokens, reused during generation so each new token is cheap to compute.

L

latency: The time you wait for a response.
leakage: When a feature or test example contains information that would not be known at prediction time, so scores look better than real use.
learning rate: How big each gradient descent step is.
least privilege: Giving a person or program only the access it needs for the job and nothing more.
LLM: Large language model: a neural network trained on huge amounts of text to predict the next token.
LLM-as-judge: Using a model to grade another model's output against a rubric.
logarithm: The power you raise a base to in order to get a number. log base 2 of 8 is 3 because 2 to the power 3 is 8.
logits: The raw scores a model produces for each possible next token, before softmax.
LoRA: A cheap fine-tuning method that freezes the model and learns small add-on matrices. QLoRA also stores the base in 4-bit.
loss: A number measuring how wrong the model's output is. Training tries to reduce it.

M

matrix: A grid of numbers. Multiplying a vector by a matrix transforms it. Model layers are mostly matrices.
MCP: Model Context Protocol: a standard for plugging tools and data into AI apps.
metadata: Extra labels stored with a document or chunk, such as its title, date or country, which let you filter results.
mixture of experts: A design with many specialist sub-networks where a router uses only a few per token, so compute is far less than the total size.
MRR: Mean reciprocal rank: the average of 1 divided by the rank of the first correct result. Higher is better.
multimodal: Handling more than one kind of data, such as text, images and audio.

N

nats: The unit of information when you use the natural logarithm. Bits use log base 2.
neural network: A function built from layers of simple units (neurons) whose weights are learned from data.
neuron: One unit in a network: it multiplies inputs by weights, adds a bias and applies an activation function.

O

OAuth: A standard way to let an app act for you without giving it your password.
object detection: A vision task that finds each object in an image and draws a box around it.
observability: Being able to see what your system did, through logs, traces and metrics.
OCR: Optical character recognition: turning an image of text into real text.
open source: Software whose code is public and can be reused under a license.
optimizer: The algorithm that turns gradients into parameter updates, such as SGD or Adam.
orchestrator: The component, often a model, that splits work and delegates it to workers.
overfitting: When a model memorizes training data and does worse on new data.

P

parameter: One learned number inside a model. Modern models have billions of them. Training adjusts them.
policy: A rule for choosing actions. In a language model, the model itself is the policy.
PPO: Proximal policy optimization: a reinforcement learning method that limits how far each update can move the model.
precision: Of the cases a system flagged, the share that were truly positive.
prefill: The first stage of generation, where the model reads the whole prompt at once.
pretraining: The first, large training stage: predict the next token across a huge amount of text.
prompt: The input text you give a model, including instructions, examples and data.
prompt injection: Untrusted text that contains instructions the model follows, such as a web page telling it to leak data.

Q

quantization: Storing weights with fewer bits (for example 4 instead of 16) to save memory at a small quality cost.

R

RAG: Retrieval-augmented generation: look up relevant text first, then give it to the model to answer from.
reasoning model: A model trained to think at length, often with RL, before answering.
recall: Of the truly positive cases, the share the system found.
reciprocal rank fusion: A way to merge two ranked result lists by adding 1 / (k + rank) for each list.
recommender: A system that suggests items such as videos or products to each user.
reinforcement learning: Learning by trial and error: take actions, get rewards, and favor what earned reward.
ReLU: An activation function that outputs the input if positive, otherwise 0.
repo: Repository: a project folder tracked by git, usually hosted on GitHub.
reranker: A second model that rescores a short list of search results by reading query and passage together.
retrieval: Finding the most relevant pieces of text for a query.
reward: A number that says how good an outcome was. RL tries to maximize it.
RLHF: Reinforcement learning from human feedback: tune a model toward answers that people rate higher.
ROI: Return on investment: what a project gains compared with what it costs.
RoPE: Rotary position embedding: a way to tell the model where each token sits by rotating its query and key vectors.
rubric: A written list of criteria used to grade an output.

S

sampling: Picking the next token at random according to the model's probabilities.
sandbox: A restricted environment where code can run with limited access to files and the network.
schema: A description of the shape of data: which fields exist and what types they have.
SDK: Software development kit: a library that wraps an API for a programming language.
segmentation: A vision task that labels every pixel by which object it belongs to.
self-attention: Attention where the tokens attend to other tokens in the same sequence.
shadow mode: Running a new system beside people on real cases without acting on its output, so you can compare it with their decisions at no risk.
SIGTERM: A signal that asks a program to shut down cleanly.
sim-to-real: The gap between a robot trained in simulation and the same robot in the real world.
skill: A folder of instructions and scripts an agent loads only when a task needs it.
softmax: A function that turns a list of scores into probabilities that add up to 1.
speech recognition: Turning spoken audio into text.
stdio: Standard input and output: how a local program talks to the program that started it, used by local MCP servers.
stop token: A special marker the model writes to say its answer is finished.
structured output: Model output that follows a schema, such as valid JSON with fixed fields.
subagent: A helper agent started by another agent for a focused job, with its own context.
SWE-bench: A benchmark that scores coding agents on real GitHub issues from open-source projects.
system prompt: Standing instructions placed at the start of every call that set the model's role and rules.

T

temperature: A setting that sharpens or flattens the probabilities before sampling. Low is predictable, high is varied.
tensor: A multi-dimensional array of numbers. The basic data type of deep learning libraries.
text-to-speech: Turning written text into spoken audio.
token: A piece of text the model reads and writes, usually a word or part of a word. About 4 characters of English on average.
tokenizer: The program that splits text into tokens and maps each one to an integer id.
tool: A function the model can ask your program to run, described by a name, description and argument schema.
tool use: The model asks your program to run a function and reads the result.
top-p: A sampling rule that only considers the smallest set of tokens whose probabilities add up to p.
trace: The full record of one run: inputs, model calls, tool calls, outputs, timing and cost.
training: Adjusting a model's parameters on data so its predictions improve.
trajectory: The sequence of steps and tool calls an agent took, not just its final answer.
transformer: The neural network architecture behind modern language models. It uses attention to relate every token to the others.

V

validation set: Data held out from training and used to tune choices and check that the model generalizes.
vector: An ordered list of numbers. Embeddings and model activations are vectors.
vector database: A database that stores embeddings and finds the nearest ones quickly.
vibe coding: Building software by prompting and accepting results with little review.
vocabulary: The full list of pieces (tokens) a model knows how to read and write.

W

weights: The learned numbers that define a trained model. A model whose weights are published is called open-weight.
word error rate: Speech recognition accuracy: substitutions, deletions and insertions divided by the number of true words.
workflow: A fixed sequence of steps written in code, with model calls at set points.
worktree: A second checked-out copy of a git repository on its own branch in its own folder.