Glossary

Each entry names the module that teaches it and, where a good one exists, links one external resource for deeper reading. Terms coined by the course link to their source material instead.

A

A2A (agent-to-agent protocol)

An open JSON-RPC protocol for serving an agent as a network endpoint that applications and other agents can call like an API. An orchestration framework can serve a whole agent team over A2A from its definition. Module 2.02 A2A project ↗

activations

The vectors built from your text for one run and discarded when the answer ends: the residual stream at every position, and the thought state at the last. The other set of numbers in a pass, the weights, is stored and shared; the activations are yours alone, they last one request, and a fact that reaches the model through them was in the context. Standard term; the course used to call them the live set. Module 3.02

address guard

The check in the MCP client that refuses an `mcp_server_url` pointing at a loopback or private-range address before any tool is listed, so a server address can never be turned into a request from inside your network. An operator can override it, by a setting in the server’s environment, for a local development server. Module 2.06

adversarial persona

A dedicated evaluation prompt that directs a model to act as a skeptical auditor of your agent's instructions: enumerate the inputs most likely to trigger confabulation, a policy bypass, a missing-context trap or a format error, ranked by likelihood and harm. Every failure it finds is kept beside the corrected prompt as a test. Module 1.07

agent

In this course’s working definition, an LLM agent is a language model inside a loop that pursues goals over time by taking actions, observing consequences, and adapting. The loop generates the agency; the language model is only the engine inside it. Computer science uses the word more broadly, for anything that perceives its environment and acts on it. Module 1.06 Wikipedia — intelligent agent ↗

agent description

The short text registered with each specialist or tool that states its purpose, tools and scope. An orchestrator chooses a specialist by reading the descriptions, and a model chooses a tool the same way, from its name, its parameter schema and its description, so the text works as an interface: a routing contract read on every pass. A vague or badly bounded description produces an agent that reaches for the wrong specialist or tool. Module 1.09

agent loop

The program around a language model that executes its tool calls, places what came back into the context window, and invokes the model again until the goal is met. The model supplies the language at each step; the loop supplies runtime execution, context management and system access, and it is where agency comes from. Module 1.06

antiparallel

Describes two vectors pointing opposite ways. What they share is a negative correlation across their slots: wherever one sits toward an end of a scale, the other sits toward the opposite end. Their dot product is negative, and antiparallel is the end of the scale opposite aligned, where cosine similarity reads −1. Module 3.03

attention head

The machine inside a model that moves information between token positions. At each position it turns the vector into a query, a key, and a value; queries are compared against keys to score how strongly one position should read from another, and what arrives is a blend of the values weighted by those scores. Everything the heads add up the stack is the context term of the thought state. The rules that produce all three are frozen in the weights, while the scores are computed fresh from your prompt — which is how a fixed network answers about a product invented this morning. Every block runs dozens of heads at once. Module 3.05 Wikipedia — attention (machine learning) ↗

autoregressive

Generating one token at a time, appending each to the sequence and running one more pass to produce the next. The first pass reads the whole prompt; each later pass runs only the newest position through every block, and its attention reads the earlier positions' keys and values from the KV cache. A hundred-token answer is a hundred passes, and what carries between them is the text plus a cache that holds nothing the text does not determine. Module 3.02 Wikipedia — autoregressive model ↗

B

baseline shift

In a raw completion, where the prompt's last token is the position that writes the answer, a change to that final token that moves `h_initial`, the baseline, at that position. A question mark sets up an answer; a period or a `#` sets up a continuation or a block of syntax. When the rest of the prompt is clear, the context term overpowers the shift. When the prompt is ambiguous, the shift can tip the first token of the reply. Module 3.05

blind observer

The vision model in the image pipeline that receives the generated image file and a fixed inventory protocol, no request and no specification, and writes an inventory of what is present. It cannot be primed by the specification because it is never told what to expect; it can still miscount or misdescribe on its own. Module 2.07

block anatomy

This course’s discipline of writing an agent instruction as named, load-bearing sections — identity, doctrines, communication style, execution framework, examples, boundaries — each with one job, so that each rule can be tested, versioned and audited on its own. Module 1.05

bootstrap confidence interval

A range of values a measurement is consistent with, computed by resampling the run’s own cases many times and reading off the middle 95% of the results. Every pass rate and mean score in an observatory report carries one, and a comparison between two variants carries its own interval: when that interval excludes zero the difference is flagged significant. The flag reports only that fact and makes no claim about whether the dataset was large enough, so read the case count in the same glance. Module 2.13 Wikipedia — bootstrapping (statistics) ↗

boundary

