Demonstration 1 · Ten skills, one after anotheras published in the ten-skill report
Skills are acquired in sequence and largely retained
Figure 1. One picture of the run: nothing is answered before teaching, each skill jumps at its own teach, and every skill holds its level while the skills after it are taught. 1,525 of 2,250 panel rows are correct at the end, from 0 at the start, and the base line stays flat throughout. The horizontal axis is the checkpoint after each teach; the vertical axis is the percentage of correct answers. Each skill uses its own fixed 225-row panel. The base line uses the separate 498-item sentinel.
Training loss falls within each successive skill
Figure 2. Training loss over the whole stream: each skill starts high, drops within its own segment, and hands over to the next. Nothing in the stream tells the learner where one skill ends and the next begins. Read left to right across 63,282 single-example updates. The vertical axis is training loss in nats on a logarithmic scale; the line is a 31-update moving average and the band shows the raw range.
All ten skills learn, but reach different held-out losses
Figure 3. Per-skill training and held-out loss during each skill's own segment, on one shared scale. Held-out loss falls with training on all ten and settles at very different levels: near zero for SCAN and COGS, far higher for Oriel and Juniper. Each panel follows one skill during its own teach. The smoothed training curve uses a 31-update moving average; the raw range is shaded, and the held-out trace uses eight monitored rows every 25 updates. Loss is shown in nats on a logarithmic scale.
All ten skills learn, with different loss scales in this view
Figure 4. The same ten panels with a separate loss scale per panel, to show the shape of each curve. Levels are not comparable across panels in this view; use the shared-scale figure for that. Each panel follows updates during that skill’s own teach. Training loss uses a 31-update moving average, with the raw range shaded. Held-out loss uses eight monitored rows every 25 updates. Compare shapes here; use the shared-scale figure to compare levels.
Earlier skills’ held-out loss stays nearly flat
Figure 5. Retention as a loss curve: after a skill's own segment ends, its held-out loss is nearly flat across the remaining tens of thousands of updates on other skills. The English control panel (never trained) stays where it started. The horizontal axis follows updates across the stream; the vertical axis is loss in nats on a logarithmic scale. Lines use eight monitored rows every 25 updates; dots are separate 24-row sweeps at teach endpoints.
SCAN stays at 222; Oriel is the largest change
Figure 6. The checkpoint-by-skill matrix: each skill is scored from its own teach onward, so cells above the diagonal are blank. Read down a column to see a skill's score while later skills are taught: SCAN 222 at every one of ten checkpoints; Meridian moves within 81 to 84; Oriel is the only column that moves by more than two rows.
Nine skills finish within two correct answers of their own teach
Figure 7. All ten skills hold what they learned: nine end within two rows of their own teach, and for Oriel the four working components survive, with the header and escaping right on every row at the end and the payload and decoded length on 92 to 95 per cent of them. Its exact-match count still moves 12 to 9 of 225 because one wrong checksum costs the whole row. Juniper and Meridian end slightly higher than at their own teach. For each skill, compare the mark just after its own teach with the mark after all ten teaches on the horizontal axis, correct answers out of 225.
COGS receives a third of updates and half of supervised tokens
Figure 8. Training dose per skill. COGS received a third of all updates and half of all supervised tokens; the other nine received between 2,835 and 9,850 updates each. The two panels separate the number of single-example updates from the number of supervised answer tokens, including end-of-sequence. Compare skills within each panel; the units differ between panels.
Figure 9. A low held-out loss is necessary but not sufficient for exact-match accuracy: Oriel and Meridian sit at loss levels similar to skills that score far higher, because a single wrong token anywhere in a long structured answer costs the whole row. Each point is one skill at its own-end checkpoint: held-out loss in nats on the logarithmic horizontal axis, and correct answers out of 225 on the vertical axis.
Base capability stays near its starting level
Figure 10. The base does not move materially on the measured benchmarks: the 498-item sentinel stays between 348 and 353 correct across all eleven checkpoints, and the full battery after ten teaches reads MMLU 0.8654, ARC 0.7099, WinoGrande 0.7885 against 0.8634, 0.7056, 0.7948 at step zero. The sentinel panel follows all eleven checkpoints, showing raw and length-normalized likelihood choice. The full battery is measured at teaches 0, 5 and 10. These are different evaluations, not free-generation scores.
Oriel’s decline is concentrated in the checksum
Figure 11. The Oriel decline is localized: between the two checkpoints the header, transformed payload, escaping and decoded length stay correct on essentially all rows, while the final checksum value is right on 15 rows, then 11. Seven rows lost that one value; one row gained it. Compare the two checkpoints for each answer component. The vertical axis counts rows out of the same 225-row panel; the horizontal axis groups answer components. A fully correct answer requires every component to be right.
Figure 1. Three conditions trained on the same four-domain stream. All three learn each domain in turn; the difference between them shows up afterwards, in what they keep. Read left to right through the four domain blocks. Colors distinguish the three conditions; training loss is shown against update number. Use the separate retention figure to assess what survives later training.
All three conditions learn each domain in the raw trace
Figure 2. The raw per-step training loss behind the smoothed stream figure, for all three conditions on identical axes. Read the same four domain blocks from left to right in each condition’s panel. These are unsmoothed per-update training losses; compare them with Figure 8 to see what smoothing changes.
Figure 3. Both Learner 1.0 conditions keep the earlier domains within a few thousandths of a nat while LoRA r256 gives back 0.07, 0.06 and 0.03 nats; all three learned each domain by about the same amount. The forgetting measure compares each earlier domain’s held-out loss at the end of the stream with its own-end loss: positive is forgetting, negative is improvement. Acquisition is loss reduction from each condition’s recorded base reference.
The control loss moves by about 0.01 nats across the stream
Figure 4. On 8 never-trained control windows the two Learner 1.0 conditions move by about 0.01 nats across the stream and sit about 0.12 nats below their recorded base reference. The figure does not isolate how much of that difference arose inside the displayed stream. Read each control measurement against the training checkpoint. The dashed reference is the recorded base loss; the measured control windows are never trained.
Learner 1.0 is near its final loss at the first measurement
Figure 5. Held-out loss while each domain is trained, against the recorded base reference (dashed, value shown). The Learner 1.0 conditions are close to their final level by the first measurement at step 25; the LoRA condition gets there over the 300 steps. All three end each domain at a similar level. Read update number within each domain against held-out loss, with all three conditions on the same panel. Lower loss is better; the dashed line is the recorded base reference.
Learning Morvath preserves Velenic’s held-out loss
Figure 1. Learner 1.0, one-pass recording. Velenic's held-out loss falls from 4.6625 to 2.8880 nats during its own teach and reads 2.8871 after Morvath is taught. Morvath's falls from 4.3636 to 2.2842 during its teach. The horizontal axis is training update and the vertical axis is loss in nats. The amber points use two withheld 256-token windows per language.
LoRA’s first-language loss rises above its starting level
Figure 2. A single adapter learns language 1 (4.35 to 2.22 nats), then learning language 2 pushes language 1 to 6.00 nats, worse than before it was ever taught. English is untouched: the damage is between the two taught skills. Follow the first language’s loss across its own teach and the second-language teach. Lower loss is better. The adapter used its own training schedule, so this is not a matched one-pass comparison with Learner 1.0.
Learner 1.0 keeps the languages apart; LoRA swaps them
Figure 3. Where the LoRA adapter answers language-1 prompts in language 2 after the second teach (0.96), Learner 1.0 keeps the two apart (0.00 in every cell). Each cell measures cross-language contamination at a teaching stage: stems from the other language in a continuation. Lower is better. The cells are means over eight prompts at greedy decoding; these are identity scores, not fluency scores.
Figure 1. Everything above the dashed line happens before you commit to training, and you can read and edit its output. The second path, below the line, has no preparation step and needs none. Read the arrows from the uploaded file through preparation, training and the served answer. This is a workflow schematic; it does not plot measured accuracy.Figure 3. Teaching does not trade away general capability at any point in a learner's history. The two language checkpoints sit 0.0004 and 0.0013 below the base model's row-mean, which is a fifth of a percentage point at most. The three sequence checkpoints sit 0.0014, 0.0003 and 0.0001 above it. There was never a dip to recover from, because there was never a dip. The horizontal sequence follows each learner’s checkpoints; the vertical axis is mean accuracy over 65 task-metric rows, higher is better. The reference line is the untrained base at 0.8583. Each checkpoint is evaluated on 16,481 held-out items.
Every held-out question and answer
Two sets: final = the 2,250 fixed-panel rows (225 per skill) answered by the checkpoint after the tenth teach; own-end = the same 2,250 rows answered by the checkpoint at the end of each skill's own teach. Greedy decoding, exact match against the frozen target, scorer per skill. Two PCFG rows hit the generation cap and count as wrong. Search matches prompt, target, output and id.