Reference

Glossary

Short definitions, written to be said out loud in a meeting. The badge shows which track covers the term properly.

The basics

Machine learningBeginner: Deriving the rules from examples instead of writing them. You give it inputs and correct answers, and it finds a function that connects them.
Deep learningBeginner: Machine learning using neural networks with many layers. The approach behind essentially every modern result.
ModelBeginner: A file of numbers, called weights, plus the code to run them. Fixed after training. It learns nothing from your conversation.
Generative AIBeginner: Models that produce content, such as text or images, rather than a label or a score.
Large language modelBeginner: A model trained on a very large amount of text to predict the next token. Everything else it appears to do follows from that.
TokenBeginner: The unit a model reads and writes. A chunk of characters, about four on average. You are billed per token in both directions.
Context windowBeginner: The maximum number of tokens the model can hold at once. Shared by your instructions, retrieved documents, tool results and the reply.
HallucinationBeginner: Confident output that is false. Not a bug in the usual sense: producing true text and plausible text are the same operation to the model.
TransformerIntermediate: The architecture behind modern language models, built around attention. Introduced in 2017.
AttentionIntermediate: The mechanism where every token scores every other token, then absorbs a weighted blend of them. It is how a word picks up its context.
Weights and parametersBeginner: The numbers inside a model, set during training. "70B parameters" means seventy billion of them.
InferenceBeginner: Running a trained model to get an output. The thing you pay for in production, as opposed to training.

Building with models

Prompt engineeringBeginner: Writing the instruction well. Matters, and stops being the main lever as soon as a system has tools and multiple turns.
Context engineeringIntermediate: Deciding what occupies the context window on each call. The successor discipline to prompt engineering, and the one to get good at.
EmbeddingIntermediate: Text converted into a list of numbers positioned so similar meanings sit close together. The basis of semantic search.
Vector databaseIntermediate: A store built to find the nearest embeddings to a query quickly, across millions of entries.
RAGBeginner: Retrieval augmented generation. Find the relevant text, put it in the prompt, then answer. An open-book exam for the model.
ChunkingIntermediate: Splitting documents before embedding them. Where most retrieval quality is won or lost.
RerankingIntermediate: Retrieving many candidates cheaply, then scoring them with a better model and keeping the top few. Usually the largest single quality gain available.
Fine-tuningIntermediate: Further training on your own examples. Good for style, format and behaviour. A poor and expensive way to teach facts.
Knowledge graphIntermediate: Facts stored as nodes and the relationships between them as edges, so you can follow connections rather than search text.
GraphRAGAdvanced: Building a knowledge graph from your documents, summarising its clusters, and answering from those as well as from retrieved text.
Recursive language modelAdvanced: Leaving a very large input as a variable in a programming environment and letting the model write code to examine it, calling itself on pieces. Research, not yet standard practice.

Agents and harnesses

ToolBeginner: A function described to the model in words so it can ask for it by name. The description is the entire interface.
MCPIntermediate: Model Context Protocol. An open standard for exposing tools and data to any AI application, so a server you write works across clients.
AgentBeginner: A model calling tools in a loop until a stop condition is met. No extra intelligence is implied by the word.
WorkflowBeginner: The same pieces with the order of steps fixed by you in advance. Cheaper, faster and more debuggable than an agent. Usually the right answer.
Agentic AIIntermediate: The umbrella term for systems built this way, where the model chooses the steps rather than following a script.
HarnessAdvanced: Everything around the model: prompts, tool definitions, context policy, limits, sandbox, retries, recovery. Shorthand: agent = model + harness.
Harness engineeringAdvanced: Designing that scaffolding. Where nearly all of your engineering leverage sits, because the model is the part you cannot change.
Loop engineeringAdvanced: Designing the runtime cycle that drives the agent, so you stop being the one who prompts it. Agent loop, verification loop, event-driven loop, hill-climbing loop.
SubagentIntermediate: A separate agent with its own context, given a narrow brief. Mainly a way to buy context capacity.
Context compactionAdvanced: Summarising or discarding earlier context when the window fills, so a session can continue. Where long sessions quietly lose details.
SkillIntermediate: A repeatable procedure packaged under a name so it loads when relevant, instead of sitting in every prompt.
HookIntermediate: A command that fires automatically around an action, such as formatting after every edit. Deterministic, so it does not rely on the model remembering.

Measuring

BenchmarkIntermediate: A fixed public set of tasks with known answers, used to compare models. Weak evidence about your own workload.
EvalIntermediate: The same idea applied to your system and your cases. The thing that turns changes into engineering rather than guessing.
LLM as a judgeIntermediate: Using a model with a rubric to grade output that has no single correct string. Scales well, and needs checking against human grades.
ContaminationAdvanced: Test cases leaking into training data or into the prompt. The score rises and nothing improved.
Eval awarenessAdvanced: A model recognising it is being tested and behaving differently from how it behaves in production.
SWE-benchIntermediate: Real GitHub issues, scored by whether the project's own tests pass afterwards. The common reference for coding agents.

Terms people mix up

Not the same	The difference
Prompt engineering vs context engineering	One is writing a good instruction. The other is deciding what the window holds on every call, and it has to be redecided each turn.
Agent vs workflow	Who picks the order of steps. The model picks, or you picked in advance.
Harness vs loop	The harness is the static scaffolding. The loop is the runtime cycle that runs inside it.
Fine-tuning vs RAG	Fine-tuning changes behaviour and style. RAG supplies facts at answer time. Facts go stale, behaviour does not.
Benchmark vs eval	Someone else's tasks for shortlisting. Your tasks for deciding.
Vector search vs knowledge graph	Finding passages that resemble your words, against answering questions about how things connect.
Tokens vs words	A token is roughly four characters. A long word can be several tokens, and code tokenises worse than prose.

Maintained by the AI team. Corrections and additions are welcome as pull requests.