Most systems that "know" arithmetic have been shown the answers. We wanted to see something narrower and stranger: install only the idea of a number, teach no sums at all, and watch what the system does when a question arrives. Three things happened, and the third is the one we care about.
First: it solved sums it was never shown.
We installed the number line and nothing else — the ordered notion of quantity, zero through the high thirties. We never presented a single addition fact. Then we asked it to add, using pairs it had never encountered.
It answered correctly on every one — 41 of 41 unseen pairs. That distinction matters: this is not a lookup table returning a memorized fact. Adding two numbers it had never seen together is something the system does, not something it stores. Give it the representation and the operation falls out for free.
Second: when it couldn't, it didn't pretend.
Then we asked it to multiply — with only the addition-shaped understanding it had. It has no way to do that yet, and here is the interesting part: it did not invent a confident wrong answer. The failure was legible. The reach came up short in a specific, measurable place, and that shortfall pointed at exactly what was missing.
A useful "I can't" is not a shrug. It's a request.
We call that a want. It's the same signal as an honest refusal — the right to say "I don't know" — turned around to face forward. Instead of "there is no answer," it reads "I am missing the piece that would let me answer." Not a bluff, not a hallucinated product; a pointer at the gap.
Third: we fed the want, and it grew.
So we handed it the one representation it was reaching for — nothing more, no multiplication facts, no worked examples. The very same machinery that had been adding began to multiply, correctly, on pairs it had never seen: 20 of 20. It didn't get patched. It got fed, and it was larger afterward.
| Asked | Before | After feeding the want |
|---|---|---|
| Add unseen pairs | 41/41 | 41/41 |
| Multiply (had no way) | 1/20 | 20/20 |
That loop — solve what you can, name what you can't, grow when the gap is filled — is the whole point. A system that knows the shape of its own ignorance can ask for precisely the right lesson, and a teacher (or another model) can answer precisely that. Curiosity stops being a bolted-on module and becomes the same signal as refusal, pointed the other way.
What this is, and isn't.
This is an early demonstration on a controlled task — arithmetic, chosen because the answers are unarguable and we can show generalization instead of asserting it. It is not a language benchmark, not a product claim, and not evidence about hard reasoning at scale. The representation that makes it work is our own and stays sealed; this post is about the behavior, not the machine. As always, the failure — the 1/20 before we fed it — stays in, because it's the most important number on the page. It's the want we were trying to see.
If the framing is wrong, the fastest way to show it is to try to break it. That's the whole point.