Out of Browser courses

Atoms, not pixels

Get a model out of the browser and onto an arm that costs less than a phone.

What this course is

Every lesson ends with a number you measured yourself. Not a benchmark score, not a leaderboard position — your task, your inputs, your hardware. The course keeps them for you as you go, and by the end you have a table nobody could have handed you at the start.

What you'll build

  • An eval harness for your own task, before you trust any model's marketing.
  • A gap table — what the hosted frontier model does that the open one on your desk does not, in points, on your problem.
  • A cost model with real tokens and real electricity, not a pricing page.
  • A working arm — around €120 of servos and printed parts, driven by a policy running locally.

How it works

Module 0 is free and needs no account. Nothing is gated until there is hardware involved. Progress is kept in your browser first and synced to your account second, so the lessons keep working when the network doesn't.

Module 0 — The gap is a number

Measure the distance between the demo you saw and the hardware on your desk, in points, on your own task. Free, and no account needed.

  1. What the demo videos actually show — Two models ship. One is on the public API. The other is not. (10 min)
  2. Build the eval harness — The only lesson with no number at the end, because it builds the instrument. (30 min)
  3. Ten probes that will embarrass you — The probe set you want is the one you would rather not run. (45 min)
  4. Measure the ceiling — One run against the best thing money can call, so you know what you are giving up. (60 min)
  5. The gap table, empty — Build the table the rest of the course fills in. One row is already yours. (45 min)

Module 1 — The model on your desk

Get open weights running locally, then run the same probes and find out what the constraint actually costs you.

  1. Open weights, and which ones actually run — The download is not the hard part. Fitting it on your machine is. (30 min, paid)
  2. Quantisation, without the hand-waving — Making a model smaller changes it. Here is how to find out by how much, on your task. (60 min, paid)
  3. Run the probes locally — The row you have been building the table for. (45 min, paid)
  4. Where it fails, specifically — A gap of four points is not a finding. Four points on occlusion is. (60 min, paid)
  5. Fill in the second row — Two models, one table, and the first honest statement about what local costs. (30 min, paid)

Module 2 — What it actually costs

Tokens, electricity, latency and the crossover point where owning the hardware wins. The module that turns a preference into an argument.

  1. Tokens are not the cost — A fraction of a cent, several times a second, for eight hours, every day. (30 min, paid)
  2. Measure the electricity — Local is not free. It is fixed, which is different, and you should have the number. (45 min, paid)
  3. The latency budget — How long the machine is allowed to think before thinking becomes dangerous. (45 min, paid)
  4. The crossover point — The one chart that ends the argument. (45 min, paid)

Module 3 — The €120 arm

Servos, printed parts and a policy running on your own machine. The module where the course stops being about pixels.

  1. What to buy, and what not to — Including one robot that costs $13,500 and will not run your code. (45 min, paid)
  2. The bench, the stop, and the rules — Set up the physical space before the first thing moves. This lesson has no code in it. (60 min, paid)
  3. One joint, reduced speed — The smallest possible motion, commanded by your own process. (45 min, paid)
  4. Limits are code, not intentions — The joint limit you did not enforce is the one the policy will find. (60 min, paid)
  5. The loop and its clock — A control loop that runs whenever it feels like it is not a control loop. (45 min, paid)
  6. Repeatability is a number — Ask the arm to go to the same place a hundred times and measure how well it does. (90 min, paid)

Module 4 — From pixels to joints

The boundary the whole course has been circling: turning an observation into a bounded, safe action, and evaluating the result like a model rather than a demo.

  1. The boundary, in your own code — Perception proposes. Something else disposes. Make that a file, not a belief. (60 min, paid)
  2. Teleoperation, and why you record it — Drive the arm by hand. Record everything. This is the dataset. (120 min, paid)
  3. A dataset worth training on — Coverage beats volume. Two hundred identical episodes teach one thing. (90 min, paid)
  4. The smallest policy that could work — Start with something you can debug. You can always make it bigger; you cannot always understand it. (120 min, paid)
  5. Evaluate a policy like a model, not a demo — One successful run is an anecdote. You built a harness in Module 0 for a reason. (90 min, paid)

Module 5 — Unplug it

The claim the course opened with, tested: a policy running on your own machine, network cable out, with a number attached.

  1. Pull the cable — The demo the whole course was for, and the things it quietly breaks. (60 min, paid)
  2. Degrade, don't fail — What the machine does when perception gets worse, rather than when it stops. (60 min, paid)
  3. The table, finished — Every row filled, including the one about the machine you actually built. (45 min, paid)
  4. Ship it, or say why not — The last decision, made from evidence, including the option to stop. (45 min, paid)

Related writing