A small AI that solves problems it was never trained on, by thinking longer.

01

The result, in one picture

Our models solve reasoning problems in steps. A problem's difficulty is simply how many steps it takes to solve: an easy one might take three, a hard one twenty. We trained the model only on problems of up to eight steps, and then did something deliberately unfair to it: we tested it on problems needing twelve, sixteen, and twenty steps, none of which it had ever seen in any form.

We ran the test twice. First with the model held to the amount of thinking it used during training, the way a conventional model is built to run. Then again with one change only: it was allowed to keep thinking until it decided, on its own, that it was done. Same model, same weights, same problems. Each score below is the share of hundreds of fresh problems answered exactly right, so 11% means 11 of every 100 problems, and there is no partial credit.

Three independent trainings, each started from a different random beginning, on a single consumer graphics card. Before running, we wrote down the bar the result had to clear, a gain of at least 0.10. It cleared that bar by roughly nine times.

A conventional model cannot do the right-hand column, and this is worth sitting with for a moment. A standard architecture spends a fixed amount of computation on every input it will ever receive, decided once, at design time. When a problem needs more reasoning than that allowance, there is nowhere for the extra reasoning to happen. Our model treats thinking time the way a person does, as a resource you spend in proportion to the problem in front of you, and that single property is what turns 11 of every 100 into essentially all of them.

02

A model that decides how long to think

Here is a strange fact about how most AI models work, one that becomes hard to unsee. Ask a standard model what two plus two is, and it runs through its full machinery. Ask it to work through a genuinely difficult problem, and it runs through the same machinery, no more and no less. Imagine a person who worked this way: the same number of hours on a grocery list as on a mathematical proof. We would find that bizarre, because we understand intuitively that effort should scale with difficulty.

Our models are built around that intuition. They think in rounds, and they decide for themselves when they have thought enough to commit to an answer. Easy inputs resolve in a round or two. Hard inputs get the sustained effort they actually need. How the model makes that decision is the part of our work we keep private; what it does, and whether it works, is measured on this page.

We checked that the decision is genuinely deliberate and not a lucky accident. Across a large set of problems, the harder the input, the more rounds the model spent on it, with a correlation between difficulty and effort of 0.999, about as close to perfect as a measured behavior gets. The model is not guessing how hard to think. It is reading the difficulty and responding to it.

03

What deciding when to stop is worth

Computation is the single largest cost of operating an AI system, and unlike the one-time cost of training, it is paid again on every query for the life of the deployment. So we measured what the stop decision saves, holding accuracy constant, because saving computation only counts if the answers stay right.

Read down that chart and you can see the mechanism behaving exactly as it should. On easy problems the model uses a fraction of the computation, because easy problems do not need much thought. On the hardest problems the saving shrinks to almost nothing, and that is not a weakness, it is the point: hard problems genuinely require the effort, so the model spends it. The savings come from not wasting effort where none is needed, never from cutting corners where it is.

We also confirmed the saving survives contact with realistic serving conditions, where models process many requests at once and adaptive methods have historically lost their advantage. In batched serving, the adaptive exit ran about 1.5 times faster end to end than forcing full effort.

04

Smaller, cheaper, and still ahead

The claim that a smaller model can beat a larger one is easy to make and easy to fake, so we tested it the only way that means anything. Both models were built from the same components, trained on exactly the same problems with the same procedure, and we deliberately handicapped ourselves: the conventional fixed-effort model got 2.3 times more parameters and roughly four times more computation per step. By every assumption the industry runs on, it should have won comfortably. Then we tested both on problems harder than either had ever seen.

The smaller model came out ahead, and the revealing detail is where the gap opened. On the easier of the two unseen difficulties, the race was close. On the harder one, the large conventional model began to break down: it stopped reasoning and started defaulting toward a guess, the way a struggling student falls back on one. Our model kept working, and held close to three times the accuracy. The advantage is largest precisely where the most actual reasoning is demanded, which is the opposite of what you would expect if the smaller model were merely lucky.

