~/curriculum/syllabus

18 modules · 3 parts · ~12 h

The module list, with progress marks and the begin button, is on the curriculum index.

why this course

Most AI tutorials stop at the chat interface. This curriculum teaches what happens when you step behind the interface to build, test, and govern production agent systems.

Every module in this course is grounded in a working codebase. Instead of toy examples, you study production agent configurations pulled directly from the course repository: the system prompts that define their behavior, the execution loops that coordinate them, and the evaluation suites that measure their reliability. You read the core theory, inspect the active configuration, and test the machinery yourself through interactive terminal checkpoints and one hands-on exercise in every module.

The guiding principle of this curriculum is purpose-driven AI. A generic, unconstrained model attempts to answer everything and excels at very little. A production agent is a model bound to a single operational purpose: clinical triage, financial auditing, literature synthesis, or software maintenance. Part 1 covers the foundations — what a language model computes, running open weights on hardware you own, and the written definition that commits a model to one purpose. Part 2 covers design and evaluation: one file defining a whole team, engineered memory, MCP reach into live data, and the graders and ledger that say whether a change made the system better. Part 3 goes down to the mechanism itself — tokens, vectors, the context window, and the single bottleneck every answer leaves through.

This course is built for practitioners who need reliable results: developers, researchers, analysts, and domain experts who can run a terminal command and edit a configuration file. You do not need a deep background in machine learning. The curriculum focuses on the architectural layer above the framework: how to specify instructions, define rigid operational boundaries, evaluate compliance, and coordinate specialized agent teams.

The melchizedek repository serves as our reference architecture, not a proprietary silo. Every design pattern you master here — delegation contracts, critic review gates, structured memory retrieval, and automated regression testing — is framework-agnostic. You can implement these patterns in any programming language or orchestration stack you choose. The goal is to give you the design discipline to build and govern your own autonomous systems.

Eighteen rooms in three wings under one roof. Enter in order, since each module leans on the last, or wander; the stoa doesn't mind.

chapter overview

The order below is not a preference. Each module declares the concepts a reader needs before it, every one of those concepts is defined in the glossary and taught by an earlier module, and the map draws what falls out of those two facts.

look first: which module carries the most arcs, and how far back does the longest one reach?

Every module on the teaching-order axis, with one arc for each dependency between two of them — 35 in all, derived from the concepts each module declares it requires. Every arc runs left to right: no module needs anything that comes after it, which is what makes the sequence a consequence of the material rather than a choice about it. The reach of an arc is how far back that module has to have understood.

Every chapter in teaching order, with what it covers and how long it runs. Titles link to the module. If you meet an unfamiliar word anywhere in the course, the glossary defines every load-bearing term and links one further resource for each.

Part 1 — Foundations of Agents

From raw models to autonomous systems: understand what a language model actually computes, run open weights locally on your own hardware, and author structured system prompts that commit models to a single operational purpose. Master the discipline of iterative prompt evaluation and deploy your first multi-agent team.

1.01 The Architecture of Prediction ~40 min

How a language model computes next-token probabilities, why tokenization and the context window govern runtime behavior, the three foundational failure classes (confabulation, the grounding gap, and systemic bias), and the two external verification loops that catch them.
1.02 Running your own model ~30 min

Open weights, local inference runtimes, and your first agent build: author a compact four-sentence system prompt that defines audience, role, communication style, and task boundaries. Run the agent on your own machine and trace the three structural limits a standalone persona prompt cannot cross.
1.03 Generative AI agent design ~50 min

The anatomy of a purpose-driven agent. Deconstruct a modular system prompt into six functional blocks, then trace the four-stage execution loop (goals, actions, observation, adaptation) that turns text prediction into verifiable task completion.
1.04 Testing & refining an agentic workflow ~40 min

Prompt engineering as a rigorous diagnostic discipline. Isolate failure modes across five systematic variables, iterate against edge cases, and build an automated critic agent that scores output quality as a number a software loop can gate on.
1.05 Agent workflows & conversation styles ~40 min

Four foundational multi-agent topologies, the one delegation contract that wires all of them, and conversation style as an auditable design surface. Evaluate two live runs: the Council on local open weights and the Style Council on a free key.

Part 2 — Agent Design and Evaluation

Production multi-agent engineering: define complete agent teams in declarative configuration files, implement persistent memory architectures, extend model reach with live tool execution via MCP, build multi-modal verification pipelines, and enforce automated regression testing before deployment.

2.01 The melchizedek protocol ~45 min

Declarative multi-agent configuration. Define an entire agent team in a single YAML schema, manage tool-based delegation against direct plan-dispatch routing, configure per-agent model providers, and serve multi-agent graphs over standard network protocols.
2.02 Building memory systems for agents ~45 min

Engineering state for stateless models. Separate short-term session state from persistent long-term storage, run the four-stage lifecycle that turns conversation turns into durable facts, enforce store hygiene, and prevent fabricated recollections.
2.03 MCP: extending an agent's reach ~40 min

Dynamic tool integration via the Model Context Protocol. Enable agents to discover tools at runtime, expose an existing database or internal service through one standard connection, query remote data, execute state-modifying actions, and enforce the security perimeter that treats every incoming tool payload strictly as unverified data.
2.04 Multi-modal agents: predictable images, objective eyes ~40 min

