lyceum@agents

~/curriculum

contents

▸ begin course · 1.01

18 modules · 3 parts · ~12 h · no account — every exercise runs on this page

[□□□□□□□□□□□□□□□□□□] 0/18 marked complete · progress lives in this browser only

This is a course on designing, testing, and trusting AI agents. It moves the way any craft moves: first the instrument, then the work, then the evidence that the work is good. Part 1 is the instrument. You learn what a language model actually computes, you place one on your own machine through open weights, and then you open it up — down to the one vector that chooses each word from its three sources, through one question asked six different ways, to the reason a model drops a step in a long calculation. By the end of the part, fabrication, prompt injection, and retrieval conflicts stop being separate lessons and become one mechanism seen from different angles.

Part 2 is the work. A purpose joined to a sectioned instruction (what the course calls block anatomy) turns the model into an agent; you test and refine it, you orchestrate your first team, and then you hand the whole thing the melchizedek protocol: advanced orchestration, engineered memory, MCP reach into live data, multi-modal review, multi-agent fact-checking, and agentic coding.

Part 3 is the instrument turned on the work. You grade a change over a dataset of real cases, using judges independent enough to be trusted and calibrated against your own labels, and you read the confidence interval before believing the result. You record every production turn in a ledger that keeps the past queryable. Then you put the question in the deploy step, where an answer can still stop a release. Its later modules are in preparation; the syllabus carries the plot so the shape of the course is public before its rooms are.

The rest of the introduction — why this course exists and what you need to run the specimens — continues below the syllabus.

modules

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 — LLM Fundamentals

□□□□□□□□ 0/8

The model itself, from the outside in: what a language model actually computes, how to run one on your own machine through open weights, then the mechanism at the level of the arithmetic — what the weights hold, what your prompt does to them, and why fabrication is the default.

  1. [□] 1.01 The Architecture of Prediction ~40 min How an LLM answers your query, why tokens and the context window govern everything, the three failure classes that follow from statistical prediction, and the two loops that catch them.
  2. [□] 1.02 Running your own model ~40 min Open weights, local inference, and the course's first agent: the Tutor, assembled block by block and run entirely on your machine, with the arithmetic on your own processor and every token staying on your disk.
  3. [□] 1.03 Token by token ~30 min A model writes one token, then runs the whole machine again for the next one. Follow three tokens of one answer through a complete pass — the lookup table, the stack, the distribution the word is drawn from, and the repeat that costs a pass per word.
  4. [□] 1.04 Two kinds of number ~30 min One piece of arithmetic runs a few hundred billion times per word. Work the dot product by hand and read it as a compass — aligned, orthogonal, opposed — then meet the two sets it compares, the frozen weights and the live vectors, and find out what the frozen set actually holds besides facts.
  5. [□] 1.05 One vector, three sources ~40 min The vector that chooses the next word is a sum of three sources: the token's own baseline, the context attention pulls in from earlier positions, and the memory the MLP injects from the frozen weights. Every score a word receives is the sum of their three votes.
  6. [□] 1.06 Six ways to ask one question ~40 min One question, one model, six arrangements of text around it, six different answers. Prior against evidence — the framing that predicts fabrication, retrieval conflicts, prompt injection, and the calculation a model drops halfway through.
  7. [□] 1.07 The Narrows ~35 min Everything a model works out has to leave through one token. That bottleneck is where the depth ceiling comes from, what reasoning models were built to get around, and why a visible chain of thought is working, never warrant.
  8. [□] 1.08 Where a fact belongs ~35 min Six places to put knowledge into an AI system: pretraining, fine-tuning, prompting, grounding, tools, memory. What each one costs, what each one can never do, and the order to reach for them in.

Part 2 — Agent Design

□□□□□□□□□ 0/9

