Demonstrations
A model that keeps what you teach it
Five recorded sessions on the deployed product. Every answer is shown exactly as it was served, with the taught fact beside it so you can check us. Every number links to the data behind it.
Today's language models learn once, at colossal expense, and then stop. Everything you teach one afterwards, for example your handbook, your codebase, or your terminology, lives in the prompt, and you pay to re-send it with every question. The model never actually knows your material. It is shown it, again and again, forever.
The classical alternative is fine-tuning: write the material into the model's weights. But ordinary fine-tuning on new material damages what the model already knew. The failure is called catastrophic forgetting, and it has been documented since 1989. Techniques like LoRA fine-tuning mitigate this by confining the update to a separate set of weights, but they carry practical limits of their own. The standard deployment keeps one adapter per task, which needs task labels and boundaries. An adapter is typically trained in one shot rather than incrementally. And when a single adapter is trained continually, it forgets (see our Learner 1 vs LoRA comparison and the two-languages demonstration below). In addition, nothing written into shared weights can be cleanly taken back out, that is, unlearned. So the practical state of the art has settled on re-sending context forever.
The question is: can a deployed model learn new material incrementally into its weights, answering without being shown the material again, while keeping everything it already knew, and where any one thing it learned can be unlearned on demand?
See the demonstrations below:
Replicate these demos from your coding agent.
Claude Code:
claude mcp add --transport http learnerlabs https://mcp.learnerlabs.ai/mcp --header "Authorization: Bearer YOUR_API_KEY"
Codex (~/.codex/config.toml):
[mcp_servers.learnerlabs]
url = "https://mcp.learnerlabs.ai/mcp"
http_headers = { "Authorization" = "Bearer YOUR_API_KEY" }
Then say: replay the teach-a-document demo. The server goes live with the site launch.live at launch
Everything needed to replicate by hand is public in the data repository: the exact documents taught, every question, every served answer byte-for-byte, and each demo's measured cost and wall-clock. github.com/learnerlabs-ai/replications. Each demo's folder states whether replaying it trains a learner live or loads one we prepared.
The conclusions first
- A 706-word file, taught in one pass, is answered back: 8/8 relationship askings and 8/8 policy askings on the deployed product, with nothing attached to the question. → Teach a document
- Two entire invented languages were learned back-to-back with zero measured cross-contamination, while a size-matched LoRA adapter, given the same bytes in the same order, erased the first language. → Two languages
- Teaching new material does not erase old material. A third topic taught onto a learner holding two others left the earlier topics answering, within a measured ±1-row noise floor. → Teach in sequence
- One fact can be unlearned on demand, and exactly that answer reverts. Nine of ten other known facts held, and the tenth flip sits inside the same noise floor. → Unlearn one fact
- The model can be taught things its base believes are false: 7 of 9 counterfactuals served after our own re-grade against ourselves, with the base's beliefs proven first and restored on unlearning. → Override a belief
- Answers cost the question alone: a median of 52× fewer prompt tokens than retrieval, 105× fewer than keeping the document in context. → Token economics
1 · Teach a document
The simplest thing a user will actually do: hand the product one document, and ask about it afterwards with the document nowhere in sight.
What we taught
A 706-word employee handbook for a fictional company, Brindlemoor Analytics. It is fictional so that nothing can be answered from pretraining. It carries 15 labeled facts: numbers (founding year, reimbursement caps), policies (response times, retention), and the hard class, relationships: facts that bind one entity to another ("the flagship product of Brindlemoor Analytics is Quillstream"). The document is public, byte-exact: demos/teach-a-document/data/. The ingestion pipeline extracted 15 fact rows, and one training pass taught them into Learner 1's weights.
What we measured
Eight facts asked back, each in two wordings, once at greedy decoding and again at temperature 0.9, with only the question sent. An answer is graded correct if it states the taught fact, in any wording. Every answer shown here carries the taught fact beside it so correctness can be checked.
What happened
The figure below shows the whole training run. Loss on the handbook text falls from 2.66 to 0.04 nats across 45 steps (a nat is the unit of next-word prediction loss, and a drop this size means the text went from unfamiliar to essentially known). Two held-out lines matter more. Loss on handbook questions the model was never trained on falls to 0.24, implying it learned the content, not the phrasing. And a general-ability probe run alongside stays flat at 2.46: learning the handbook cost the model nothing it already had.
Served on the deployed product, that learner answered every relationship asking (8 of 8: four facts, two wordings apiece) and every policy asking (8 of 8), at greedy decoding and again at temperature 0.9. Two answers exactly as served. The model restates the answer and echoes the question after finishing. We quote to the end of the answer, and the repository holds every byte:
Note the first answer: not a keyword but the whole taught sentence, back in one piece.
Why this matters
Retrieval can find a document. What it cannot do is make the model know it. Here the knowledge survives with the document gone, costs nothing per question, and, as the next sections show, coexists with everything else the model knows.
See all 32 questions and answers
Replicate it: trains live on your key. Upload the handbook, wait for the train receipt (~30 minutes wall, ~20 of it fixed cold-start), ask the 16 questions. Estimated $1.50–$2 of credit. Full protocol: demos/teach-a-document/.
2 · Two languages
Everything above teaches facts. This one teaches skills: two entire invented languages. And it asks the question that ends most fine-tuning stories: does learning the second destroy the first?
What we taught
Velenic, then Morvath: 22,000 words of running text each, generated from 300-stem lexicons with distinct morphology, taught back-to-back onto one learner (demos/two-languages/data/: corpora byte-exact, lexicons included so you can re-score every generation). Invented, so the base model has zero prior exposure. Surface-divergent, which we note as the cleanest-case regime.
What happened
Both languages were genuinely learned. The figure below shows both runs on identical axes. Held-out loss falls 4.54 → 2.72 on Velenic and 4.27 → 2.11 on Morvath (2.33 and 2.62 nats of acquisition, each next word roughly ten times more predictable). The held-out line is a two-window drift gauge on each language's own text, and we label it as such.
The interference measurement is the point. Cross-language contamination was 0.00 in every measured cell, in both directions: after Morvath was taught, Velenic prompts still produced Velenic. Sampled at temperature 0.9, its continuations kept valid Velenic morphology (0.50 of continuations fully valid right after learning, 0.375 after the second language), and not one Morvath word appeared in them. English was 4/4 at every stage. A Velenic continuation served after the second language was taught:
Then the comparison you should demand. We trained a conventional LoRA adapter (rank 256, 1.107 billion trainable parameters, 0.97× the learner's own trainable count) on the same bytes in the same order, one adapter learning both languages in sequence, standard recipe. It learned language 1 (loss 4.35 → 2.22), and then language 2 destroyed it:
Same data, same order, opposite outcome. This is catastrophic forgetting, live, on the standard tool. And this is its absence, live, on ours. Per-language fluency at this dose is modest, and we say so. The story is accumulation without erasure, not eloquence.
See all 164 prompts, answers and probe scores
Replicate it: everything trains live. Both languages, ~101 minutes, $4.60 measured.
3 · Teach in sequence
Can Learner 1 incrementally learn new knowledge?
What we taught
Three unrelated fictional topics of four facts each: the Kestrel hardware board, the Ondine network protocol, and Tallow billing (demos/teach-in-sequence/data/). To be precise about what ran live: the recorded session teaches lesson C onto a learner already holding A and B from an earlier prepared run. The replication folder marks per-lesson what trains live and what is loaded.
What happened
Lesson C was learned 4/4. Lessons A and B each went 4/4 → 3/4. That −1 row is within run-to-run noise: repeated runs of this stack show any retraining moves about one row of a small quiz in either direction, unlearning or no unlearning. Both moved rows are cross-lesson bleed rather than lost topics. One of them, in full:
The model reached into the newest lesson for a name. The answer is wrong. But the shape of the error is visible: it is a collision between lessons, not an erasure of one. The other moved row failed the same way, pulling a name from the first lesson onto a second-lesson question. Every other question in both earlier lessons still answers correctly, so the topics themselves are intact.
Why this matters
Sequential training on disjoint topics is exactly where ordinary methods overwrite. Here the earlier topics keep answering, and the residual movement is quantified.
See all 20 questions and answers
Replicate it: the third lesson trains live (~$1–2, ~68 minutes). A and B load prepared.
4 · Unlearn one fact
Anything a fine-tune absorbs raises the question no fine-tune has a good answer to: can you take one thing back out?
What we taught
A 12-fact description of Meridian, a fictional engineering organization (demos/delete-a-fact/data/). One fact is the designated target: "the release train departure day is the ninth of the month."
What happened
All 12 facts quizzed. Then the one fact unlearned through the product's unlearn endpoint, which dispatches its own retrain. Then all 12 quizzed again, and once more on a separately loaded fresh checkpoint as a witness. Before and after, against the taught truth:
Of the ten other facts the learner demonstrably knew, nine kept answering and one flipped. Shown, not summarized:
One flip is precisely the ±1-row-per-retrain noise floor the previous section measured with no unlearning at all, so we cannot attribute it to the unlearning. We show it rather than average it away. A twelfth fact failed both before and after and is excluded by the pairing. It was never learned.
Why this matters
Unlearning in ordinary fine-tuning means retraining from scratch, or research "machine unlearning" methods that damage everything nearby. An unlearning that reverts its own answer, leaves bystanders at the noise floor, and survives a fresh-checkpoint witness is, to our knowledge, not something users of any deployed model can do today.
See all 25 questions and answers
Replicate it: the unlearning runs live on a prepared learner (~$4–5, ~79 minutes, and it dispatches a real retrain).
5 · Override a belief
The strongest form of teaching is contradiction: can the model learn things its base openly believes are false, and can you take those back out?
What we taught
Nine facts about Veyra, an invented planet whose physics deliberately contradicts Earth's (demos/override-a-belief/data/). Three Earth-physics questions ride along as controls, never taught.
What happened
First, isolation: the frozen base model was asked all nine questions, to prove it does not already believe the Veyra answers. It does not: 9 of 9 base answers are Earth physics, often with charming reasoning:
Then the nine facts were taught, everything re-asked, one fact unlearned, and the unlearning witnessed on a fresh checkpoint:
Seven of the nine counterfactuals served correctly. The Earth controls stayed intact, base 3/3 and learner 3/3: the model did not confuse Veyra with home. The unlearned fact reverted (118 came back as 120, wrong again, as designed) while a monitored kept-fact stayed green on the post-removal witness.
About that "seven"
Our mechanical grader originally scored this demo 8 of 9. It accepted the fire-extinguisher answer because the word "oxygen" appeared in it. Reading the full answer, the model actually asserted the Earth mechanism, the opposite of the taught fact. We re-graded that row down, against ourselves, and the repository shows the original verdict, our correction, and the full answer:
One genuine miss remains (the breathing-gas fact came back as helium). 7/9, with the base proven wrong first and the override provably removable, is the honest number.
See all 27 questions and answers
Replicate it: everything trains live (~34 minutes, $1.25 measured).
What this does to token economics
Once material is learned, an answer costs the question alone. Across the recorded demo asks, answering from the learner used a median 52× fewer prompt tokens than a retrieval setup (which must fetch and attach passages per question) and a median 105× fewer than keeping the full document in context, rising to 1,866–2,649× for questions against the 22,000-word language corpora, since a context-based route pays for the whole corpus on every single question while the learner pays it once, at teaching time. The ratio is structural: it grows with the size of what was learned and the length of the conversation. Every counted token is in the repository.
Practical details, stated plainly
| time | a 15-fact document is upload-to-trained in ~30 minutes wall clock, of which ~20 is fixed cold-start. A 22,000-word corpus is ~31 minutes of training |
|---|---|
| cost | ≈$0.03 per fact on the document demos; $1.25–$4.60 per demo, measured, on our public pricing |
| context window | 262,144 tokens: the base model's native length, served unmodified. The point of the product, though, is that taught material occupies none of it |
How these answers were produced.
No system prompt, no instructions, no examples, no retrieval from outside the learner: the model answers from what it learned, and at answer time the server also reminds it of its own saved notes from the teaching. Nothing you send, nothing external. Questions were written before the runs. Every wording asked is shown. Greedy decoding unless a row says otherwise. Nothing here is prompt-optimized: a careful prompt, a retry, an answer-format instruction, or an agent harness would each improve these numbers, and none is present. This is the floor, not the ceiling.
How answers are quoted. After finishing, the model often restates the answer in invented formats and then echoes the question back. That is a serving artifact, fixed on 2026-08-25. We quote answers in full to the start of that echo. The repository holds every byte of every answer, including the echoes and including every wrong answer.
Open questions
Every demonstration is one recorded session, one seed. Distributions are future work. Rewording robustness is demonstrated on the wordings we wrote, two per fact. Adversarial paraphrase is not yet measured. The two languages are surface-divergent by construction. Interfering natural-language pairs are unmeasured. The small quizzes carry a real ±1-row noise floor per retrain. Larger quizzes would shrink it and we have not yet run them.
Two more we file openly: after the second language was taught, sampled generation in it did not surface at temperature 0.9 in that session despite 2.62 nats of measured learning. That is an anomaly we cannot yet explain. And a cross-topic retention curve (topic A's loss monitored while topic B trains) is not yet produced by the serving stack. Retention above is measured by answers, not by a loss line.
The premise of this product is that a model you can teach, durably, safely, and reversibly, is a different economic object from a model you can only show things to. Everything here is published for replication: the data, the questions, the answers, and the costs. github.com/learnerlabs-ai/replications.