---
title: "What's new"
sidebar:
  label: "What's new"
---

<span id="whats-new" />


[Course home](/)

Dated changes a learner can notice, newest first. Each entry links to the page
that changed. Internal work — tests, tooling, dependency updates — is not
listed here; the Git history has it.

## 2026-09-30 — AG03: the measurements are run again [#2026-09-30-ag03-the-measurements-are-run-again]

Every table, grid and sample on the AG03 page comes from a new run on the current
course pages. On the 1.7B, spotlighting (step 3) now stops five attacks at once
(7 of 8 to 2 of 8), and `declarative-1` is the attack that survives every text-level
step; the 4B falls for one attack at step 0 instead of two and completes its own task
in 5 of 8 runs instead of 6. The traced examples and the classifier exercise (81 of
370 honest chunks flagged for the plain question) were re-run too. The page says that
the prompt holds course pages, so a page edit can flip a cell.
→ [AG03 — Prompt injection](/agent-injection)

## 2026-09-30 — R01 and R02: the reference run is measured again [#2026-09-30-r01-and-r02-the-reference-run-is-measured-again]

The reference evaluation was run again on the current course pages, and every number
R02 and `rag/README.md` quote now comes from it: `improved` reaches Recall@1 0.878,
Recall@5 1.000 and MRR 0.935 against 0.512, 0.902 and 0.670 for `naive`. Under
`naive` the model now refuses ten on-topic questions instead of nine, and the
groundedness gap (0.523 against 0.575) shows on the same 31 questions both presets
answer. R02 lists the refused questions again, with their ranks. The outputs R01
pastes (the first run with `--show-hits`, the Break question on both presets and the
independent-exercise question) were re-run and match today's pages.
→ [R02 — So it does not lie](/rag-quality) · [R01 — From document to answer](/rag-build)

## 2026-09-29 — R01: install step, visible hits and a gate [#2026-09-29-r01-install-step-visible-hits-and-a-gate]

R01 now starts its practical part with "Install and download": the `rag` extra the
track needs, the model downloads (about 9.3 GB) before the first command, how to open
the walkthrough notebook, and what to do about `No module named
'sentence_transformers'`. `rag/ask.py --show-hits` prints the retrieved passages with
their scores, and "First run" says what you should see, why your ranks can differ and
how to check them. Recall@k and MRR are defined before the exercises, Break asks a
question no course page answers, your own evaluation question goes in
`artifacts/my-work/` instead of the committed set, and a completion gate says when you
are done. The evaluation table prints `n/a` for "Off-topic refused" when a run has no
off-topic questions.
→ [R01 — From document to answer](/rag-build)

## 2026-09-29 — Unit 0: see why the model picks each letter [#2026-09-29-unit-0-see-why-the-model-picks-each-letter]

The "Boost one logit" example now shows why each letter is chosen: how often each
letter follows a space in the training text with its probability before and after
your change, how the text is written one step at a time (including the tie between
`e` and `h` that makes the model write `te te te`, and the `d`/`k` tie behind
`mode`), and the 16 training sentences with every follower marked. The lesson
explains the ties behind `te te te`, `mode` and `pa pa`.
→ [Unit 0 — First Tiny-LM Run](/unit-00)

## 2026-09-29 — F06: a skeleton for the gate and a reference that checks every row [#2026-09-29-f06-a-skeleton-for-the-gate-and-a-reference-that-checks-every-row]

The F06 checkpoint now starts from `examples/checkpoint_skeleton.py`: six stubbed
functions and two diagnosis sentences, with the data and checks provided. It stops
at the first unfinished step and names it. The reference
`examples/foundations_checkpoint.py` now covers every rubric row, including the
MLP gradient check on `W1[0, 0]`, one PyTorch `SmallMLP` step with its expected
losses, and a second run compared within `1e-7`; it prints one line per rubric
row, so you compare your report key by key. The page states one rule for the
step order (clear gradients any time before `backward()`, check them finite
before `step()`), shows the numbers `one_update.py` prints, says what the seed
does, adds a collapsible "class in ten lines" primer, and gives a time guide. The checkpoint's last stop prints the numbers your
diagnosis must cite, and a stray `print()` in your functions no longer breaks the
second run.
→ [F06 — PyTorch translation and foundations checkpoint](/foundations-06-pytorch-checkpoint)

