glossary

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. Melchizedek serves any syndicate over A2A with one command. module 2.04 · A2A project ↗

agent

A system 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. module 2.01 · Wikipedia — intelligent agent ↗

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 1.05 · Wikipedia — attention (machine learning) ↗

autoregressive

Generating one token at a time, appending each to the sequence and running the whole model again to produce the next. A hundred-token answer is a hundred complete passes over the prompt plus everything written so far, and nothing carries between passes except the text itself. module 1.03 · Wikipedia — autoregressive model ↗

block anatomy

This course’s discipline of writing an agent instruction as named, load-bearing sections — identity, doctrines, communication laws, workflow, boundaries — each with one job, together forming a contract the model must follow. module 2.01 · field checklist (download) ↗

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 3.01 · Wikipedia — bootstrapping (statistics) ↗

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.02

causal mask

The rule that a position may only read from positions earlier in the sequence than itself. Because the model is predicting what comes next, text further along is not available to look at, so every attention score against a later position is discarded before the blend is taken. module 1.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 1.07 · 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 and do not let a judge below its floor decide a deploy. module 3.01 · Wikipedia — Cohen’s kappa ↗

confabulation (hallucination)

Fluent, confident output that is false. A model optimized for plausible continuation fills 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.01 · Wikipedia — hallucination (AI) ↗

context window

The fixed number of tokens a model can consider at once — its only working memory. When input exceeds the window, the oldest tokens drop 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 independent channels or primary-sourced → bare fact; attested but unconfirmed → attributed claim; single-source → labeled unverified; contradicted → the contradiction itself is what gets reported. module 2.08

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, meaning genuinely unrelated — 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 1.04 · 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 2.03 · ADK — multi-agent systems ↗

critic loop

A drafter produces the work, a separate critic scores it against a schema, and the orchestrator repeats the exchange until the score clears a threshold. Quality becomes a parsed field a loop can gate on. module 2.02

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. module 3.01

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 2.01

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.05 · 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 3.01

fact collision

The memory term of the thought state holding more than one association for the pattern in front of it, and the loudest one winning over 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 vote is the repair: put the fact in the prompt and a memory vote the model may lose becomes a context vote it wins. module 1.05

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. Behavior in the weights, facts in retrieval. module 1.08 · Wikipedia — fine-tuning (deep learning) ↗

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.01 · Wikipedia — symbol grounding problem ↗

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.01 · Wikipedia — human-in-the-loop ↗

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 1.05 · Wikipedia — in-context learning ↗

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 3.01

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 ↗

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 1.03

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.06 · 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 1.05 · Wikipedia — multilayer perceptron ↗

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 3.01

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.02 · 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 syndicate, 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. module 2.04 · Google Agent Development Kit ↗

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, architecture can gate on it automatically. module 2.04 · json-schema.org ↗

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.05 · pgvector on GitHub ↗

plan-dispatch

The second of a syndicate’s two orchestration methods, 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, so the user is always answered. Dispatch is for routing; delegation is for composing. module 2.04 · Google Agent Development Kit ↗

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 fills the slot. That is the mechanism behind confabulation. module 1.06

prompt injection

Instructions smuggled inside data an agent reads — a tool result or document containing text shaped like commands. The countermeasure is doctrine: tool results are data, never instructions. module 2.06 · OWASP — LLM01 prompt injection ↗

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 1.05

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. Both answers are then built from the same evidence, which isolates the change you made. Bounded honestly: replays are single-turn, tools with no recording run live, and long-term memory is not replayed. module 3.01

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. At the last position, at the top of the stack, it is the thought state. module 1.03

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 1.08 · Wikipedia — retrieval-augmented generation ↗

sampling

Drawing one token from the probability distribution a pass produces — the only step in the whole pass where anything is left to chance. Everything before it is fixed arithmetic over stored numbers, so two identical prompts differ only in what the draw returned. module 1.03 · 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 1.07

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 3.01 · 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 1.03 · 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 ↗

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 1.05

syndicate

Melchizedek’s unit of composition: one agent definition that declares an entire agent system — hierarchy, prompts, tools, models, memory tier, and output contracts. The shipped specimens keep theirs in YAML files; the runner accepts the same definition built in code. module 2.04 · melchizedek-agents (public repo) ↗

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.01 · Wikipedia — algorithmic bias ↗

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 hands you the leading token every time, while a high value flattens them and gives long shots a real chance. It changes the draw and never the ranking: no setting can promote a token the pass scored near zero. Configured per agent in a syndicate. module 1.03 · 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 1.03

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); h_prior, what the MLP injected from the frozen weights (the memory). h is their sum, and every logit is the sum of their three votes. A right answer is usually the context and the memory agreeing; a confabulation is the memory voting alone; a fact collision is the memory outvoting the context. module 1.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 1.03 · Wikipedia — byte pair encoding ↗

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 2.03

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 1.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.05 · Wikipedia — vector database ↗

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 a live set of numbers 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 1.04 · Wikipedia — weighting (neural networks) ↗

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 shipped syndicate specimens 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. module 2.04 · yaml.org ↗

Missing a term you expected? The syllabus is the long-form version of this page — every definition above is taught in context there.