Glossary

A decision chain ordering LLM adaptation techniques from cheapest/fastest to most expensive/slowest -- prompting, structured output, RAG, tools, then fine-tuning.

A system that repeats a plan-act-observe cycle across multiple steps, rather than producing one response to one prompt.

The repeated plan/act/observe/reflect cycle that defines what makes a system an agent rather than a single-shot model call.

A secret credential authenticating a caller to a hosted API, never hardcoded in source code.

The component that receives a request, coordinates calls to the model, retrieval, tools, and a database, and returns a response.

Finding vectors close to a query fast by accepting a small chance of missing the exact best match, instead of comparing against every stored vector.

A written explanation of a system's real design decisions -- what was chosen, why, and what its known limitations are -- not just a description of what the code does.

The role label for the model's own turns in a chat conversation, as opposed to the user's or the system's.

A mechanism letting each token look at every other token in context and weight how much each one matters to it.

A sparse vector of raw word counts over a fixed vocabulary, with word order thrown away entirely.

A model that has only been pretrained -- it completes text plausibly but has no built-in tendency to follow instructions or hold a conversation.

An n-gram precision metric (how much of the generated text's word sequences appear in the reference) commonly used for translation.

A more carefully tuned successor to TF-IDF for scoring how well a document matches a keyword query, and the sparse half of most hybrid search systems.

A subword tokenization method that starts from individual characters and repeatedly merges the most frequent adjacent pair.

Trying a cheap, fast model first and escalating to a more expensive, capable one only if its output looks insufficient.

A model losing previously learned capability while being fine-tuned on a new task or dataset.

One piece of a larger document, split up so each piece is small enough to embed and retrieve individually.

An LLM application that combines several pieces -- prompting, structured output, retrieval, tools, an agent loop -- into one working system, rather than a single isolated call.

A model filling a gap in its knowledge with a fluent, plausible-sounding but fabricated detail -- a specific flavor of hallucination.

Restricting a model's candidate next tokens at every generation step to only the ones that keep the output on a schema-valid path.

Trimming retrieved text down to what's actually relevant before it enters the prompt, instead of injecting every retrieved chunk in full.

Manipulating what accumulates in an agent's ongoing context over a long session, distinct from poisoning a retrieval system's underlying knowledge base.

The fixed maximum number of tokens a model can attend over at once, covering both the prompt and the model's own output so far.

Serving many requests' generation steps together on the same hardware, rather than processing one request at a time.

A back-and-forth exchange of turns between a user and a model, each turn tagged with a role.

A similarity score between two vectors based only on the angle between them, ignoring their length.

Three different numbers a model-serving decision trades off -- what a response costs, how long one response takes, and how many responses fit in a given time.

An organized store of data that a program can search or query.

A choice a model or system makes at some point in a process, such as which token to output next.

Stacking several independent safeguards so that no single failure is catastrophic on its own.

Finding relevant text by nearest-neighbor search over embedding vectors rather than exact keyword matching.

Two forms of prompt injection -- the user's own prompt trying to override instructions, versus untrusted retrieved or tool content carrying the injected instruction.

Training a smaller model to imitate a larger model's outputs, compressing capability into fewer parameters via training rather than reducing numeric precision.

Training directly on preference data to make a model favor the preferred response, without a separate reward model or an RL training loop.

A vector of numbers standing for a piece of text -- a word, sentence, or document -- positioned so that similar meanings end up as nearby vectors.

A model component that turns input text into a numeric representation, without generating new text itself.

A named value set outside a program's source code, in its running environment, rather than hardcoded -- the standard place to keep a secret like an API key.

A reusable structure for scoring a system's outputs against an evaluation set and a chosen set of metrics, applied consistently across projects rather than reinvented each time.

A small, fixed set of example inputs (with known-good answers or a scoring rubric) decided on before building a system, used to measure whether it actually works.

An all-or-nothing metric -- a generated answer scores 1 if it matches the reference exactly, 0 otherwise.

An agent given more autonomy or tool access than a task actually requires, turning any single compromise into a much bigger blast radius.

A retry strategy that waits longer after each successive failure, rather than retrying immediately or at a fixed interval.

A partial-credit metric balancing how much of the reference answer was captured (recall) against how much of the generated answer was actually correct (precision).

Two related RAG evaluation properties -- whether an answer avoids contradicting its retrieved context, and whether every claim in it is actually supported by that context.

Showing a model a small number of worked examples inside the prompt itself, so it infers the task's pattern without any parameter update.

A large pretrained model general enough to be adapted to many downstream tasks rather than built for just one.

A common file format for distributing quantized models for local inference.

The direction and steepness of a function's fastest increase, used to decide which way to adjust a model's parameters.

Always choosing the single highest-probability token at every generation step.

A post-training method that scores a group of sampled responses against each other's average, used in current reasoning-model training.

A deterministic post-processing check -- a value range, a required cross-field relationship -- that catches what type/schema validation alone can't express.

A model stating a plausible-sounding but false claim with the same fluent confidence as a true one.

A deliberate pause point in an agent's loop requiring a person's approval before a consequential action proceeds.

Having the model first write a hypothetical answer to a query, then searching for chunks similar to that hypothetical answer instead of the raw question.

Not affected by, or having no bearing on, some other quantity or event.

Checking untrusted input before it reaches a model, aimed at safety properties rather than just structural correctness.

Supervised fine-tuning specifically on instruction-response pairs -- the training stage that turns a base model into an instruction-following one.

A base model further trained to follow instructions and directly answer requests, rather than merely continuing text plausibly.

A technique aimed at bypassing a model's trained-in refusals or safety behavior.

A precise, machine-readable contract for a JSON object's required keys and value types.

The fixed date after which a model's training data ends -- it has no knowledge of anything that happened later.

A direct alignment method that trains on individually labeled good/bad responses, rather than requiring paired preference comparisons like DPO.

Storing each token's already-computed key and value vectors so generating the next token doesn't recompute attention over the whole sequence from scratch.

A system that assigns a probability to sequences of text, most often used by predicting the next token given the ones before it.

A language model built from a Transformer with billions of parameters, pretrained on a huge amount of text.

Granting a model or agent only the permissions and tool access a task actually requires, nothing more.

Using a language model itself to score or compare other models' outputs, instead of (or alongside) human evaluators.

A model's raw, unnormalized output score for one vocabulary entry, before softmax turns the whole set into probabilities.

Training a small pair of low-rank matrices alongside a frozen pretrained model instead of updating all its weights.

An application (often an agent framework) that connects to one or more MCP servers and uses their exposed resources, tools, and prompts.

A program that exposes resources, tools, and prompts to any MCP client over the standard protocol.

A specific piece of machinery inside a model that does one job, like attention or a feed-forward layer.

Restricting a search to documents matching a structured condition -- a category, a date range, an owner -- alongside or instead of semantic similarity.

A short, structured document a model's publisher writes describing what the model is, how it was built, and how it's meant to be used.

A standardized interface for connecting a model-calling application to external resources, tools, and prompts, so one application can talk to many independently-built servers the same way.

An architecture where a supervisor component coordinates several specialized agents working together on one task.

Embedding images and text into the same shared vector space, so a text query can retrieve relevant images or vice versa.

The full probability distribution a language model produces over every possible next token, before any token is actually chosen.

A word or piece of text a tokenizer's fixed vocabulary has no entry for.

Checking a model's generated data against its expected shape after generation, and handling a mismatch clearly rather than passing bad data downstream silently.

Two concrete ways to judge model output at scale -- deciding which of two responses is better, or scoring several specific criteria separately.

One of the many adjustable numbers inside a model, learned during training.

Searching over small, precise chunks but injecting each match's larger surrounding context into the prompt instead of the small chunk alone.

A single number summarizing how surprised a language model is by held-out text on average -- lower is better.

A fixed sequence of processing steps chained together, each step's output feeding the next.

An agent architecture where one component decides the full plan up front and a separate component carries out each step.

Pairs of responses to the same prompt, ranked better/worse by a human or another model -- the raw material reward modeling and direct alignment methods both consume.

Training a language model on next-token prediction over a huge, broad corpus, before any task-specific or instruction-following training happens.

A number between 0 and 1 measuring how likely a token or sequence is, according to the model.

The live, real-world setting where a system serves actual users, as opposed to development or testing.

Reusing a cached, already-processed prefix of a prompt instead of recomputing it on every call that shares that prefix.

When text from an untrusted source -- a document, web page, or tool result -- contains instructions the model may follow as if they came from the developer or user.

LoRA combined with storing the frozen base model's weights at reduced precision, shrinking memory further.

A system's output quality gradually degrading over time -- from a silent model update, a shifting user population, or content in the world moving past a retrieval index's freshness.

Storing a model's weights at lower numeric precision to shrink its memory footprint and speed up inference, at some cost in quality.

Turning a vague, multi-part, or poorly-phrased query into a better search query before retrieval runs.

The three vectors attention derives from each token -- what it's looking for, what it offers to be matched against, and what it contributes if matched.

A cap a provider enforces on how many requests or tokens you can send in a given time window.

An agent pattern that interleaves reasoning and acting in one loop -- think, act, observe, repeat -- rather than planning everything up front.

Two retrieval metrics measured over a search's top-k results -- what fraction of the relevant items were found, and what fraction of what was found is actually relevant.

A simple way to combine two separate ranked lists (a sparse search's and a dense search's) into one ranking, using each result's rank rather than its raw score.

A pointer to a specific piece of information elsewhere, such as a source document or an earlier message.

Actually useful for the task or question at hand, as opposed to off-topic.

A second, more expensive scoring pass over a first-stage retrieval's candidates, trading speed for precision.

Deliberately planting misleading or malicious content where a RAG system's retrieval will find and inject it.

Looking up relevant text from an external source and injecting it into the prompt before generating an answer, instead of relying only on the model's own trained-in knowledge.

A model trained to predict which of two responses a human (or another model) would prefer -- the training signal RLHF uses.

Using a trained reward model's predictions as a training signal to further train a language model via reinforcement learning.

An n-gram recall metric (how much of the reference text's word sequences appear in the generated text) commonly used for summarization.

A component that sends a request to the single best-suited handler among several available options.

Running a risky action in an isolated environment where a mistake or attack can't reach anything outside it.

The empirical pattern that a language model's loss falls smoothly and predictably as data, parameters, and compute all grow together.

Sampling several independent candidate answers to the same problem and taking the majority (or otherwise combining them), rather than trusting one greedy generation.

A training setup where the correct label at every position already exists in the raw data itself, so no human needs to add it.

Sensitive information leaking into a response, a log, or a tool call where it shouldn't have reached.

A tokenizer library that treats whitespace itself as an ordinary vocabulary symbol, so the same scheme works for languages that don't use spaces between words.

One isolated call to a model for one task, with no other pieces composed around it.

A reserved vocabulary entry with a structural role rather than a piece of ordinary text, such as marking the start or end of a sequence.

Representing an agent's possible paths as a graph with persistent state, supporting cycles, branching, and resuming after a pause.

Receiving a model's output incrementally, token by token, instead of waiting for the entire response to finish generating.

Produce a shorter version of a text that keeps its main points.

A message setting the model's overall behavior and constraints for a conversation, distinct from the user's own turns.

A knob that reshapes a next-token distribution before sampling -- low temperature sharpens it toward the top choice, high temperature flattens it toward uniform.

Spending more computation at inference time -- more samples, more search, more verification -- to reach a better answer, rather than only improving the model itself.

A word-count weighting that discounts words common across the whole corpus, so distinctive words stand out more than raw counts alone would show.

The unit of text a language model actually reads and predicts -- often a word piece, not a whole word or a single character.

The integer a tokenizer assigns to each vocabulary entry, and the actual number a model reads in and predicts.

Splitting raw text into the sequence of tokens a model actually processes.

An agent tricked into calling a real tool with attacker-chosen or otherwise harmful arguments.

A model's generated request to invoke one registered action, with typed arguments -- the same structured-output idea aimed at a callable interface instead of a document.

The application-side cycle of executing a model's requested tool call and feeding the result back to the model.

Restricting sampling to only the k highest-probability tokens before drawing from the (renormalized) distribution.

Restricting sampling to the smallest set of top tokens whose probabilities add up to at least p, then drawing from that set.

A subword tokenization method that starts from a large candidate vocabulary and prunes it down by likelihood, the opposite direction from BPE's merge-up approach.

A number measuring how spread out a set of values is around their average.

A model that takes both an image and text as input and reasons about them jointly.

The fixed set of tokens a tokenizer can produce and a model can read or predict.

The dedicated memory on a GPU, and the practical limit on how large a model can be loaded and run on that hardware.

Caching an entire model response for a repeated request, distinct from caching just a shared prompt prefix.