A non-negotiable operational constraint in an agent’s instruction: a mandatory initialization check or an absolute prohibition that marks the edge of the agent’s whole purpose. Breaking one costs money, safety or trust. Written, a boundary shifts the probability of a continuation; anything that must not happen, such as a payment, a deletion or an irreversible write, is also enforced by a check in code that runs before the action, outside the model. Module 1.05

C

candidate vector

The stored vector each token in the vocabulary has in the unembedding table, written `u_A` for candidate `A`. At the last position, the finished thought state `h` is multiplied against `u_A` slot by slot and the results are added: one number, that candidate’s logit. A fifty-thousand-token vocabulary means fifty thousand candidate vectors and fifty thousand scores. Module 3.02

capability floor

The minimum set of abilities a model must clear for its role — tool calling to participate in delegation, vision to audit images. Models are selected by the floor the task requires, not the ceiling the hardware allows. Module 1.03

causal mask

The rule that a position may only read from itself and earlier positions in the sequence. Because the model is predicting what comes next, text further along is masked out, so attention scores against later positions are discarded before softmax is applied. Module 3.05

chain of thought

Writing intermediate work out as tokens before the final answer. One pass through the network has a fixed depth, so results that will not fit through it at once have to be written down and read back as context. It removes a real limit rather than adding a style, and it pays on step-by-step checkable work while costing you on simple lookups. Module 3.08 Wikipedia — chain-of-thought prompting ↗

Cohen’s kappa (κ)

Agreement between two graders corrected for the agreement you would expect from chance alone. In an eval harness the two graders are a judge and a person, so kappa says how much of the judge’s apparent accuracy is real. It is read on the standard scale (slight, fair, moderate, substantial, almost perfect) and split into the two disagreement kinds that carry different costs: lenient, where the judge passes what a person failed, and harsh, the reverse. Set a floor per judge, do not let a judge below its floor decide a deploy, and count a judge with no labels as failing that floor. Module 2.13 Wikipedia — Cohen’s kappa ↗

collector

An agent whose only job is to gather evidence from one channel and write a report, drawing no conclusion. The course’s fact-checking team runs two: one over the live claim stream on X, and one over the documented record on the web that checks the claims surfaced by the first. Module 2.09

confabulation (hallucination)

Fluent, confident output that is false. When it does not abstain, a model optimized for plausible continuation can fill gaps in its knowledge with the statistically likely shape of an answer: citations formatted perfectly for papers that do not exist. The output reads like knowledge because it is built from the pattern of knowledge. Module 1.02 Wikipedia — hallucination (AI) ↗

conformance auditor

The text-only agent in the image pipeline that reads the approved specification and the blind observer's inventory, never the image, and returns a per-field verdict of match, mismatch or unverifiable, a conformance score over the fields it could check (report coverage, the share of fields checked, beside it), and one field to reinforce. Module 2.07

context window

The fixed number of tokens a model can consider at once — its only working memory. When input exceeds the window, a raw API call returns an error; a system configured with a rolling history drops the oldest tokens out silently, with no error raised. Module 1.01 Wikipedia — large language model ↗

corroboration gate

The rule deciding what a fact-checking agent may state plainly: corroborated across both channels or primary-sourced → bare fact, where outlets or channels repeating one origin count as one source; attested but unconfirmed → attributed claim; single-source → labeled unverified; contradicted → the contradiction itself is what gets reported. Module 2.10

cosine similarity

The dot product of two vectors with both of their lengths divided out, leaving direction alone. It runs from +1 when they point the same way, through 0 when they are orthogonal — at right angles, where the agreements and disagreements across their slots cancel — to −1 when they point opposite ways. This is the number people mean when they call two pieces of text similar, because dividing the lengths out stops a merely emphatic vector from scoring high against everything it half-agrees with. Module 3.03 Wikipedia — cosine similarity ↗

council

A workflow topology in which several specialists examine the same question in parallel and an orchestrator weighs their independent judgments into one verdict. One of the four shapes taught alongside solo, router, and decomposer. Module 1.09 ADK — multi-agent systems ↗

coverage

The fields an audit checked out of the fields the specification states, reported beside the conformance score. Conformance is matching fields divided by checkable fields, so an `unverifiable` field leaves both the numerator and the denominator, and a high score can rest on very little; coverage says how much was checked. A builder computes it in code against the specification's own fields, with a rule for required fields: a required field that comes back `unverifiable` prevents `accept` or sends the image to a person for review. Module 2.08

critic loop

A drafter produces the work, a separate critic scores it against a rubric and returns the score in a schema, and the orchestrator repeats the exchange until the score clears a threshold or a round cap is reached, then returns the critic’s latest verdict with its score. Quality becomes a parsed field the orchestrator, or your own code, can compare against the threshold. Module 1.08

