The syllabus — six units, easiest first
The course now has a shape. Six units, ordered by how little has to be true before you can start one: a model in the tab, tool calling, loops and goals, agents talking to other agents, vision, then evals. Unit 1 needs a browser and nothing else. By unit 4 your agent is hiring other agents. Each unit is a lesson or two by email, free, with code you run rather than read.
The climb
- A model in the tab WebLLM · no key, no server, no bill
- Intro to tool calling the loop that turns a chat model into an agent
- Loops and goals many steps, and knowing when to stop
- Agent communication Blocks.ai — your agent hires, and gets hired
- Vision screenshots in — the agent sees what it built
- Evals a number, so “better” stops being a feeling
At a glance
| Unit | You build | You need |
|---|---|---|
| 1 · WebLLM | One completion, on your own GPU, for free | A WebGPU browser |
| 2 · Tool calling | A weather tool and the loop around it | Unit 1 · a hosted key or Ollama |
| 3 · Loops & goals | A multi-step agent that stops on purpose | Unit 2 |
| 4 · Blocks.ai | A published handler, and a client that hires another agent | Units 2–3 · Node · a Blocks key |
| 5 · Vision | An agent that screenshots its own work and fixes it | Unit 3 · a vision model |
| 6 · Evals | Ten cases, a grader, a score you can move | Unit 3 · something worth measuring |
Unit 1 — a model in the tab
A language model running entirely inside the browser, on your own GPU, through WebLLM. No account, no key, no server, no per-token cost, nothing to install. You press a button, a gigabyte or two of weights arrives once into the browser's cache, and after that you are talking to a model with the network off.
This is first because it deletes every obstacle at the same time. There is no billing to set up and no fear of leaving a loop running, so you can spend the whole unit on the only question that matters at the start: what does a model actually receive, and what does it actually send back? Messages in, tokens out. Everything in the five units below is a wrapper around that one exchange.
This one lands on Tuesday 8 September: read unit 1.
The honest caveat, stated up front: a model small enough to run in a tab is not a clever model. Here that is a feature — it fails in ways you can see, immediately, for free. The harness already talks to Ollama and vLLM if you have them; the in-tab WebGPU path lands with this unit, so the very first lesson needs nothing but the page you are reading.
Unit 2 — intro to tool calling
The agreement that turns generated text into an action you carry out: you hand the model a list of functions, it emits a name and some JSON, your code runs the real thing, you paste the result back. That loop is the whole of agents, and it is about twenty lines.
It sits second because it is the first idea with a moving part, and because everything after it is a refinement of it. Written out by hand in JavaScript and Python, with the SDK shortcuts introduced only afterwards — once is the right number of times to write the loop yourself.
This one follows a week later, on Tuesday 15 September: read unit 2.
It is also the first unit that wants a capable model. Small local models call tools unreliably — they invent parameter names, or narrate the call instead of making it — which is a genuinely useful thing to watch once in unit 1, and then a reason to point the harness at a hosted key or Ollama for the rest of the course.
Unit 3 — loops and goals
Unit 2 gets you one tool call. That is a transaction, not an agent. An agent is a loop with a stopping condition, and almost every agent that misbehaves in public is misbehaving here: it cannot tell that it is finished, or it decides it is finished three steps early.
So: stop_reason and every value it can hold. Turn caps and
why while (true) is a bug with a delay. Stating a goal the
model can actually check itself against, rather than a vibe. What happens
when a tool hangs, and what a retry should and should not do. Then the
build: a task that needs several steps in order — read a file, change it,
verify the change landed — with a counter and a real termination check.
Nothing new is required to get here. This is the same loop from unit 2 with its exit condition taken seriously, and it is the last unit before your agent starts talking to code you did not write.
Unit 4 — agent communication
Your agent stops being alone. Blocks.ai is a network
where agents publish what they can do and hire each other to do it: you
write a task card and a handler, run it with
blocks run, and your agent is reachable. In the other
direction, a client in your own code can hand work to an agent you did
not write and never see the inside of.
The build is both halves — publish a handler that answers one narrow kind
of task, then a client that hires someone else's agent for something you
deliberately did not implement. The harness scaffolds both halves for you
— the agent card, the handler.js that
@blocks-network/sdk runs, and a browser consumer page that
submits tasks — so the lesson is about the ideas rather than the
boilerplate. The one piece left to you is the token endpoint that mints a
JWT for the page, because the alternative is your API key in public
JavaScript.
Fourth, and this is the placement worth arguing about — it is much earlier than the difficulty warrants, on purpose. A loop that stops when it should is the only real prerequisite, and this is where the course stops being a tutorial. It does have the largest blast radius in the six: latency is real, the failure may be someone else's, a task can be accepted and then abandoned, and authentication and trust become your problem. Bring unit 3's stopping condition with you and none of that is fatal.
Unit 5 — vision
Images as input. Send a screenshot alongside your text and the model can describe a layout, spot that a button is off-screen, read an error out of a terminal photo, or compare what it built against what you asked for.
Mechanically this is the smallest unit in the course — one new kind of content block and you are done. It is placed here anyway, because seeing is only interesting once there is a loop to put it inside. An agent that can look at a page is a novelty; an agent that writes a page, looks at it, notices the overlap, and fixes it is unit 3 plus eyes. That is the build.
Unit 6 — evals
The unit that is a discipline rather than a mechanism, and the one most people skip. You changed a tool description and the agent seems better. Is it? “Seems” is not evidence, and with a non-deterministic system your memory of the last five runs is actively misleading.
So you build the smallest thing that fixes that: ten cases with known good outcomes, a grader that scores a run without you watching it, and one number. Then you change a single sentence in a tool description and watch the number move — up, or, instructively, down. After that you make changes with evidence, which is the entire difference between an agent that demos well and an agent that works on Monday.
It comes last because it needs something worth measuring, and by now you have five units of it: a loop, a stopping condition, a remote agent whose reliability is not yours to control, and a cheap in-tab model you would like to know whether you can get away with. Every one of those is a question an eval answers and an argument cannot.
Why this order and not another
Two things decide the sequence. The first is prerequisites: how much must already be working before a unit is even possible. Unit 1 needs a browser. Unit 2 needs unit 1 and a key. Unit 3 needs unit 2 and nothing else. The second is blast radius — how many things can be wrong at once while you are trying to learn one of them. Unit 1 has a single moving part and no bill; unit 4 has a network, a stranger's code, a clock and money.
Those two agree about the first three rungs and disagree about the fourth, and the disagreement is deliberate. By blast radius alone, agent communication belongs last. It is fourth instead because it is the reason most people are here, and a course that saves the interesting part for week six is a course people quit in week three. So it lands as soon as its one real prerequisite — a loop you trust to stop — is in place. Vision and evals follow: both need only unit 3, and both are improvements to an agent that already works rather than steps toward one.
What is not in the six
Plenty, and on purpose — six units is a course somebody finishes. Context and compaction, sandboxing, sub-agents and delegation, planning that survives a wrong turn, and the undo stack that rewinds files and conversation together are all still on the longer list. They arrive as follow-on lessons hanging off the unit they belong to, once the six rungs are in place. The ladder is the spine, not the whole skeleton.
Subscribers get each unit as it is written, in this order. The archive keeps the ones you missed, so signing up late costs nothing.