We repeated the entire comparison from scratch three times, each from a different random beginning. Our model won all three, at both difficulties. We hold ourselves to eight repetitions before calling a number a hard claim, so we state this one plainly as what it is: a three-run result, consistent in direction every time, not yet at our own bar for a hard claim.

05

Against the best published method, on equal terms

It is easy to look good against a weak baseline, so from the start we tested against the strongest published method for adaptive thinking, PonderNet, a well-regarded and widely cited approach, under identical conditions: same task, same training, same everything except the mechanism. Because a single run can flatter either side, we ran the whole comparison eight times each.

Our approach reached essentially perfect accuracy on problems twice as long as its training, and it did so on every one of the eight runs. The published method averaged 0.977, but the average hides the story: some runs did beautifully and others stumbled, in both accuracy and cost, while spending about ten percent more computation overall. Ours reached the top score and stayed there, run after run.

In a research demo you can show your best run. In anything real, you cannot. A method that usually works but occasionally falls apart is not something you can build on, because you never know which kind of run you are going to get. We treat consistency as seriously as the headline number, and we report across runs rather than showing a favorite.

06

The surprise: stopping well is not just cheaper, it is load-bearing

We expected the stop decision to save money. We did not expect it to be responsible for correctness. On our harder testbed we ran a simple control: take the trained model and force every input to maximum thinking depth, the conventional way. Accuracy did not dip. It collapsed, from 0.989 to 0.168.

That number changed how we talk about the architecture. The model deciding when it is done is not an efficiency accessory bolted onto a reasoner. It is part of how the reasoning stays correct: thinking past the point where the answer is settled actively corrupts it, the way second-guessing a finished calculation introduces errors rather than removing them. Adaptive depth is doing real work, and the control proves it.

07

It holds when we change things

A result that only appears under one setting is a curiosity, not a finding, so we varied everything we could afford to. First, size: we built the model at four widths spanning a 2.7-fold range, and measured the efficiency edge at each. It does not erode as the model grows.

Then, the task itself. The behavior appears on three problem families that share nothing except needing several steps in a row: arithmetic chains, matching brackets by depth, and counting. On all three, effort rises with difficulty. And a single model trained jointly on arithmetic and on transitive logic, the "Alice is taller than Bob" kind, learned both at once, resolving the relationships before answering rather than pattern-matching the words.

One honesty note belongs here. Training is reliable, but on the hardest configurations a run occasionally fails early and is simply restarted; with that procedure, eight of eight runs reach 0.999 or better on problems twice their training length. We could hide the restarts and the sentence would read better. We would rather you know the procedure.

08

A 19.5M model against one fifty times its size

We also ran our small model head to head against a strong open model of a billion parameters, roughly fifty times larger, on our internal reasoning benchmark. We publish the losses with the wins, because the losses are just as informative.

Exact-match scoring. The two models were evaluated on different question counts per section in this run, 60 for ours and 30 for the open model; the rankings are unaffected, and a matched re-run is queued before we treat any single figure here as final.

The pattern is exactly what an honest reader should expect. On multi-step reasoning, the small model wins large, at a fiftieth the size and more than twice the speed, and it is perfectly consistent, giving the same answer to the same question every time. On language comprehension and world knowledge it loses outright, because it was never given the broad text data those require. That is a data gap, not a mystery, and closing it at scale is precisely the work in front of us.

09

Why the perfect scores are real, and why they are not the point

Several numbers on this page are 1.000, which should make any careful reader suspicious. It made us suspicious. Perfect scores are reachable here because these are controlled, deterministic tasks with a clean ceiling: every problem has one exactly checkable answer, correctness is scored against a computed ground truth rather than resemblance, and effort is reported separately from accuracy, so thinking longer is never mistaken for thinking correctly.

A task you can saturate is also a task that eventually stops teaching you anything, and we hit that wall ourselves. So we built a substantially harder version, hard enough that a strong baseline scores 0.927 on familiar difficulty and only 0.357 beyond it. On that testbed, our current architecture reaches 0.991 and 0.897, confirmed on rented cloud hardware. Rerun eight times from different random beginnings, the beyond-training figure averages 0.919 with a standard deviation of 0.037, which means the published 0.897 sits on the conservative side of its own spread. We would rather publish the careful number than the flattering one.