custom domain tool

A function written for your own system and its job, such as a billing agent's `issue_refund` or the Assistant's `task_update`. The model has met neither its name nor its behavior in training: it knows the tool only from the name, parameter schema and description that reach the context window. The tool's description says what it does; the system prompt says, in plain words, which case calls it, in what order, how many calls a turn may spend, and what to do when it fails. Module 1.05

D

decoding

One step of generation after the prefill: the token just drawn enters as one new position, climbs through every block, and at each block its attention reads the keys and values of every earlier position from the KV cache. Each token after the prefill costs one decoding step. Module 3.01

delegation contract

The two pieces of prose that decide routing in a multi-agent configuration. The orchestrator’s instruction says which specialists it must consult and when; each specialist’s `description` says what that specialist is for; the orchestrator’s model reads both and chooses. Both halves are prose, so both can be audited, and both are where routing failures start. Module 1.09

deploy gate

A check that reduces an eval run, a pinned baseline and a set of thresholds to an exit code, wired into the step that publishes an agent so a regression cannot reach users. Thresholds cover how far a pass rate or score may fall against the baseline, absolute floors per judge, error rate, latency, and the agreement floor a judge must clear before it is allowed to decide anything. A judge with no human labels has no kappa to check; a gate that requires calibration counts that as a failure, where the module’s harness only warns. Module 2.14

distillation

The background pass that reads a finished session transcript and keeps only the facts durable enough to matter next month, each rewritten to stand alone with a date, a source and exact values. The model that runs it is the distiller; most turns are dropped. Module 2.03

doctrine

A block in an agent’s instruction that governs one capability: what counts as ground truth for it, when it must be consulted, and what the agent does when the source is silent. Blocks follow capabilities — a new power earns a new doctrine. Module 1.05

dot product

The comparison every score in a model is built from: multiply two vectors element by element and add the results. One number comes out, large when the two point the same way, near zero when they sit at right angles, and negative when they point opposite ways. Attention scores and logits are both dot products. Module 3.03 Wikipedia — dot product ↗

E

embedding

A numeric vector that captures the meaning of text, placing similar meanings near each other in space. Embeddings are what let a memory store find records a query resembles rather than records it quotes. Module 2.03 Wikipedia — word embedding ↗

eval suite

One directory holding everything needed to grade an agent: a dataset of cases, the variants being compared (a definition file plus overrides such as model or thinking level), and the judges that score the results. What runs is the product of variants, cases and trials, and a trial is a repetition of one case under one variant, which measures whether the agent agrees with itself. Module 2.13

execution framework

The block of an agent’s instruction that fixes what the agent does on every turn, or the mandatory sequence of phases for multi-step work. Every framework in this course has four parts: a task directive naming the deliverable, a reasoning directive naming the decision the model makes before any branch runs, the numbered steps of the procedure, and guardrails, written as negative constraints, that bound every branch. A single-turn query agent needs no procedure, and its framework shrinks to a task directive and its guardrails. Module 1.05

expectation priming

The failure in which a reviewer that has read the specification reports what it expected rather than what is there: told to look for three vases, it sees three in an image holding two. It is the same conditioning of later tokens by earlier ones that makes worked examples work, which is why the observer is kept blind. Module 2.08

F

fact collision

In the three-term picture, the memory term of the thought state holding more than one association for the pattern in front of it, and the louder one outscoring the one the question asked for — the largest city answering for the capital, the previous CEO for the current one. The MLP matches patterns and hands back what was filed; nothing in it checks that the loudest filing is the asked-for one. The context term is the repair: put the fact in the prompt and a memory term the model may lose becomes a context term it is more likely to win. Module 3.06

fine-tuning

Continuing training on a small curated dataset to shape behavior — output format, tone, domain vocabulary, tool-call syntax, what to decline. It installs behavior well and facts badly: a fact learned from a small corpus is stored weakly, competes with a much stronger prior, cannot be corrected surgically, and cannot be deleted selectively. Behavior in the weights, facts in retrieval. Module 3.10 Wikipedia — fine-tuning (deep learning) ↗

five prompt variables

The five variables a prompt is refined by, each with a characteristic failure: clarity (ambiguity forces the model to guess the task), precision (loose constraints produce unusable output shapes), context (missing data induces confabulation), instruction (observational phrasing elicits commentary) and format (a missing schema breaks downstream parsing). Refinement isolates where an output broke down, changes exactly one of the five, and runs the agent again. Module 1.07

G

grounding

