Glossary A–Z

Plain-language definitions of the AI terms you will meet in these docs and at work. Use search (/) to jump to any term. Links point to the page that explains the term in depth.

A B C D E F G H I J K L M N O P Q R S T U V W Z

A

A2A (Agent2Agent protocol): An open protocol for agents built by different vendors or teams to discover each other and collaborate on tasks. Complements MCP (agent↔tools).
ACP (Agent Client Protocol): An open protocol connecting editors/IDEs to coding agents, so you can use an agent of your choice inside an editor. Supported by several IDEs, including JetBrains IDEs and Xcode. Page 06.
Agent: A model that uses tools in a loop (think → act → observe) to achieve a goal. Page 08.
Agent harness: The software around a model that turns it into an agent: system prompt, tools, loop, permissions, context management. The same model can behave very differently in different harnesses.
Agentic coding: Software development where AI agents carry out multi-step tasks (editing files, running builds and tests) under human supervision.
AGENTS.md: An open convention: a Markdown file of project instructions (commands, conventions, boundaries) that many coding agents read automatically. Page 07.
Agent Skills: An open format for packaging know-how as a folder with a SKILL.md file plus optional scripts and references, loaded on demand. Page 07.
AGI (Artificial General Intelligence): A hypothetical AI matching humans across essentially all cognitive tasks. Its definition and timeline are debated.
AI (Artificial Intelligence): The broad field of making machines perform tasks associated with human intelligence. Page 01.
Alignment: Making AI systems behave according to human intentions and values: helpful, honest, harmless.
Attention: The Transformer mechanism that lets each token weigh and use information from other tokens in the context. Page 02.
Automation bias: The human tendency to over-trust automated output. A key risk when reviewing AI work.
Autoregressive: Generating output one token at a time, each conditioned on everything generated so far.

B

Base model: A model after pre-training only. It continues text but isn't tuned to follow instructions or chat.
Benchmark: A standard test set for comparing models (coding, maths, reasoning). Useful but imperfect. Always test on your own tasks.
Bias (in AI): Systematic skew in outputs inherited from training data or design, e.g. stereotypes or unequal performance across groups.
BPE (Byte-Pair Encoding): A common tokenisation algorithm that builds a vocabulary by merging frequent character sequences.

C

Chain of thought (CoT): Having the model reason step by step before answering. Reasoning models do this internally.
Chunking: Splitting documents into pieces for embedding and retrieval in RAG.
Classification: An ML task that assigns inputs to categories (spam/not spam, ticket type).
Compaction: Summarising older conversation history to free context space during long agent sessions.
Computer use: Agents operating a GUI (browser or desktop) via screenshots, clicks and typing.
Context: Everything the model sees for one response: system prompt, rules, history, files, tool results, your prompt. Page 04.
Context engineering: The practice of curating what goes into the context: write, select, compress, isolate.
Context rot: Quality degradation as a session accumulates long, noisy history.
Context window: The maximum number of tokens a model can handle at once (input + output).
Cosine similarity: A measure of how similar two vectors (embeddings) are, based on the angle between them. Used in semantic search.
Custom agent: A named configuration of instructions, allowed tools and optionally a model, for a specific role (planner, reviewer).

D

Deep learning: Machine learning with multi-layer neural networks.
Diffusion model: A generative model (common for images/video) that learns to turn noise into data step by step.
Distillation: Training a smaller "student" model to imitate a larger "teacher" model.
DPO (Direct Preference Optimization): A post-training method that tunes a model directly on preferred-vs-rejected answer pairs, without a separate reward model.

E

Elicitation (MCP): An MCP client feature that lets a server ask the user for additional input mid-task. Page 09.
Embedding: A vector of numbers representing the meaning of a token, text or code. Similar meanings get nearby vectors.
Emergent abilities: Capabilities that appear as models scale, without being explicitly trained for.
Epoch: One full pass through the training dataset.
Evals: Systematic tests of AI system quality: datasets, rubrics, automated grading. Level 3.

F