10

Why thinking longer works at all

Partway through this work we stopped and asked the question a skeptic would ask: why should thinking longer generalize? A model that extends its reasoning to twenty steps when it trained on eight is doing something most architectures simply cannot, and we wanted the reason on paper, not in our intuitions. So we built a stripped-down study to find out.

The answer turned out to be clean enough to state as a law. When reasoning is built as one reliable step applied again and again, the accuracy of a whole chain follows the reliability of the single step, multiplied out across the depth. A step that is right 99.9% of the time composes into long chains that stay right. A step that is right only 80% of the time decays fast: by sixteen steps, chains succeed less than one time in ten. We measured that decay curve directly and it fits the multiplication rule almost exactly, across different kinds of steps. The law holds when the step's errors are independent of each other, which a well-trained step satisfies, and our architecture is engineered to keep its per-step reliability near one, which is why the depth penalty stops biting.

The same study produced the control that convinces us the loop is the point. We trained four variants on identical data: every combination of two input formats with two designs, one that predicts the answer in a single pass and one that applies a learned step repeatedly. Both single-pass variants scored about 0.10 beyond their training range no matter how the input was formatted. Both repeated-step variants scored 1.00. Reasoning as repetition of a reliable step is what generalizes; a better-formatted input does not. This study was run on deliberately simple material, and we state it as an explanation of the design, not as a scale result.

11

First contact with real language

Everything above is measured on synthetic reasoning tasks, where ground truth is exact and nothing can hide. The obvious question is whether any of it survives contact with real text. We have taken the first, careful step.

Trained on children's stories, the model settled into roughly two thinking rounds per word at the same prediction quality as a fixed-effort twin, saving about three quarters of the computation, with genuine variation from word to word. Then we made the text harder on purpose: we embedded three-digit arithmetic inside ordinary prose, so that one word in each passage, the answer, is genuinely difficult and the words around it are not. The model spent 1.44 times more thinking on the answer word than on the narration around it, clearing the bar we had written down before the run.

Two honest boundaries. The corpus with embedded arithmetic is constructed, built to isolate the effect, so this is proof of mechanism, not a claim about arbitrary text. And allocating effort toward the hard word is not the same as getting it right: at this tiny scale the model's actual arithmetic on those sums, checked against a calculator, was poor, and we say so. Where the effort goes and whether the answer is correct are separate properties, and we measure them separately, because collapsing them is how a field fools itself.

12

What is not proven

The results on this page are on synthetic and small-scale tasks, trained mostly on a single consumer graphics card, with the confirmations on modest rented cloud hardware. They demonstrate that the mechanism works, that it survives changes of size and task, and that a disciplined search finds real headroom. They do not demonstrate that the advantage transfers to real language at a hundred million parameters and beyond. That transfer is the central open question of this work, and we treat it as the honest core of the bet rather than a footnote.

The decisive experiment is already designed, and it is deliberately cheap: our architecture against a fixed-effort baseline of the same size, on the same real reasoning data, with the pass-or-fail bar written down before the run, for single-digit dollars of rented compute. If the result is negative, it retires the bet early and gets published exactly like everything above. That discipline, not any single number, is the asset.

13

How to check us

Every number on this page is a measured result against a named baseline, or it is marked as not yet proven. Failures, retractions, and corrections stay on our record permanently; two earlier headline figures were withdrawn by us after we found our own harness, not the architecture, had produced them, and finding them ourselves is the standard we intend to keep. The mechanism, how the model decides its depth, is not published and will not be. Under a signed agreement we provide the evidence and the reproduction, so a reviewer confirms the result on their own hardware rather than taking ours on faith. If you want to verify rather than believe, write to us.

@misc{ArchResearch2026ThinkingLonger,
  author = {{Arch Research}},
  title  = {A Small AI That Solves Problems It Was Never Trained On, by Thinking Longer},
  year   = {2026},
  month  = jul,
  url    = {https://arch-research.dev/ThinkingLonger}
}