The practice of supplying verified reference material, database records, source files, policy documents or live system state directly into the context window before the model generates a response. It works because every prediction is conditioned on everything in the sequence: the supplied text steers the next-token probabilities toward the exact terms, dates and numbers it contains. It is the repair for the grounding gap. Module 1.02

grounding gap

The distance between a model’s words and the world they describe. A model manipulates symbols with no contact with the physical world, so fluent instructions for impossible tasks cost it nothing. The classic statement of the underlying problem is the symbol grounding problem. Module 1.02 Wikipedia — symbol grounding problem ↗

guardrail

A negative constraint in an execution framework that names the one failure a branch invites and forbids it, such as “never state an amount no tool returned”, paired with a way out that says what the reply does instead. The negative makes it checkable: a script searches the transcripts, and one occurrence is a fail. The way out supplies a continuation, because a prohibition alone often leaves the same invention, reworded, as the next most likely sentence. Breaking a guardrail costs a worse reply; breaking a boundary costs more. Module 1.05

H

human-in-the-loop (HITL)

A system design that keeps a person inside an automated process, so designated steps wait on human judgment before the work proceeds. This course places that judgment at two gates: data hygiene before the model sees input, and skeptical verification before its output travels further. Module 1.02 Wikipedia — human-in-the-loop ↗

I

in-context learning

A model picking up a pattern from the prompt and applying it, with no weight change and nothing kept afterwards. Worked examples mostly specify the shape, scope, and register of the answer rather than teaching content — randomising their labels barely hurts performance on many tasks. Use examples to pin down form; put knowledge in as explicit content. Module 3.07 Wikipedia — in-context learning ↗

J

judge model (LLM-as-judge)

A model given a rubric and asked to score another model’s output. The rubric’s criteria are compiled into an output schema the provider forces the judge to fill, so the fields arrive under the names you declared; weights turn the fields into one number and a threshold turns the number into a decision. The judge must not be a model under test, and every rubric keeps a deterministic judge beside it. Module 2.13

K

KV cache

The keys and values attention has already computed for earlier positions, kept at every block by the serving engine so that each new pass computes only the newest position. It holds exactly what the text would rebuild, so it saves time and adds no memory of its own. It is inference state for one request and is dropped when the request ends, though some serving systems keep the cache for a prompt's opening text and reuse it when a later request begins with exactly the same text. Module 3.02

L

large language model (LLM)

A neural network trained across an enormous body of text to predict the next token. It stores no table of facts — it stores the statistical shape of language and reproduces it one prediction at a time. Module 1.01 Wikipedia — large language model ↗

leaf constraint

The rule, under Google ADK and the runtimes built on it, that an agent holding an output schema could have no sub-agents: a structured answer and a delegation turn deadlocked on one agent. A runtime that lifts it lets an orchestrator hold a schema beside its sub-agents, delegating first and ending its turn on the JSON. A schema on a leaf remains the choice when the user should receive a specialist's answer, and under plan-dispatch the schema makes the orchestrator a pure classifier.

ledger

The append-only record of production turns, one row per turn across five tables (`adk_turns`, `adk_telemetry`, `adk_payloads`, `adk_verdicts`, `adk_labels`), keyed by session, user, task and invocation ids and a `config_hash` of the compiled graph, so that the same judges that grade a suite can grade what production already did. Module 2.14

logits

The raw scores a model produces for every token in its vocabulary at the end of a pass, before they are turned into probabilities. Each one is a dot product between the thought state and that token’s candidate vector, ℓ(A) = h · u_A, so it is the sum of three votes — baseline, context, and memory. Softmax converts the logits into the distribution the next token is drawn from. Module 3.02

M

matrix

A grid of stored vectors, one per row, compared against an input vector all at once: one vector goes in, and one match score per row comes out. Running an input against a matrix this way is what one layer of a neural network does. Module 3.03 Wikipedia — matrix (mathematics) ↗

MCP (Model Context Protocol)

An open standard for connecting AI applications to external tools and data: a source runs a small server that describes what it offers, and any agent speaking the protocol can use it. In the course’s plain terms, the source hangs a labeled toolkit next to itself; each tool is a deterministic function the agent discovers at connection time, calls with arguments, and folds the verified result into its answer. Capability becomes a connection rather than a compilation. Module 2.05 modelcontextprotocol.io ↗

MLP (multi-layer perceptron)

The machine in each block that works at one token position and never looks at another. It compares the vector against roughly thirty-two thousand stored patterns, zeroes the misses, mixes the survivors’ contributions and adds the result back. Everything it adds up the stack is the memory term of the thought state. Two-thirds of a model’s parameters sit here, and this is where most remembered facts appear to live. Module 3.06 Wikipedia — multilayer perceptron ↗

N

negative constraint