Specification-first multi-modal pipelines. Implement a strict division of visual labor: a blind observer that inventories what is present in an image, and a text-only auditor that judges that inventory against the approved contract.
2.05 Multi-agent fact-checking: two channels, one arbiter ~35 min

Multi-source fact verification architectures. Coordinate specialized collector agents that gather evidence without drawing conclusions, routing raw findings to an isolated arbiter agent that synthesizes the final verified account with every fact carrying its source.
2.06 AI builds the feature ~40 min

The autonomous coding loop: plan, edit, run, verify, commit. Implement the four repository instruments — rules file, skills, knowledge docs, and plan artifacts — that load at different phases so an agent can maintain a large codebase without ever holding it in context.
2.07 The grader and the ledger ~50 min

Quantitative agent evaluation. Run test suites across controlled variants, grade performance with deterministic assertions and calibrated judge models, track confidence intervals and human agreement scores, and maintain an append-only audit ledger of every production turn.

Part 3 — Mastering the Principles of LLMs

Transformer mechanics at the level of arithmetic: trace how weights encode statistical structure, how context vectors condition the probability distribution, why fabrication is the default outcome, and how the single-token bottleneck governs sequential reasoning.

3.01 Token by token ~30 min

The iterative forward pass. Trace a three-token sequence through the tokenizer, the embedding lookup, the attention stack, and the final softmax distribution to understand the computational cost of autoregressive generation.
3.02 Two kinds of number ~30 min

Linear algebra fundamentals in transformers. Calculate the dot product by hand to read vector alignment, distinguish static frozen weights from dynamic activation vectors, and examine what transformer weights actually retain besides facts.
3.03 One vector, three sources ~40 min

The anatomy of token scoring. Deconstruct the final pre-softmax vector into its three constituent components: token embedding baselines, self-attention context aggregation, and feed-forward memory retrieval from the frozen weights.
3.04 Six ways to ask one question ~40 min

Contextual sensitivity and prior distributions. Test six prompt variations against a single model to observe how framing alters prediction trajectories, producing fabrication, retrieval conflicts, prompt injection vulnerabilities, or abandoned multi-step calculations.
3.05 The Narrows ~35 min

The autoregressive information bottleneck. Understand why complex multi-step reasoning degrades when forced through a single token prediction, how reasoning models work around the constraint, and why a visible chain of thought represents active computation rather than guaranteed truth.
3.06 Where a fact belongs ~35 min

Architectural trade-offs in knowledge placement. Evaluate the six layers for injecting knowledge into an AI system (pre-training, fine-tuning, system prompting, context grounding, external tools, persistent memory), their operational costs, their failure modes, and the order to reach for them in.

prerequisites and setup

To complete the course online: no account, API keys, or software installations are required. Every interactive trace, terminal checkpoint, and code exercise runs directly in your browser, and every hands-on lesson carries scripted dialogues that reproduce the real model's behavior faithfully. You mark each module complete yourself, and that record lives in this browser alone.

To run the agents locally (optional): if you want to run the reference code and local models on your own machine, the fastest path is the guided setup script. It runs a single diagnostic command to verify system requirements, explains each dependency, and asks for confirmation before making any changes. Alternatively, install the prerequisites by hand — each item below states which modules need it.

Part 2 needs a free API key. Every syndicate from module 2.01 onward runs on a hosted model, so building along with Part 2 — the protocol, memory, MCP, multi-modal review, fact-checking, agentic coding, and the evaluation suite — requires a Gemini key from aistudio.google.com. Its free tier covers every cloud text syndicate in the course, memory embeddings included. Without a key you can still read Part 2 and work through its scripted traces; you cannot run its syndicates yourself.

Part 1's open-weight modules, 1.02–1.05 (no keys required): Ollama (free) plus ollama pull qwen3:8b, and Node.js 22+ for the repo. npm run syndicate:tutor and npm run syndicate:council run entirely on your machine, with no account, no meter, and no data leaving your desk.
Part 2, from module 2.01 (Gemini API key, free): obtained from aistudio.google.com. The free tier runs every cloud text syndicate, including memory embeddings. Only module 2.04's image-generation model requires a paid tier. Because each agent's model is one line of its definition, substituting providers is a supported exercise, not a workaround.
A free Supabase project (required only for the memory module's specimens) to host two tables and the pgvector extension. The repo ships the exact SQL, including the hardening script.
An optional, paid Anthropic key: required only if you point an agent at a claude-* model. This is usage-billed with no free tier, and nothing in the course requires it.
Part 3's mechanism modules, 3.01–3.06 (nothing at all): they study the model itself rather than a syndicate, so they need no install and no key. The one optional exercise at the end asks you to run six short prompts against any model you already have access to.

The full key-by-key cost table, which includes the paid market-data keys for the private financial syndicates, lives on the melchizedek tool page. If you prefer to delegate the setup, melchizedek-agent-setup.md provides a paste-ready prompt for your coding agent, keeping the human steps separate.

The repo is public: github.com/jhwadman/melchizedek-agents. Every syndicate studied here also ships its verbatim agent definition as a download inside its module, allowing you to follow the architecture line-by-line and rebuild it anywhere without cloning the repository. Each module states what its specimen needs.

try the controls

Checkpoints throughout the course look like this: type the letter of your answer and press enter. Every option receives a direct explanation; wrong answers teach, and nothing is scored.

┌─ how this course works ─ checkpoint

▸ the module list