Two numbers, put side by side, tell a story that neither tells alone.
GLM-5.2 reportedly clears AIME 2026 at 99.2%, running roughly 40 billion active parameters per token. GPT-4, at a rumored 280 billion active parameters in 2023, could barely solve an AIME problem at all.
The natural reading is a triumph: reportedly around seven times fewer active parameters, and the newer model crushes a contest the older one flunked. Efficiency compounding into intelligence. A magic trick where the rabbit gets bigger as the hat gets smaller.
But watch a small knowledge-light model when you ask it something else. Request from the 9B model the birth year of a minor 19th-century mathematician, and you get a confident, plausible, wrong answer. The trick has a false bottom.
This week the lens turns to the machine, and to a symmetrical failure: not a mind that has stopped understanding, but one engineered never to know.
Because the parameter count did not drop for free. It dropped because labs are trading world knowledge for reasoning skill, and the trade is deliberate.
The economics are clean. Research on knowledge capacity puts factual storage at roughly two bits per parameter, which means that knowing the birth year of every minor Wikipedia figure, the population of every Dutch municipality, and the argument order of every npm function costs you weights — a lot of them.
Reasoning, by contrast, compresses beautifully. It is a small set of procedures applied over and over: break the problem into parts, track intermediate state, check your work, backtrack when a step fails. Distillation reportedly transfers those procedures into small models fairly well, though some research finds it captures behavioral length while failing to replicate logical efficacy due to intrinsic capacity limits.
So the frontier splits in two. Phi-4, reportedly at 14 billion parameters trained on synthetic textbook data, is good at math and bad at trivia — which used to look like a limitation and now looks like the design goal.
There is a genuine argument for this. Facts rot; procedures don't. Algebra worked the same in 1970 as now, but half of what a 2024 model believed about the JavaScript ecosystem was stale before it shipped. A model that is mostly procedure ages gracefully.
And the knowledge that survives the cut has a useful shape. These models are generalists that know a little about nearly everything and almost nothing in depth — precisely the layer that lets a model understand what a question is about and know what to look up.
So far, so elegant. The problem is what happens to the facts that got evicted. They have to live somewhere, and the answer is that the harness carries them: retrieval, tool calls, web search, a filesystem full of docs, supplied at runtime.
A coding agent doesn't memorize your dependency's API surface; it greps node_modules or reads the docs before calling anything. The recall that used to be a fixed cost in every forward pass became an on-demand lookup. Grounded, current, cheap.
This is where the accounting starts to feel too tidy, because the harness only carries the facts. Someone still has to carry the judgment.
Consider what "trading knowledge for reasoning" actually produces at the small end. Artificial Analysis reportedly measures Qwen3.5's 4B and 9B models at hallucination rates of 80 to 82% on its knowledge benchmark.
Read that plainly: when these models don't know a fact — which is most of the time — they make one up. Not flag the gap, not decline, not hedge. They generate something confident, plausible, and wrong, in exactly the fluent register of everything else they say.
Even at the frontier, factual recall is dismal. On SimpleQA, a no-tools test of plain factual knowledge, the current leader is reportedly Gemini 2.5 Pro at 53 percent. The best recall money can buy misses half the questions.
The intended behavior, the designers will tell you, is that a knowledge-light model paired with a good harness should say "I don't know" and go look it up. That is the right behavior. It is not the default behavior.
The default, absent a harness that catches it, is fluent invention. And here is the quiet reallocation: a model that once had enough world knowledge to notice when its own reasoning contradicted a known fact may have shed that internal check. The check now lives outside the model.
A model that once had enough world knowledge to notice when its own reasoning contradicted a known fact may have shed that internal check. The check now lives outside the model.
Which means it lives with you.
This is where a second shift, happening in software, becomes the general case. For decades the bottleneck in programming was writing code — slow typing, tedious boilerplate. AI assistants shattered that. Generation is now the easy part.
But, as the developers putting this into words have noticed, now you have to understand the code. And understanding is much harder than generating.
The reason is structural, not incidental. Generation is synthesis: you take requirements and produce output, building a mental model as you go. Understanding is analysis: you take finished output and reverse-engineer the intent, the assumptions, the implications you were never shown.
The image that captures it, applied to AI-generated code: reconstructing someone else's reasoning from their output alone is reportedly "like trying to understand a conversation by reading only the responses." You get the fluent half. You have to supply the rest.
That is exactly the position a knowledge-light, fluent model puts you in. It hands you the responses — the confident answer, the clean derivation, the plausible birth year — and withholds the thing that would tell you whether any of it is true.
And analysis does not compress the way reasoning does. That is the crux of the whole paradigm.
The efficiency miracle worked because reasoning turned out to be a small, transferable set of procedures — distillable, shrinkable, cheap to run on a consumer GPU. Comprehension has no such structure. There is arguably no procedure for "understand whether this is true" that you can distill into a 14-billion-parameter head and ship.
Verification is domain-specific, effortful, and slow. It is the one input in the whole loop that refuses to scale. Arguably, you can make generation far cheaper and comprehension does not get meaningfully cheaper alongside it.
So the loads diverge. Generation falls; verification stays flat or rises, because now there is more fluent output to check and less internal knowledge inside the model checking itself.
The consequence overturns the promise. The pitch for these tools is democratization — anyone can now produce code, produce analysis, produce answers. But if the binding constraint moves to understanding, and understanding demands deep expertise, then the tools do not democratize. They "just change what kind of expertise is needed."
The beneficiary is not the beginner who can finally generate code without learning. It is the expert who can, per that same account, already produce code faster while still being able to evaluate it critically. Cheap generation raises the bar for safe use; it does not lower it.
None of this is an argument against the trade. Decoupling the expensive, slow artifact from the fast-changing truth of the world is a real advance, and the harness pattern is genuinely elegant.
It is an argument about where the bill lands. The parameters that got evicted held more than facts. They held the model's ability to check itself — and that duty did not evaporate. It moved.
It moved to the harness, for the part that is a lookup. And it moved to the reader, for the part that is judgment — the part that was never a lookup, that does not distill, that does not scale, and that the whole accelerating paradigm cannot manufacture.
Understanding is the one resource nobody is optimizing to the benchmark, because there is no benchmark for it that a human doesn't have to sit down and pass, one output at a time.