A rule written as a prohibition, “never state an amount no tool returned”, naming one specific failure an agent’s procedure invites. Guardrails and boundaries are both written this way, because a named failure can be checked with a single search of a transcript. Each one is paired with the move to make instead, since a prohibition alone removes the likeliest continuation without supplying another. Module 1.05

neuron

In an MLP, one stored pattern together with its paired contribution. The neuron’s activation is the single number its pattern’s match produces, and “the neuron fires” means that number came out high, so its contribution is added to the residual stream in proportion. Module 3.06 Wikipedia — artificial neuron ↗

O

observability ledger

The database of what agents actually did: one row per turn (input, output, the agent that answered, the route and how it was chosen, errors, tokens, time split between model and tools, and the tool calls with their responses), one row per model call, and, by policy and expiring, the assembled prompts. Each row carries session, user, task and invocation ids plus a hash of the definition that produced it, and that identity is what makes routing mix, cost per agent, full-text search over old questions, and a whole conversation rebuilt from its events one query each. Module 2.14

open weights

A model whose trained parameters are published as a downloadable file, so inference can run on your own hardware — no key, no meter, no data leaving the machine. Module 1.03 Wikipedia — open-source AI ↗

orchestrator & subagents

The two roles in a hierarchical multi-agent system: a coordinating agent that owns the conversation and delegates, and specialist agents that each handle one kind of work. In a declared agent team, load time wraps each subagent as a tool on the orchestrator’s belt, so delegation is function calling: the orchestrator reads each description and decides a handoff the way it decides any tool call.

orchestration script

The fourth of an agent team’s orchestration methods: the logic between agents written as a short program in the team definition. It calls the declared agents, the allowed tools and the person as functions, chooses a model for each call, and returns the answer, so a routing rule changes with a deploy of the definition. It runs in a sandbox with no network, clock or randomness of its own, and every call is journaled; a run paused on a question resumes by replaying the journal, which holds only if the script makes the same calls on every run. Module 2.02

originating evidence

The document, data or first-hand report a claim traces back to. Corroboration is counted by it: two websites republishing one press release are one originating source seen twice, and a post quoting the same release repeats it a third time. The outlet that reports a figure is a source for the claim; the release or dataset behind the figure is the evidence. Module 2.09

orthogonal

Describes two vectors at right angles to each other: their dot product is zero, because the agreements and disagreements across their slots cancel, or one sits at zero wherever the other commits. An orthogonal pair can still share traits. It is the middle of the scale between aligned and antiparallel, and it is where the overwhelming majority of pairs sit in a real model, because eight thousand dimensions leave a great deal of room for directions at right angles. Module 3.03

outcome supervision

Training feedback on the final result alone. The model writes a long stretch of tokens before answering, a program checks the final answer, and the runs that ended correctly are rewarded. The tokens in the middle receive no direct score; whether the runs containing them ended correctly is the only thing that shapes them. Module 3.09

output schema

A machine-readable contract, usually written as JSON Schema, that fixes the shape of an agent’s reply: which fields must appear, their types, and their allowed values. Once quality is a parsed field, a confidence integer or a per-item status, code can compare it against a threshold, while the value in the field remains the judgment of the model that wrote it. The engine returns an answer without rejecting one that misses its schema, so the code that consumes the JSON validates it. json-schema.org ↗

P

pass

One run of the network that scores every candidate in the vocabulary for the next position, so that one token can be drawn. The first pass reads all the prompt’s positions together; each later pass runs only the one new position, reusing the work stored for the earlier tokens, which holds nothing the text does not already determine. A two-hundred-word answer takes roughly three hundred passes. Module 1.01

pgvector

A PostgreSQL extension that stores embeddings and answers similarity searches. The course’s long-term memory tier keeps its 768-dimension vectors here. Module 2.03 pgvector on GitHub ↗

plan artifact

A structured implementation specification drafted before any code is written: it breaks the change into discrete phases, identifies architectural risks, and records the decisions that are hard to change later, such as external API contracts, database schemas and interface names. A person reviews and approves it before editing starts, and the finished change is verified against it. The agent writes it to disk and reloads it, so the approved decisions survive across sessions and context resets. Module 2.12

plan-dispatch

One of an agent team’s four orchestration methods, beside delegation, the workflow graph and the orchestration script, switched on by a dispatch: block. The orchestrator holds no subagent tools; it is a pure classifier whose output schema names one route, code runs the matching specialist directly, and the specialist’s own output is the answer. Removing the relay turn removes its failure by construction: every routing failure resolves to a declared default route, and a route that then fails ends the turn with an error naming it. Dispatch is for routing; delegation is for composing. Module 2.02

position