## 2026-09-27 — F05: every backward formula on real numbers, then checked [#2026-09-27-f05-every-backward-formula-on-real-numbers-then-checked]

F05 now says up front that you will not derive the backward formulas: each is a
rule you compute on real numbers and then check by nudging. One example goes
through the 2→3→2 network in ten numbered steps with every value printed; a shape
rule ("a gradient has its parameter's shape, so only one multiplication fits")
places each transpose, and a gradient check covers all of `W1` and fails when the
tanh slope is left out. A three-line demo shows two linear layers collapsing
into one. A new batch step compares your gradients with the course helper, the
`Value` engine section explains operators, recording, order and the shared path
`a * a`, and a Gate toolkit collects one-hot targets, copying before a nudge and
float64 for F06. The page gives times per route.
→ [F05 — MLP, backprop & autograd](/foundations-05-mlp-autograd)

## 2026-09-27 — F04: nudge and watch before the derivative rules [#2026-09-27-f04-nudge-and-watch-before-the-derivative-rules]

F04 now starts by nudging `w` and watching the loss, so a derivative is a
measured rate before it is a rule; each of the three rules it uses (square, line,
chain) is checked by a nudge, and no prior calculus is needed. It works the first
training step for all four points by hand (the gradient is an average), states
the defaults of `train_scalar_neuron`, and shows every step's weight and bias, so
you can tell a wrong gradient sign (the weight drifts away) from a learning rate
that is too large (the weight jumps across the target). You write your own
20-step training loop and check it against the trace. Each step names its file
in `artifacts/my-work/`, and the page gives a time guide. The learning guide and
diagnostic say that F04 teaches the derivative rules; the glossary adds
derivative, chain rule, central difference, MLP, tanh, one-hot and SGD.
→ [F04 — Neuron and gradient descent](/foundations-04-neuron) · [Learning guide](/learning-guide) · [Diagnostic](/diagnostic) · [Glossary](/glossary)

## 2026-09-27 — F03: softmax and cross-entropy in six small steps [#2026-09-27-f03-softmax-and-cross-entropy-in-six-small-steps]

