Can a weaker AI think better if code, tools, and structure carry the heavy lifting instead of its own text?

This explores whether a weaker model does better when the heavy lifting (long procedures, shaky intermediate steps, sprawling context) is moved into external structure like code, tools, or routing, treating "cognitive load" as a metaphor for what the model has to carry in text. The corpus says yes, and it adds a twist: much of what looks like weak reasoning is a failure to execute or to carry a load, not a failure to understand. A model confined to writing out text can't reliably run a long multi-step procedure even when it knows the algorithm, and tool-enabled models solve problems past the supposed reasoning cliff (Are reasoning model collapses really failures of reasoning?).

The most direct demonstration is a stronger model building an inference-time harness for a weaker one. On Theory-of-Mind benchmarks this nearly doubled the weaker model's performance with no retraining. The gain came mainly from moving unstable reasoning into deterministic code and routing each task to a suitable path, not from encouraging longer thinking (Can a stronger model lift a weaker one at test time without retraining?). So structure can carry capability from one model to another. The weak model isn't reasoning better in its own head. It is doing less of the fragile part there.

The load can also be reduced by shrinking what the model must hold. Reasoning accuracy falls from 92% to 68% with only 3,000 tokens of padding, far below the context limit, and chain-of-thought prompting doesn't fix it (Does reasoning ability actually degrade with longer inputs?). Meanwhile, most of a reasoning trace turns out to be dead weight. Keeping just the instruction prefix and a recent window gives a 3x speedup, and traces can run past 100k tokens (Can models think longer by forgetting intermediate reasoning?). Models rank their own tokens by function, keeping symbolic computation and dropping grammar and meta-discourse first, and student models trained on those pruned chains beat ones trained on frontier-model compression (Which tokens in reasoning chains actually matter most?). A single steering vector can cut chain-of-thought length by 67% with accuracy intact (Can we steer reasoning toward brevity without retraining?). Much of the verbal scaffolding is load, not work. Deciding when to think at all is itself learnable structure (Can models learn when to think versus respond quickly?).

There are two limits. First, structure doesn't help if the problem is simply unfamiliar. Failures track instance-level novelty, not complexity, so a model fits patterns from similar instances and doesn't learn a general algorithm (Do language models fail at reasoning due to complexity or novelty?). A scaffold can take over execution, but it can't give the model an understanding it never picked up. Second, apparent gains need checking: twelve of fourteen models got worse when constraints were removed, which shows they were defaulting to the cautious answer and not reasoning about the constraints (Are models actually reasoning about constraints or just defaulting conservatively?). A harness that makes a weak model's answers look right may be exploiting the same kind of shortcut.

The surprise underneath all of this is that visible reasoning may not be where the reasoning happens. Latent-reasoning architectures scale test-time compute through hidden-state iteration with no verbalized steps (Can models reason without generating visible thinking tokens?). Models trained on filler tokens compute the right answer in layers 1-3, then overwrite it to produce the required format (Do transformers hide reasoning before producing filler tokens?). If so, freeing a weak model from load doesn't mean handing its thinking to scaffolding. It means clearing the text-generation bottleneck so the computation that already works can show up.