One slot in the sequence of tokens, and the residual stream that lives there. Each position carries its own vector up through every block in its own lane, and attention is the only machine that moves information from one position to another. Module 3.01

positive example

A worked exchange in an agent’s examples block that shows only the right reply for one branch of its execution framework. The wrong reply goes in a guardrail as a negative constraint rather than in the block, where its wording would sit in the window as one more pattern to imitate. Module 1.05

prefill

The first pass of a request, which runs the whole prompt through the stack at once, every position together, and stores each block's keys and values for those positions in the KV cache. Every token after it is written by a decoding step. Module 3.02

prior (the)

The model’s defaults about what text looks like, laid down by training — which claims travel with which, what a policy document sounds like, what usually follows a question of this shape. When the context underdetermines an answer, generation does not stop and no error is raised: the prior can fill the slot, though a model can also decline or ask for the missing fact. That is the mechanism behind confabulation. Module 3.07

procedure

A working algorithm that training discovers and stores in the weights, because an algorithm predicts better than a lookup table. The cleanest example is a two-head arrangement that finds an earlier occurrence of the current token and predicts what followed it last time: a copy-and-continue routine that runs on whatever is in the context, including sequences that appeared nowhere in training. Procedures are one of four kinds of thing the weights hold, beside facts, world models and the prior. Module 3.04

process supervision

Training feedback given on each intermediate step of a worked solution, where outcome supervision gives it on the final answer alone. Module 3.09

prompt injection

Instructions smuggled inside data an agent reads — a tool result or document containing text shaped like commands. A chat template's role tokens mark which message slot that text sits in and say nothing about who wrote it, so the model reads that text as ordinary tokens in that slot. The countermeasure starts as doctrine: tool results are data, never instructions; an operation that must not run on such text is checked in code. Module 2.06 OWASP — LLM01 prompt injection ↗

Q

quality bar

The standard a critic scores a draft against, expressed as a number the loop can gate on. In the course’s critic loop the critic returns a confidence from 0 to 100, a rubric score that it assigns by following its instruction’s bands and that nothing calibrates against measured correctness, and those bands are cut at the gate, 85: a score in the top band ships, and a score below it goes back to the drafter with the critic’s list of issues until the three-round cap, after which the latest verdict ships with its score. Module 1.08

quantization

Storing a model’s weights on a coarser numeric grid than the one they are published in, near four bits for each number rather than sixteen, so the file and the memory it occupies shrink by roughly a factor of four. The rounding introduces a small error into every weight and is what makes local inference possible on ordinary hardware. The specimens in this course are quantized, which is why an 8-billion-parameter model downloads as about five gigabytes. Module 1.03

query, key, value

The three short vectors an attention head derives from the vector at each position, by multiplying it against three separate grids of frozen weights. Queries are compared against keys to decide where a position reads from; values carry the content that gets blended in. The names come from database lookup, with one difference that matters: you never get exactly one value back, only a blend of all of them weighted by how well each key scored. Module 3.05

R

reasoning directive

The line in an execution framework that names the decision a model must make before it writes its reply, “decide first which of three requests this is”, and says where that reasoning goes: a thinking model’s hidden scratchpad, a schema field code reads, or nowhere the user sees. It is chain of thought aimed at one decision, and it is left out where the reply turns on none. Module 1.05

recall

The stage of the memory lifecycle that brings stored facts back: a similarity search over long-term memory produces a shortlist, index keys and dates re-rank it, and the top records are placed in the context window as text. Recall is grounding pointed at a store the system writes to itself. Module 2.03

register law

One line in an agent's communication-style block that a transcript can pass or fail: a word ceiling, a forbidden structure, a required closing element, exactly one metaphor. Voice is engineered as a set of these, and each one gives a reviewer or an evaluation agent something in the reply to check; the model and its sampling settings shape the reply too. Module 1.10

replay

A back-test on stored traffic: real user inputs become the cases, the answer production gave becomes the baseline, and the tool responses recorded on that turn are injected so the candidate is answering last month’s question with last month’s data. For the replayed tools, matched by tool name whatever arguments the candidate passes, both answers are then built from the same evidence, which removes the world’s drift from the comparison. Bounded honestly: replays are single-turn, tools with no recording run live where a safer harness would return an error, and long-term memory is not replayed. Module 2.14

repository instruments

The four kinds of file a coding agent reads at different phases so it can work on a repository larger than its window: the rules file (always in the window), skills (found by their descriptions, body loaded on match), knowledge docs (retrieved on demand) and plan artifacts (the human gate before code). Module 2.12

residual stream