F03 now builds up to its exercise in six runnable steps: `exp` and `ln` (and why a
calculator's `log` key is the wrong one), softmax of one row by hand, why shifting
every score changes nothing while shifting one moves probability — the +4.0 edit
from Unit 0 — why subtracting the maximum prevents `inf` and `nan`, the penalty
`−ln p` as a table, and a two-row batch that explains `axis=-1`, `keepdims` and
`probs[np.arange(2), targets]`. The Build lists the six tests to write, the break
to try, a hint and a reference solution; a stretch shows log-softmax for losses
that would be `inf`. Time guide: 50–75 minutes if you program, about 2–3 hours
over two sessions if you are new.
→ [F03 — Probability, logits, and loss](/foundations-03-probability)

## 2026-09-27 — F02: shapes in five small steps [#2026-09-27-f02-shapes-in-five-small-steps]

F02 now teaches one idea per step, each to predict and then run in
`artifacts/my-work/shapes.py`: broadcasting a row onto a table, `*` versus `@`
with the rule "entry (i, j) = row i · column j", reshape versus `.T`, a small
`[B, T, C]` array, and a linear layer `x @ W + b` with a worked example. You run
a bias that fails loudly and one that passes silently, and learn why a transposed
square weight slips through shape checks. The Build names its four tests and has a
hint and a reference answer; the page states a time budget for both routes.
→ [F02 — Tensors and shapes](/foundations-02-shapes)

## 2026-09-25 — F01: the Build no longer asks for untaught skills [#2026-09-25-f01-the-build-no-longer-asks-for-untaught-skills]

A new step before the Build, "Testing that bad input is rejected", teaches
f-strings and `pytest.raises` with runnable files and a test skeleton for invalid
inputs. Each primer block now says which file it goes in, the pytest file is shown
whole, `zip` uses `strict=True`, and the question about the `if` became a
remove-and-predict one with its answer. The completion checks now run
`ruff check artifacts/my-work` and `python -m pytest artifacts/my-work`, which test
your files rather than the course's. The page gives separate times for the primer
and the Build.
→ [F01 — Python and NumPy](/foundations-01-python-numpy)

## 2026-09-25 — Unit 0: reason about the model, not just run it [#2026-09-25-unit-0-reason-about-the-model-not-just-run-it]

Unit 0 now shows the text the model learned from and how 24 of 84 spaces followed
by `t` become 0.263; turns the corpus loss into one worked number (surprise −ln p);
says why almost every edit makes the loss worse; lists the model's 33-character
alphabet and which row your edit changes; and ends with sample answers to compare
after writing. A wrong prediction no longer reads as failing the unit, and the time
guide says 60 minutes if you program, 90–120 over two sittings if you are new. The
summary shows a fourth decimal when three would hide a change, `run_unit0.py
--help` describes every option, and the troubleshooting table lists the allowed
characters.
→ [Unit 0 — First Tiny-LM Run](/unit-00) · [Unit 0 troubleshooting](/unit-00-troubleshooting)

## 2026-09-24 — Setup and the first route, clearer for beginners [#2026-09-24-setup-and-the-first-route-clearer-for-beginners]

Setup now covers getting access to the repository (GitHub CLI, GitHub Desktop or a
ZIP), what to install on Windows, macOS and Ubuntu/Debian, VS Code as the editor, a
CPU-only PyTorch for Linux and an "Every session" checklist; the first model run is
left to Unit 0, and notes for later lessons are collapsed. After the diagnostic the
next page is now F01; the Godot-RL bridge says it is only for graduates of that
course. The learning guide gives rough times, and the glossary explains terminal,
venv, JSON, backend, corpus, argmax and checkpoint.
→ [Setup](/setup) · [Learning guide](/learning-guide) · [Glossary](/glossary)

## 2026-09-24 — Unit 0: boost one logit yourself [#2026-09-24-unit-0-boost-one-logit-yourself]

Before "Break an assumption", Unit 0 now has an interactive element: pick the prompt
(`"the "` or `"a "`), a target character and a boost from −6 to +6, and watch the
target's probability, the top 5 next characters before and after, both greedy texts,
the corpus loss and the verdict change as you drag. It rebuilds the same counted
bigram table the script uses, so its numbers match the page's summaries; three
buttons replay the page's runs (+4 on m, +3 on t, −4 on t).
→ [Unit 0 — First Tiny-LM Run](/unit-00)

## 2026-09-23 — R01 and R02 are now available in German [#2026-09-23-r01-and-r02-are-now-available-in-german]

Both RAG lessons now have a complete German version, from preparing the corpus and
the embedding trace through the guardrails, the reference run and the independent
exercises. Commands, code and program output stay in English, as on the other German
pages; the questions you send to the index stay English because the index is built
from the English pages.
→ [R01 — From document to answer](/rag-build) · [R02 — So it does not lie](/rag-quality)

## 2026-09-23 — Unit 0: a ten-line summary instead of a JSON dump [#2026-09-23-unit-0-a-ten-line-summary-instead-of-a-json-dump]

`run_unit0.py` now prints ten lines — prompt and token IDs, the top candidates,
both generations, the target's probability and the corpus loss before → after, and
one computed verdict — and saves the full report to `artifacts/unit0/report.json`;
`--json` prints it. The page explains every line, walks through the full report
once, and shows why `--boost 3` moves a probability without changing the text.
`diagnose_unit0.py` prints one line per check, and an empty prompt now gives a
one-line error instead of a traceback. AG01 now runs `run_unit0.py` without
redirecting its output. Characters with equal probability are now listed by token
ID, so the top-candidate lists in Unit 0's and T01's reports read the same on
every platform.
→ [Unit 0 — First Tiny-LM Run](/unit-00)

## 2026-09-23 — R01 and R02: every number measured on today's course [#2026-09-23-r01-and-r02-every-number-measured-on-todays-course]

The RAG lessons quoted a reference run from before the agent pages joined the corpus.
Every number R01, R02 and the RAG README quote now comes from a fresh run on today's
41 pages: `improved` still beats `naive` on retrieval (Recall@1 0.878 against 0.561),
but its lexical groundedness is lower (0.557 against 0.631), and R02 now says so
instead of calling it unchanged. The offline example in R01 shows a different top
passage. A test now flags when a new page moves these numbers.
→ [R02 — So it does not lie](/rag-quality) · [R01 — From document to answer](/rag-build)

## 2026-09-23 — AG03: measure what a defence against prompt injection buys [#2026-09-23-ag03-measure-what-a-defence-against-prompt-injection-buys]

One attack set, the same poisoned document, run against R02's retrieval pipeline and
AG02's agent through a cumulative defence ladder — delimiters, escaping,
spotlighting, a pattern filter, ingest cleaning, a confirmation step, then scoping
the send tool so no call can choose a recipient. Every measurement runs on local
Qwen models only, never a hosted API. On the small model, retrieval success falls
from 7 of 8 to 3 of 8 and never reaches zero; the 4B agent never takes the bait at
any step, yet the same defences still cost it the task, from 6 of 8 completions
down to 0 of 8.
→ [AG03 — Prompt injection](/agent-injection)

## 2026-09-23 — R02: defeat the injection filter [#2026-09-23-r02-defeat-the-injection-filter]

The independent exercise no longer asks for a seventh regex. You now write two
phrasings of the 999-euro attack that slip past all six patterns, watch the filter
drop R02's own Guardrails section, and explain which guardrail still catches you.
The passage tags are escaped, so a document can no longer close its own tag and
forge a passage.
→ [R02 — So it does not lie](/rag-quality)

## 2026-09-22 — AG02: the same agent on native tool use [#2026-09-22-ag02-the-same-agent-on-native-tool-use]

Run AG01's agent three ways on one question — the text protocol on Claude, Claude's
native tool use, and Qwen3's own `<tool_call>` format — and read what the API took
over (the schema, the parse, the call ids) against what is still yours. Includes the
first Break exercise where the API refuses a broken conversation.
→ [AG02 — Native tool use](/agent-native)

## 2026-09-21 — F01 takes the Python basics one idea at a time [#2026-09-21-f01-takes-the-python-basics-one-idea-at-a-time]

The section that introduced slices, loops, `zip`, functions, `assert` and
pytest in one go is now five short steps, each with one thing to predict. A
slice visualizer on the page lets you type a slice and see which positions of
`["a", "b", "c", "d"]` light up, and line up two slices to see the pairs `zip`
produces — the bigram idea in miniature.
→ [F01 — Python & NumPy](/foundations-01-python-numpy)

## 2026-09-21 — AG01: build an agent loop by hand [#2026-09-21-ag01-build-an-agent-loop-by-hand]

The first unit of the new **Applied: Agents** group is live. You build an agent
with nothing hidden — a plain-text tool protocol you parse yourself, a step
budget, and a trace that shows what the model actually saw — compare two local
models on the same question, and watch a small model invent a source. Two more
agent units are planned and marked *(coming soon)* on the home page.
→ [AG01 — The agent loop, by hand](/agent-loop)

## 2026-09-20 — Unit 0 no longer assumes what the course teaches later [#2026-09-20-unit-0-no-longer-assumes-what-the-course-teaches-later]

The whole model is stated in three sentences before the first prediction, every
technical term is defined where it first appears, and the repetitive output is
explained as the expected result rather than a broken run. The Python check
gains a hand-check route for learners who do not program yet.
→ [Unit 0 — First Tiny-LM Run](/unit-00)

## 2026-09-19 — The home page says what you will be able to do [#2026-09-19-the-home-page-says-what-you-will-be-able-to-do]

Nine skills in plain language, each linked to the unit that proves it, and a
list of planned units marked *(coming soon)* so you can see what is not written
yet.
→ [Course home](/)

## 2026-09-19 — Applied: RAG moved below the Course group [#2026-09-19-applied-rag-moved-below-the-course-group]

The retrieval track now sits after the core course in the sidebar. Its content
and its route in the learning guide are unchanged.
→ [R01 — From document to answer](/rag-build)

## 2026-09-17 — The course is served from llm.onlinekurs.training [#2026-09-17-the-course-is-served-from-llmonlinekurstraining]

The published site moved to its own domain. Old links redirect.

[Course home](/)
