The syllabus — six friendly steps into agent building
Welcome in. The course has six lessons, ordered so each one gives you what you need for the next: a model in the tab, tool calling, loops and goals, agents talking to other agents, vision, then evals. Lesson 1 needs only a browser. By lesson 4, your agent is asking other agents for help. Every lesson is free and comes with code you can run, change, and make your own.
Your path through the course
- 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
| Lesson | 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 | Lesson 1 · a hosted key or Ollama |
| 3 · Loops & goals | A multi-step agent that stops on purpose | Lesson 2 |
| 4 · Blocks.ai | A published handler, and a client that hires another agent | Lessons 2–3 · Node · a Blocks key |
| 5 · Vision | An agent that screenshots its own work and fixes it | Lesson 3 · a vision model |
| 6 · Evals | Ten cases, a grader, a score you can move | Lesson 3 · something worth measuring |
Lesson 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, and nothing to install. Press a button, let a gigabyte or two of weights arrive once into the browser's cache, and after that you are talking to a model with the network off.
This comes first because it clears away nearly every obstacle. There is no billing to set up and no worry about leaving a loop running, so you can spend the whole lesson 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 lessons below is a wrapper around that one exchange.
Lesson 1 was published on Tuesday 8 September: read lesson 1.
One friendly caveat up front: a model small enough to run in a tab has limits. Here that is useful because you can see its choices clearly, immediately, and for free. The harness already talks to Ollama and vLLM if you have them; the in-tab WebGPU path arrived with this lesson, so the very first one needs nothing but the page you are reading.
Lesson 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.
Lesson 2 followed a week later, on Tuesday 15 September: read lesson 2.
It is also the first lesson 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 lesson 1, and then a reason to point the harness at a hosted key or Ollama for the rest of the course.
Lesson 3 — loops and goals
Lesson 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.
Lesson 3 was published on Tuesday 22 September: read lesson 3.
Nothing new is required to get here. This is the same loop from lesson 2 with its exit condition taken seriously, and it is the last lesson before your agent starts talking to code you did not write.
Lesson 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.
Lesson 4 was published on Tuesday 29 September: read lesson 4.
Lesson 4 arrives earlier than its difficulty might suggest, on purpose. A loop that stops when it should is the only real prerequisite, and this is where the course starts connecting to the wider world. It has the most moving parts in the six: latency, remote failures, authentication, and trust. Bring lesson 3's stopping condition with you and you'll have a steady place to begin.
Lesson 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 lesson 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. What you build here is lesson 3 plus eyes: it writes a page, looks at it, notices the overlap, and fixes it.
Lesson 5 is ready today, Tuesday 6 October: read lesson 5.
Lesson 6 — evals
This lesson is a discipline rather than a mechanism. You changed a tool description and the agent seems better. An eval turns that encouraging feeling into evidence you can keep, compare, and build on.
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.
Lesson 6 arrives next Tuesday, 13 October: read lesson 6.
It comes last because it needs something worth measuring, and by now you have five lessons 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 lesson is even possible. Lesson 1 needs a browser. Lesson 2 needs lesson 1 and a key. Lesson 3 needs lesson 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. Lesson 1 has a single moving part and no bill; lesson 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 lesson 3, and both are improvements to an agent that already works rather than steps toward one.
There is more waiting after lesson six
Plenty, and on purpose — six lessons 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-ons hanging off the lesson they belong to, once the six rungs are in place.
Subscribers get each lesson as it is written, in this order. The archive keeps the ones you missed, so signing up late costs nothing.