The work the instrument was built for: committing a model to one purpose with a written instruction, testing and refining it, orchestrating teams — then the full ADK protocol: engineered memory, MCP reach, multi-modal review, multi-agent fact-checking, and agentic coding.

  1. [□] 2.01 Generative AI agent design ~40 min A working definition of the agent — goals, actions, observation, adaptation — and the written anatomy that commits a general model to a single purpose it can serve better than any generalist.
  2. [□] 2.02 Testing & refining an agentic workflow ~40 min Prompting is a diagnostic discipline. Isolate the failure, adjust one of five variables, run again; then hand the whole judgment to a critic agent that scores quality as a number a loop can gate on.
  3. [□] 2.03 Agent workflows & conversation styles ~40 min Four workflow topologies, the one delegation contract that wires all of them, and conversation style as an engineered surface you can specify and audit, shown on two live runs, the Council and the Style Council, on local open weights and a free key.
  4. [□] 2.04 The melchizedek protocol ~45 min The full syndicate schema: one definition file describing a whole team, delegation as tool calling, plan-dispatch as its code-level sibling for pure routing, every config surface read as a design decision, multi-model routing per agent, and serving a whole agent graph over the network.
  5. [□] 2.05 Building memory systems for agents ~45 min A model keeps nothing between requests, so memory is a filing system you build around it: session state against long-term facts, the lifecycle that turns a conversation into a durable record, the judgment of what deserves keeping, the hygiene that keeps a store from filling with restatements, and the doctrine that stops a fabricated recollection from reaching a patient.
  6. [□] 2.06 MCP: extending an agent's reach ~40 min Why the Model Context Protocol exists: agents that discover tools at runtime, fetch and modify live data on the far side of a connection, and the trust boundary that makes such reach safe to grant, because everything that crosses the wire is data and never an instruction.
  7. [□] 2.07 Multi-modal agents: predictable images, objective eyes ~40 min Spec-first image generation, and the strict division of visual labor: a blind inventory of what is actually present, kept separate from the audit that judges it against the contract.
  8. [□] 2.08 Multi-agent fact-checking: two channels, one arbiter ~35 min Multi-agent, multi-modal fact-checking: an X-sweep collector and a web-verification collector that gather but never judge, under a tool-free arbiter that writes the true narrative with every fact carrying its source.
  9. [□] 2.09 AI builds the feature ~40 min The agentic coding loop: plan, edit, run, verify, commit; and the four repository instruments that let an agent work across sessions without ever holding the whole codebase in its window.

Part 3 — Agent Observability

□ 0/1

What the work looks like once it runs without you: grading a change over a dataset of real cases with judges you have calibrated against your own labels, recording every production turn so the past stays queryable, and asking "did this get worse?" in the deploy step, where the answer can still stop a release.

  1. [□] 3.01 The grader and the ledger ~50 min Agent quality becomes a number you can compare: a suite of real cases run under controlled variants, graded by scripts and by an independent judge model, every figure carrying a confidence interval and an agreement score with human labels, over a ledger that records every production turn so the past stays queryable.

to take the course

Nothing. No account, no keys, no install, and no model — every exercise runs on this page, and your progress lives in this browser.

to run the specimens

Optional, and staged by module: nothing at all for Part 1's mechanism arc, Ollama for the open-weight modules, and a free Gemini key from module 2.04.

guided setup

One command opens a guided walk-through: it checks your machine, explains each install, and asks before touching anything.

the key-by-key detail, including costs, is below the introduction

why this course

Almost every module studies a living specimen. A real agent team, called a syndicate, comes out of the public repo and onto the page: the agent definition that shapes it, the behavior it produces, the design pattern underneath. You read the theory, then the actual definition, and then you take the controls yourself, through scripted traces, terminal checkpoints, and one hands-on exercise in every module. Here, you handle the knowledge directly.

The conviction driving this course is purpose-driven AI. A general model serves everyone slightly and no one well. An agent is a model committed to one purpose: your patients, your portfolio, your research, your students. Agents are therefore the building blocks of every system we teach. Part 1 gives you the material the blocks are cut from, on land you own; Part 2 cuts the block and teaches the architecture that assembles blocks into institutions.

We write this course for the practitioner who has outgrown the chat window. You already use AI daily, for work, for research, for the thing you are building, and you can run a terminal command and edit a config file. You do not need to be a software engineer, and the course will not try to make you one. It teaches the layer above the code: how to design, instruct, test, and trust a team of agents that serves your own domain, whether that domain is your patients, your portfolio, your research, your product, or your cause.

It exists for the same reason this site exists: individual autonomy in the AI era, becoming better at building AI and better at building with AI. Met through a chat window, generative AI is a superb way to search. Commanded as agents, it drives efficiency, accelerates research, and makes new things under your direction. The machine takes the iterative work, and your attention returns to the questions worth a human hour: which paradigms to doubt, which understanding to pursue, what to build next. What it produces is only as good as your ideas, and only as powerful as the hands that mold it. Every module here is a mold, a way of putting your judgment into a form the machine must obey.

Melchizedek is the specimen, not the syllabus. By the end you will navigate the repo comfortably, and every pattern you take from it (delegation contracts, critic loops, memory doctrines, blind visual review, agentic coding) stands on its own, in whatever stack you already use. The takeaway is what you can design yourself.

Λ Υ Κ Ε Ι Ο Ν · T H E · C U R R I C U L U M I · llm fundamentals II · agent design III · observability prediction · local · mechanism anatomy · testing · memory · mcp evals · judges · the ledger
Eighteen rooms: two wings finished, and the first column of a third standing on its foundation. Enter in order, since each module leans on the last, or wander; the stoa doesn't mind.

what you need

To take the course: nothing. No account, no keys, no install, and no model. Every exercise runs on this page. Every hands-on lesson carries scripted dialogues that reproduce the real model's behavior faithfully, letting you learn without running any local code. You track your own progress with a checkmark in your browser.

To run the specimens yourself (optional, and staged by part): the fastest road is the guided setup — one command that checks your machine, explains each install, and asks before touching anything. Or gather the pieces by hand:

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