What actually happens at the moment a model learns?

Ongoing research. This is an experimental result from active work, not a settled conclusion. The numbers are what we measured and the method is described so you can judge it, but the programme is still running and later experiments may revise what it means.

A note on the language in these records. This is a working laboratory notebook for research into training AI models more cheaply and efficiently, so you will read that an approach did not work, that a result did not hold up, or that one method was worse than another. That is the research doing its job, not a verdict on the engineering we deliver to clients. Ruling an approach out is how the search narrows, and these are the pages that teach us the most: nearly every technique we now rely on came from understanding why something else fell short. Testing our own ideas at least as hard as anyone else's is the point of publishing them. More about this programme and why we run it.

The jump from guessing to competent takes a few dozen steps. What is going on inside the model during those steps?

Where this stands

It builds machinery rather than selecting it, working through the task in a reproducible order and trying a simpler wrong rule on the way. The visible training curve cannot tell you which is happening.

This is where the commercially relevant finding lives: a model handed finished machinery shows the same training curve as one building it from nothing, so the curve alone cannot tell you what you paid for.

Still open · 14 published results bear on this question.

What this does not settle yet

Stated plainly, because the gaps are as much a part of the record as the answers:

• Why is the first-acquired part the most expensive to remove? The mechanism is unexplained.
• Everything here is one architecture family on one task family.

How these results fit together

Models on these tasks do not improve gradually. They sit near chance for a long time and then climb steeply, and these nine records are about what is inside that climb. The most useful finding is that it is not one event: what looks like a single jump is several acquisitions in a reproducible order, roughly sixteen steps apart. That ordering is stable enough across seeds to be a real property of the task rather than noise. Two records complicate it in ways worth knowing. First, some of that apparent separation is an artefact of scoring by accuracy, which is a winner-takes-all measurement -- scored in bits instead, the acquisitions are about half as separated, though the *order* is untouched. Second, a model handed finished internal machinery largely skips the reorganisation, while one handed a perfect external shortcut does not, which points at the climb being the construction of machinery rather than the discovery of an answer. The most striking negative here is that two models can have nearly identical improvement curves while one is building something and the other arrived with it. The curve alone cannot tell you which you are looking at.

The results

Each of these is a self-contained record: what we asked, what would have proved us wrong, what we found, and what it does not show. They open with a plain-language summary before any of the technical detail.

Back to all research questions