An AI That Teaches on a Whiteboard, Draws as It Talks, and Can Be Interrupted, Then Ranks Six Models on Teaching
What This Thing Actually Does
An AI tutor that writes, draws, and erases on a whiteboard while it explains, and lets the student cut in mid-lesson. That sounds like some advanced model capability, but the author pops that illusion right away: it is not a model ability at all, it is a small, clever protocol. The model streams drawing instructions as JSON, a browser plays them back as handwriting stroke by stroke, and when the student interrupts, the app sends the current board state back to the model so it can carry on from there. Because the model never touches a canvas, any LLM can be the tutor. The repo is really two things bundled together. One is a reference implementation of that loop: the protocol, a whiteboard player, and a runner for Claude, Gemini, and DeepSeek. The other is a benchmark, with the same prompt, the same eight scenarios, six models, two thinking settings, three repeats each, and every board kept in the repo so you can replay any of them.
Why It Blew Up Recently
I think it caught fire because of a genuinely smart angle: everyone is busy measuring whether models can solve problems, and this project goes and measures whether they can teach. Teaching cannot be judged on words alone, the diagrams have to be right too, and that turns an invisible ability into something you can tell right or wrong at a glance. Even better, the evaluation is painstaking: blind review, random ids, hidden model names, a fixed rubric, plus a model that was not under test and a human audit sample for cross-checking. That kind of rigor is rare in an environment where leaderboards get thrown together casually. Then there is the comparison image of six models tackling the same question, why the Pythagorean theorem works, where some get the geometry right and one draws the c-squared square outside the hypotenuse. It spreads because the difference is obvious. Publishing the roughly forty-eight dollars of API cost for the whole matrix just hands everyone a reproducible ruler.
The Interesting Bits
The protocol is beautifully small. The model emits no images, only steps, and each step carries one line of narration plus a list of operations. On a 1600 by 900 board there are just six moves: write, line, rect, ellipse, path, and erase. Because the first operation can be drawn the moment it arrives, the fastest model puts down its first stroke in two to four seconds, well before the lesson finishes generating. Interruptions are handled too: when a student cuts in, the app stops the stream and sends the model the question along with every object on the board, its id, type, bounding box, and text. The model replies with new steps only and may erase or annotate existing objects by id. The evaluation runs 288 times. For blind review, boards are rendered to images under random ids, scores are written to disk before the id mapping is opened, and the reviewer is Claude Fable 5.2, which was not one of the tested models, checking geometry from pixel positions. The runner is thoughtful as well: it pins every OpenRouter model to its first-party provider, disables fallback, caps per-model and total spend, and appends every call to a JSONL file so an interrupted run can resume.
Who It Is For
Anyone building education technology should study its methodology, because it breaks AI tutoring into a reproducible protocol instead of a black-box demo. People doing model evaluation will appreciate the blind review plus human audit flow, especially the finding about how unreliable an automatic linter can be as a judge, which is a useful warning for anyone writing evals. Prompt engineers can take the frozen protocol prompt and study how to make a model reliably emit structured instructions. Teachers and the merely curious can open the live gallery and watch lessons being written without installing a thing. Generating new lessons does need an API key and a runner, and the full matrix costs about four dollars.
Quick Start
To just see the results, there is nothing to install: clone the repo, cd into it, run python serve.py, and open localhost:8811, or use the online gallery. To run a model yourself, first pip install -r requirements.txt, then export OPENROUTER_API_KEY and DEEPSEEK_API_KEY, using the bundled set_key.ps1 on Windows. Next run python bench/run.py preflight to check keys, smoke for a few cents of samples, main --confirm for the full matrix, and finally python bench/aggregate.py for the tables. To try the runner for free, there is a mock_server.py that imitates the three APIs locally.
How It Compares
- General AI chat tools: they explain with text and formulas but cannot draw the figure, and cannot continue on the same board after you interrupt.
- Dedicated homework or tutoring apps: answers are standardized, with no write-as-it-teaches process and no cross-model comparability.
- Vision models generating images directly: quick pictures, but no step-by-step playback, no editing a single object by id, and no structured teaching steps.
- This project: an extremely small protocol, any LLM can join, replayable boards, mid-lesson interruption, and a way to turn how well it teaches into a quantifiable blind-reviewed question.
- The catch: only eleven boards per model were blind-reviewed, so the middle ranks are not really distinguishable; there is a single frozen Chinese prompt across eight scenarios; the review looked only at final boards, not intermediate states or animation pacing; and handwriting depends on the system font, so replays outside Windows look a little different.