The running vector each token position carries up through every block — an additive highway. Each machine reads it and adds its own contribution back; nothing overwrites. Think of it as a noticeboard the whole building posts to, one per token — early blocks post what a token is, late blocks post something close to a prediction, and nobody takes anything down, though a later block can cross part of a note out by posting a contribution that points the other way. At the last position, at the top of the stack, it is the thought state. Module 3.01

retrieval-augmented generation (RAG)

Searching a document store for text relevant to the question and pasting it into the context before the model answers, usually with a citation demanded. The defining property is that the facts live outside the model: add, correct, or delete one instantly, with no retraining. The standard fix for the grounding gap, and the layer most facts belong in. Module 3.10 Wikipedia — retrieval-augmented generation ↗

review agent

A second model placed between the generator and the user. It evaluates the draft against strict rules, a required output shape or a safety policy, then passes it, halts it, or sends it back with specific correction instructions. It works because it is separate, with its own instructions, its own narrow task and its own pass; asking the generator to check its work in the same pass produces a fluent explanation of why the draft is fine. Module 1.02

router

An entry-level agent whose sole task is classification: it reads each incoming request, matches it against the available specialist descriptions, and hands the whole turn to one specialist, answering nothing itself. Its behavior is defined entirely in its instruction. The classes can be domains (which specialist a request belongs to) or depth (how much reasoning a request deserves). Module 1.09

runner

The execution loop around a model in an agent runtime: it passes the tool definitions in, dispatches each call the model emits, feeds the string result back, and repeats until the model writes text. A sub-agent wrapped as a tool runs its own complete runner loop inside the parent's call.

S

sampling

Drawing one token from the probability distribution a pass produces: the one step where chance is put in on purpose, at a strength the temperature sets. The arithmetic before it is meant to give the same distribution for the same prompt, but on a busy server it can vary from run to run with the load, so identical prompts can differ even at temperature 0. Module 3.02 Hugging Face — how models generate text ↗

scratchpad (thinking trace)

The intermediate tokens a reasoning model writes before its answer, kept in the context between passes. The pass that writes the first answer token builds its context term from the whole scratchpad, which is how the conclusion crosses from the trace to the answer — and why a scratchpad cut off by a token budget hands the answer back to one-hop machinery with a half-built context. Module 3.09

self-preference bias

The tendency of a model to score its own output higher than an independent model scores it. It is the reason a judge may not be a model under test: preflight refuses a judge whose model matches any agent being graded, following nested references down into subagents, and warns when the two merely share a provider family. Its companion in pairwise judging is position bias, handled by judging every pair twice with the order swapped and recording a winner only when it survives both. Module 2.13 Wikipedia — algorithmic bias ↗

softmax

The step that turns any set of numbers into fractions adding up to one, keeping their order and exaggerating the gaps between them. It appears twice in every pass: converting attention scores into the proportions a position reads by, and converting logits into the distribution the next token is drawn from. Module 3.02 Wikipedia — softmax function ↗

SSRF (server-side request forgery)

An attack in which a hostile URL tricks a system into making requests against internal services. It is why the framework refuses loopback and private MCP hosts unless a development flag is set knowingly. Module 2.06 OWASP — SSRF ↗

sub-agent

An agent declared beneath an orchestrator in a team definition and wrapped as a tool of it: the orchestrator delegates by calling it with a task, the sub-agent runs in its own window holding only its instruction and that task, and its final text returns as the tool's observation.

superposition

Packing more concepts into a model than it has dimensions to give them, by letting them share overlapping directions instead of getting one each. The consequence is that a single neuron fires for several unrelated things, so you cannot locate and edit one belief cleanly — attempts to do so damage neighboring facts. Module 3.06

syndicate

The course’s word for an agent team declared as one unit: one definition that declares an entire agent system — hierarchy, prompts, tools, models, memory tier, and output contracts. The specimens the course quotes keep theirs in YAML files; a runner can accept the same definition built in code.

syndicate definition

The single YAML document that declares an entire agent network: the hierarchy of agents, each agent's instruction, tools, model and memory tier, and the schema of its return payload. One file describes a complete team, and every key in it fixes a boundary.

system prompt

The standing instruction placed at the front of the context window before the conversation begins and kept there on every turn. Predictions are conditioned on everything in the active sequence, so the system prompt steers every reply without touching a single weight: as plain text, it selects the identity, rules, and personality an agent shows from the behavior the weights learned in training, and the conversation after it conditions the reply too. Module 1.03

systemic bias

The skew a model inherits from its training data, which carries history’s imbalances of race, gender, and class into the model’s behavior. Bias shows up in aggregates, not single outputs, so it must be audited for rather than assumed away. Module 1.02 Wikipedia — algorithmic bias ↗

T