Few-shot prompting: Including a few examples in the prompt so the model copies the pattern.
Fine-tuning: Further training a pre-trained model on specific data to specialise it.
Foundation model: A large general-purpose model adaptable to many tasks.
Frontier model: One of the most capable models available at a given time.
Function calling / tool calling: A model API feature where the model outputs a structured request to call a defined function. The application executes it.

G

Generative AI (GenAI): AI that creates new content: text, code, images, audio, video.
GGUF: A file format for (often quantised) model weights used by llama.cpp and many local runners.
GPU: A graphics processor. Its massively parallel maths is ideal for training and running neural networks.
Grounding: Giving the model authoritative information (docs, code, data, tool results) so its answers are based on facts.
Guardrails: Checks around a model that block or fix unsafe or invalid inputs and outputs.

H

Hallucination: Fluent, confident output that is false or fabricated. Page 14.
Hooks: Commands that run automatically on agent lifecycle events (before/after tool calls, on stop). They give deterministic guarantees.
Host (MCP): The AI application (IDE, chat app, agent) that connects to MCP servers through clients.
Human-in-the-loop: Designs where humans approve, correct or guide AI actions at key points.
Hyperparameter: A setting chosen before training (learning rate, batch size), as opposed to learned parameters.

I

Inference: Running a trained model to produce output.
Inline edit: An IDE mode where you select code, give an instruction, and accept or reject a proposed diff.
Instruction tuning: Fine-tuning on instruction→response examples so a model follows requests (part of SFT).

J

Jailbreak: A prompt crafted to make a model ignore its safety rules.
JSON mode / structured output: Constraining model output to valid JSON, often matching a given JSON Schema.
JSON-RPC: A lightweight remote-procedure-call format using JSON. The message format of MCP and LSP.

K

Knowledge cutoff: The date after which a model has no training data. Newer facts must come from context or tools.
KV cache: Stored attention keys/values from previous tokens that speed up generation. Level 4.

L

Latency: Time until a response (or its first token) arrives.
LLM (Large Language Model): A large neural network trained on text and code to predict the next token. It powers chat and coding assistants.
LLM-as-judge: Using a model to grade other model outputs against a rubric. Powerful, but it has biases.
LoRA (Low-Rank Adaptation): An efficient fine-tuning method that trains small add-on matrices instead of all weights.
Lost in the middle: The tendency of models to under-use information placed in the middle of long contexts.
LSP (Language Server Protocol): The protocol between editors and language servers (e.g. Metals for Scala). It inspired MCP's design.

M

Machine learning (ML): Systems that learn patterns from data rather than following hand-written rules.
MCP (Model Context Protocol): An open standard for connecting AI applications to tools and data via servers exposing tools, resources and prompts. Page 09.
MCP server: A program exposing capabilities to AI apps over MCP, either locally via stdio or remotely via HTTP.
Memory (product feature): Facts an AI product stores and re-inserts into future prompts. It is not model learning.
Metals: The Scala language server used by VS Code and other editors. Recent versions include an MCP server for agents. Page 10.
Mixture of Experts (MoE): An architecture where only some sub-networks ("experts") activate per token, giving large capacity at lower compute cost.
MLX: Apple's open-source machine-learning framework optimised for Apple silicon.
Model card: Documentation of a model's intended use, training data, performance and limitations.
Multimodal: Handling multiple data types (text, images, audio, video).

N

Neural network: Layers of simple mathematical units whose connection strengths (weights) are learned from data.
Next-token prediction: The core LLM task: predict the probability of each possible next token.
NLP (Natural Language Processing): The field of computers working with human language.

O

Open-weight model: A model whose weights are published for download and self-hosting (licences vary).
OpenAI-compatible API: A widely copied HTTP API shape for chat completions, supported by many providers and local runners.
Orchestrator: An agent or program that coordinates other agents or steps in a workflow.
Overfitting: When a model memorises training data and performs poorly on new data.

P

