Every term used in the course, in one line, with a link to the lesson that explains it.
A
Adapter — A small set of extra weights trained and attached to a model that otherwise stays unchanged, so its behavior changes without retraining the whole model. Fine-tuning, LoRA and QLoRA
Agent — A system in which a model, in a loop, chooses the next action until it decides it is done or hits a stop condition. From LLM app to agent
Agent loop — The repeating cycle behind an agent: ask the model, run the tools it asked for, feed the results back and repeat, until it is done or hits a set limit. From LLM app to agent
Agent profile — In Tack, a reusable package of instructions, allowed tools and limits that is copied into each new piece of work when it is created (Agent Runners & Fleet Execution). Implementation walkthrough
Agent Skill — A folder with a SKILL.md file (a name, a description and instructions) plus optional scripts and reference files, which an agent loads only when a task needs it. Coding agents: harnesses and skills
AGENTS.md — A Markdown file at the root of a code repository, in an open shared format, that tells coding agents how to work in that project. Coding agents: harnesses and skills
AI winter — A period of sharply reduced funding and interest in AI after promises outran results; the two main ones began in the 1970s and in 1987. A short history of AI
Ambiguous outcome — A run where you cannot tell whether its effects in the outside world happened or not, so it should stop for a person to review instead of being retried. Durable agent execution
Approval — A saved request for a person to decide something, which survives restarts, has a deadline and keeps an audited record of the answer. Governance and human-in-the-loop
Attempt — One numbered try at running a piece of work, with its own expiring lock, a counter that blocks outdated writes and its own working folder. Durable agent execution
Attention — The mechanism that lets a model decide, for each token, how much to draw on every other token in the text. A short history of AI
Audit log — A record of who decided what, when and under which rule; linking each entry to the previous one with a cryptographic fingerprint (hash) makes later edits detectable. Observability, audit and reliability
B
Background agent — An agent that works on a task unwatched and returns a reviewable result, typically a pull request. From vibe coding to the lights-out factory
Backpropagation — The method neural networks use to learn: it sends the error backward from the output, layer by layer, to work out how much each weight should change. A short history of AI
Backtesting — Evaluating a system on past, already-resolved cases to estimate how it would have performed. Applied use cases
Base model — A model after its first, general training, which only continues text and has not yet been tuned to follow instructions. Models, open weights and Hugging Face
Baseline — The reference result a new model or change must beat to count as an improvement. Evaluating models
Benchmark contamination — When a test's questions leak into a model's training data, so its score reflects memorization rather than real ability. Models, open weights and Hugging Face
BM25 — A classic scoring method for keyword search, often used alongside vector search so exact words and names are not missed. Embeddings and RAG
Bot gate — A check that proves a request comes from a human before any costly work, such as a CAPTCHA followed by a signed ticket. Implementation walkthrough
Budget — A hard limit on tokens, calls, time or money, enforced before the resource is spent. Context, routing and cost
BYOK — Bring your own key: a gateway calls model providers using the customer's own account credentials rather than its own. Model gateways
C
Capability — Holding the actual means to perform an operation, such as a tool or a key; taking the means away is safer than checking a permission each time. Governance and human-in-the-loop
Chokepoint — The single code path every action must pass through, so rules and logging live in one place. Tool calling and harnesses
Chunking — Splitting documents into smaller pieces so each one can be turned into an embedding and found by search on its own. Embeddings and RAG
Closed model — A model reachable only through a provider's API; its weights are never distributed. Models, open weights and Hugging Face
Coding agent — An agent that works inside a code repository, reading files, editing code and running commands toward a task. Coding agents: harnesses and skills
Compaction — Summarizing or trimming conversation history so it fits the context window without losing what matters. Context, routing and cost
Context engineering — Deciding what goes into each model call, in what order and within what token budget. Context, routing and cost
Context window — The maximum number of tokens a model can read in one call; the model keeps nothing between calls. LLMs as software components
D
Deny-ask-allow — The three possible answers a policy gives about an action: block it, ask a person, or let it run. Governance and human-in-the-loop
Durable execution — Running a workflow so its progress is saved step by step, and after a crash it resumes where it stopped without redoing finished steps. Durable agent execution
E
Embedded runtime — A library version of an agent runtime that an application imports, so the application's own tools run under the runtime's rules and audit record. Implementation walkthrough
Embedding — A list of numbers that captures the meaning of a text, so texts with similar meanings get numbers that sit close together. Embeddings and RAG
Eval — A measurement of how well the whole system behaves on realistic cases, including the steps it took along the way, scored with imperfect checks and read with statistics. Testing and evals for agents
Eval gate — An automatic check that blocks a model or change from going live unless it passes an evaluation. Evaluating models
Execution request — A saved record asking for a piece of work to run under given rules, built so that submitting it twice still creates only one. Durable agent execution
Expert system — A 1980s-style program that encodes specialist knowledge as hand-written if-then rules; it does not learn. A short history of AI
F
Fail-closed — A safety rule that blocks the operation whenever a control errors, times out or cannot decide. Governance and human-in-the-loop
Fake model — A scripted stand-in for a real model, so tests of the code around it give the same result every time. Testing and evals for agents
Fallback — Sending a failed request to another provider or model automatically. Model gateways
Fencing token — A number that goes up each time work changes hands, so the system can reject writes from a previous owner whose lock has expired. Durable agent execution
Fine-tuning — Further training a pretrained model on your own examples to change how it behaves. Fine-tuning, LoRA and QLoRA
G
Generalization — A model performing well on data it did not see during training. Machine learning in one lesson
GGUF — A single-file model format used by llama.cpp and similar tools to run models locally, holding the weights and their metadata, usually quantized. Models, open weights and Hugging Face
Golden file — A saved copy of the expected output; the test checks that the real output matches it exactly. Testing and evals for agents
Golden set — Small set of inputs with expert-approved answers, used to judge whether a system is good enough to ship. Applied use cases
Guardrail — A broad term for any control that filters or blocks inputs, outputs or actions; ask where it applies and what happens when it fails. Governance and human-in-the-loop
H
Hallucination — A fluent, confident answer that is not supported by facts or sources. LLMs as software components
Handoff — The structured piece of work one agent produces and passes on for the next agent to use. Multi-agent systems
Harness — The software around the model that runs its loop, carries out the tools it requests, prepares what it sees and enforces limits. Tool calling and harnesses
Headless mode — Running a harness non-interactively: it takes a task, works and exits with machine-readable output. Coding agents: harnesses and skills
Held-out data — Examples kept out of training and used only to measure the model. Evaluating models
Hook — A command the harness runs automatically at set moments in its work, whatever the model decides. Coding agents: harnesses and skills
Hugging Face Hub — A platform that hosts models, datasets and demos, each with its own documentation, versions and license. Models, open weights and Hugging Face
Human-in-the-loop — A supervision model where certain actions wait for an explicit human decision. Governance and human-in-the-loop
Hybrid search — Combining vector search (by meaning) with keyword search (by exact words), usually merged into one ranked list. Embeddings and RAG
I
Idempotency — The property that performing an operation twice has the same effect as performing it once. Durable agent execution
In-context learning — A model's ability to perform a new task from instructions or examples in the prompt, without updating its weights. A short history of AI
Inference — Running a trained model to produce an output for a new input. Machine learning in one lesson
Instruct model — A base model given extra training to follow instructions and hold a conversation in a fixed chat format. Models, open weights and Hugging Face
L
Lease — A lock that expires unless its owner keeps renewing it with regular check-ins, so a worker that vanishes cannot hold work forever. Durable agent execution
Least privilege — Giving each component only the permissions, tools and credentials its job requires. Sandboxing and agent security
Lethal trifecta — The dangerous combination of private data, untrusted content and a way to send data out. Sandboxing and agent security
Lights-out factory — A production setup that runs with no people present; in software, agents write and verify code nobody reviews. From vibe coding to the lights-out factory
LLM — A large language model: a neural network trained to predict the next token, then tuned to follow instructions. LLMs as software components
LLM-as-a-judge — Using a model to grade outputs; trustworthy at scale only after its grades have been checked against human ones. Testing and evals for agents
LoRA — Low-rank adaptation: a cheaper way to fine-tune that trains small add-on matrices instead of all of the model's weights. Fine-tuning, LoRA and QLoRA
M
MCP — The Model Context Protocol: an open standard that lets AI applications connect to tools, data and prompts through one common interface. MCP, the Model Context Protocol
MicroVM — A lightweight virtual machine with its own operating-system kernel, which isolates code more strongly than a container does. Sandboxing and agent security
Model card — The document in a model repository describing intended use, limitations, data, evaluation, license and base model. Models, open weights and Hugging Face
Model gateway — A single service between your applications and many model providers, offering one API and handling keys, limits, caching and logs. Model gateways
Model routing — Assigning each request or role to a specific model, usually to balance cost and quality. Context, routing and cost
Multi-agent system — Several agents with distinct roles, tools and sometimes models, coordinated through handoffs. Multi-agent systems
Multi-tenancy — Serving several isolated customers or projects from one deployment. Serving models
O
Observability — Being able to answer new questions about system behavior from the events, traces and metrics it emits. Observability, audit and reliability
OCR — Optical character recognition: turning text in scanned images or PDFs into machine-readable text. Applied use cases
Open weights — A model whose trained parameters can be downloaded and run anywhere, regardless of whether its code or data are published. Models, open weights and Hugging Face
Open-weight model — A model whose trained weights are published for download, under a license that may still restrict use. A short history of AI
OpenAI-compatible endpoint — A model API that follows the request format OpenAI popularized for chat, so existing client code works without changes. Serving models
Output guard — Code that checks a model's full reply against rules before showing it, and replaces it when a rule fails. Implementation walkthrough
Overfitting — A model memorizing its training data instead of learning patterns that generalize. Machine learning in one lesson
P
Perceptron — Rosenblatt's 1958 single-layer model that learns weights from examples; it can only tell apart categories that a straight line (or flat plane) can separate. A short history of AI
Policy as code — Rules written as versioned files and checked by code at the point where an action happens, independent of the model. Governance and human-in-the-loop
Progressive disclosure — Loading context in stages: only names and descriptions at startup, full content when a task needs it. Coding agents: harnesses and skills
Prompt — Everything sent to the model in one call: instructions, conversation messages and any tool definitions. LLMs as software components
Prompt injection — An attack where hostile text, typed directly or hidden inside data the model reads, changes what the model does. Sandboxing and agent security
Pull-based runner — A worker that always opens the connection itself to ask for work, so the server never has to reach into its machine. Durable agent execution
Q
QLoRA — LoRA training on a compressed (quantized) copy of the model, so even large models can be fine-tuned on a single GPU. Fine-tuning, LoRA and QLoRA
Quantization — Storing a model's weights as less precise numbers, using fewer bits, to cut memory and cost at some loss of accuracy. Serving models
R
RAG — Retrieval-augmented generation: finding relevant passages in your documents and adding them to the prompt before the model answers. Embeddings and RAG
Rank fusion — Merging several ranked result lists, such as vector and keyword results, into one. Embeddings and RAG
Reasoning model — A model that generates intermediate reasoning steps before answering, trading tokens and latency for accuracy. Models, open weights and Hugging Face
Reranking — Re-scoring search results with a slower, more precise model before passing the best ones to the LLM. Embeddings and RAG
Risk classification — Sorting actions into risk classes so each class gets the minimum sufficient control. Governance and human-in-the-loop
RLHF — Reinforcement learning from human feedback: tuning a model with human preference judgments so it follows instructions. A short history of AI
Runner — A worker program that picks up work, runs it close to the code and credentials it needs, and reports back. Durable agent execution
S
Safetensors — A file format for model weights that holds only the numbers and a description of them, so opening it cannot run hidden code. Models, open weights and Hugging Face
Sandbox — An isolated environment that limits what code can reach (files, processes, network, credentials, the kernel), with a clear statement of which threats it guards against. Sandboxing and agent security
Scaling laws — Observed patterns showing that a model's error falls predictably as its size, training data and computing power grow. A short history of AI
Semantic cache — A cache that reuses an earlier answer when a new prompt means nearly the same thing, judged by comparing their embeddings. Model gateways
Spec-driven development — Development where a versioned specification, not the chat, is the source of truth an agent implements against. From vibe coding to the lights-out factory
Structured output — Making the model reply in a fixed data format defined by a schema, usually JSON Schema, so programs can read it reliably. LLMs as software components
Subagent — A separate agent loop with its own context, launched by another agent; only its result returns. Coding agents: harnesses and skills
Survivorship bias — Drawing conclusions only from cases that were published or succeeded, ignoring the cancelled or failed ones. Applied use cases
Symbolic AI — An approach that builds intelligence from explicit rules and symbols written by people, rather than learning from data. A short history of AI
T
Tamper-evident — A record whose modification is detectable, which is not the same as impossible to modify or delete. Observability, audit and reliability
Temperature — A setting that controls how random the model's next-token choice is: low gives predictable output, high gives more varied output. LLMs as software components
Token — A small chunk of text, often part of a word, that a model reads and writes and that providers charge by. LLMs as software components
Tool calling — The model replying with a structured request to use one of the tools it was shown, with arguments your program checks and then runs. Tool calling and harnesses
Trace — A step-by-step record of one run, made of linked events that show what happened at each step. Observability, audit and reliability
Training — Adjusting model weights from data so its predictions improve. Machine learning in one lesson
Transformer — The 2017 neural network design behind today's LLMs, built around attention and able to process all the tokens of a text at once. A short history of AI
U
Upsert — A write that inserts a record or overwrites it if the id exists, so repeating it never creates duplicates. Implementation walkthrough
V
Vector search — Finding the stored embeddings closest to a query's embedding, which means finding the texts closest in meaning. Embeddings and RAG
Vibe coding — Karpathy's 2025 term for building software by accepting AI-generated code without reading it. From vibe coding to the lights-out factory
Virtual key — A revocable credential issued by a gateway to a team or app, hiding the real provider keys. Model gateways
W
Workflow — A fixed sequence of steps, some of them model calls, decided by your code rather than the model. From LLM app to agent
Worktree — A separate working copy of a git repository for each task, so agents working in parallel do not touch each other's files. Sandboxing and agent security
Z
Zero data retention — A provider or endpoint commitment not to store prompts and responses. Model gateways