task directive

The line that opens an execution framework and names what this call must hand back, and so when the agent is done. Identity is the agent’s standing purpose across every conversation; the task directive is one call’s deliverable, and it tells a subagent where its slice of the job ends. Module 1.05

temperature

The setting that governs how adventurous the final draw is. It divides the logits before softmax, so a low value exaggerates the gaps and, at 0, hands you the leading token every time, while a high value flattens them toward an even spread and gives every long shot a larger chance, near-zero ones included. It changes the draw and never the ranking: no setting moves a token above one that outscored it. Configured per agent in a team definition. Module 3.02 Hugging Face — how models generate text ↗

thought state (h)

The residual stream at the position that writes the next token, at the top of the stack: one vector, about eight thousand numbers, and the only thing the vocabulary is ever compared against. Everything the model read, remembered, or worked out has to be in it, or it plays no part in what gets said. Module 3.01

three sources (h_initial, h_ctx, h_prior)

The thought state grouped by which machine wrote each part: h_initial, the token’s own embedding (the baseline); h_ctx, what attention pulled in from earlier positions (the context term); h_prior, what the MLP injected from the weights (the memory term). h is their sum, and every logit is the sum of three dot products, one per term. In that picture a right answer is usually the context and the memory agreeing, a confabulation the memory voting alone, and a fact collision the memory outvoting the context. The grouping is a bookkeeping identity, and it cannot by itself show which term caused a given answer. Module 3.05

token

The unit a model reads and predicts: a subword fragment, a short word, or a punctuation mark. Tokens are also the unit of cost, speed, and the context-window budget. Module 1.01 Wikipedia — byte pair encoding ↗

tokenizer

The fixed lookup table that cuts text into the chunks a model reads. Between fifty thousand and two hundred thousand entries, assembled once from the training text and never changed, so every piece of text a model ever sees has to be spelled out of those entries and only those — which is why a name it has never met arrives as several fragments that mean nothing on their own. Module 3.01 Wikipedia — byte pair encoding ↗

tool result

What a tool sends back across the connection, entering the context window as text. It is data for the agent to reason over and never an instruction to obey; a result that contains directives is reported as text, and a write is believed only after a read-back confirms the new state. Module 2.05

topology

The shape of who does what in a multi-agent system: solo, router, decomposer, or council. A topology is a sentence about who answers; adding agents costs handoffs, latency, and context, so the shape is chosen deliberately. Module 1.09

transformer block

One of the identically shaped machines a model’s vectors travel up through: forty in a small model, up to about a hundred and twenty in a large one. A block reads the vector arriving at a position, computes a vector of its own of the same length, and adds it in slot by slot, so the residual stream leaving it is the sum of what arrived and what the block contributed. The modules call it a block; the blocks of block anatomy are sections of a prompt. Module 3.01

U

unembedding table

The stored table above the stack holding one candidate vector per token in the vocabulary. The finished thought state at the last position is dotted against every candidate vector to give one logit each. It is where a pass narrows from millions of numbers in flight to a single choice, and its counterpart below the stack — the embedding table — is what turned each token into numbers in the first place. Module 3.02

V

vector

A list of numbers used as coordinates, so that its direction carries meaning: tokens that play similar roles in text come out as vectors pointing similar ways. A real model’s vectors hold about eight thousand numbers each; the worked examples in this course hold three, so the arithmetic fits on a page. Module 3.03

vector database

A store organized around embeddings, answering the question "what is nearest in meaning?" — the recall half of a long-term memory system. Module 2.03 Wikipedia — vector database ↗

W

weights

Every stored number in the model, on the order of a hundred billion of them, fixed the day training ended. Nothing writes to them while you talk to it. Any answer combines these with the activations, built fresh from your prompt and discarded when the request ends — and when someone says a model “knows” something, which of the two sets they mean changes what you should do about it. Module 3.03 Wikipedia — weighting (neural networks) ↗

world model

An internal model of the thing generating the text, formed by prediction pressure alone. A model trained only on Othello move lists, never shown a board, builds an internal picture of the board; a small classifier can read it out, and editing it changes the model’s next legal-move predictions to match. World models form in well-structured domains and stay narrow. Module 3.04

Y

YAML

A plain-text format for structured data (the name is a recursive acronym: YAML Ain’t Markup Language) that expresses lists and key-value pairs through indentation, so a file of it reads like an outline. The agent definitions the course quotes are written in it because a definition kept in a plain file stays easy to read, diff, and review — the format is a convenience, and the same definition can live in code. yaml.org ↗

Missing a term you expected? The course itself is the long-form version of this page — every definition above is taught in context there, and the syllabus says which chapter covers what.