Parameters / weights: The learned numbers inside a model. Model size is usually quoted in parameters (e.g. 8B = 8 billion).
Perplexity (metric): A measure of how well a language model predicts text. Lower is better.
Pre-training: The first, largest training phase: next-token prediction on huge datasets.
Progressive disclosure: Loading information only as needed, e.g. skills exposing only name and description until relevant.
Prompt: The input you give a model. Page 03.
Prompt engineering: The craft of designing prompts that reliably produce desired outputs.
Prompt file: A saved, reusable prompt invoked by name (slash command).
Prompt injection: Malicious instructions embedded in content the model processes, causing it to act against the user. "Indirect" when they arrive via documents, web pages or tool results.
Prompts (MCP): Reusable prompt templates exposed by an MCP server.

Q

Quantisation: Storing weights with fewer bits (e.g. 4-bit instead of 16-bit) to shrink models and speed them up, at some quality cost.
Query, key, value: The three vectors each token produces in attention: what it looks for, what it offers, what it passes on.

R

RAG (Retrieval-Augmented Generation): Retrieving relevant documents (often by embedding search) and adding them to the prompt so answers are grounded. Level 2.
Reasoning model: A model trained to "think" (generate internal reasoning) before answering, trading latency for accuracy on hard problems.
Red-teaming: Deliberately attacking a system to find safety and security weaknesses.
Regression (ML): Predicting a continuous number (price, duration).
Reinforcement learning (RL): Learning by trial and error from rewards.
Re-ranking: A second retrieval step that reorders candidate documents by relevance using a stronger model.
Resources (MCP): Read-only data exposed by an MCP server via URIs.
RLHF: Reinforcement Learning from Human Feedback: tuning a model using human preference judgements.
Roots (MCP): Directories or projects the host allows a server to operate within.

S

Sampling (decoding): Choosing the next token from the model's probability distribution, controlled by temperature, top-p, top-k.
Sampling (MCP): An MCP feature letting a server request a completion from the host's LLM.
Scaling laws: Empirical relationships showing model performance improves predictably with more parameters, data and compute.
Self-supervised learning: Learning where labels come from the data itself (e.g. the next word).
Semantic search: Searching by meaning using embeddings, rather than exact keywords.
SFT (Supervised Fine-Tuning): Fine-tuning on curated example responses.
Skill: See Agent Skills.
Slopsquatting: Registering malicious packages under names that AI models commonly hallucinate.
stdio transport: MCP transport where the host launches the server as a local process and talks over standard input/output.
Stop sequence: A string that ends generation when produced.
Streamable HTTP: MCP transport for remote servers over HTTP, with streaming support.
Streaming: Receiving output token by token as it is generated.
Structured output: See JSON mode.
Sub-agent: An agent delegated a sub-task by a main agent, working in its own context and returning a summary.
Supervised learning: Learning from labelled input→output examples.
Synthetic data: Data generated (often by AI) for testing, evaluation or training.
System prompt: High-priority instructions setting a model's role, rules and behaviour for a conversation.

T

Temperature: A sampling setting: low means focused and repeatable, high means varied and creative.
Test-time compute: Spending more computation during inference (thinking, multiple attempts, verification) to improve answers.
Throughput: How many tokens or requests a system processes per second.
Token: A chunk of text (word piece, symbol, whitespace) that models read and write. About 4 characters of English on average.
Tokenizer: The component that converts text to token IDs and back.
Tool: A function an agent can call (read file, run tests, query DB). In MCP, a server-exposed callable with a JSON Schema.
Top-k / Top-p: Sampling limits: only consider the k most likely tokens, or the smallest set whose probabilities sum to p.
Transfer learning: Reusing knowledge from one task or model to accelerate learning another.
Transformer: The neural architecture (2017) based on attention that underlies modern LLMs.

U

Unsupervised learning: Finding structure (clusters, anomalies) in unlabelled data.

V

Vector: An ordered list of numbers. Embeddings are vectors.
Vector database: A store optimised for similarity search over embeddings (e.g. pgvector, Qdrant).
Vibe coding: Informal term for building software by prompting AI and accepting output with little review. Fine for throwaway prototypes, risky for production.
Vision-language model (VLM): A model that understands images together with text.

W

Weights: See Parameters.
Workflow (vs agent): A predefined sequence of LLM calls and code steps. An agent decides its own steps dynamically. Workflows are more predictable.

Z

Zero-shot: Asking a model to do a task with no examples in the prompt.