Reorganizing what an AI reasons over — not making it smarter — can let a weaker model match a stronger one.

This explores whether a weaker planning model can close the gap with a stronger one just by changing the structure it plans over, rather than by scaling up the model itself. The corpus gives a surprisingly direct 'yes' — with conditions. The clearest case reorganizes a coding harness around what code actually *does* at runtime instead of where it lives: a behavior-to-code map let weaker planners match stronger models on code localization across every precision and recall metric, while also cutting planner tokens by 8–13% Can explicit behavior maps help weaker planners compete with stronger models?. The lever isn't intelligence, it's representation — hand the weak planner a map that already encodes the hard-to-infer relationships, and it stops needing the raw reasoning horsepower to reconstruct them.

The same pattern shows up when you move the structure out of the harness and into the training data or the task decomposition. Embedding 'lookahead' tokens that carry future information lets an ordinary model plan better with no architectural change at all Can embedding future information in training data improve planning?, and splitting the decomposer (the planner) from the solver turns out to matter because decomposition *transfers across domains while solving doesn't* — the planning skill is separable and portable in a way raw problem-solving isn't Does separating planning from execution improve reasoning accuracy?. Reorganizing exploration itself works too: forcing a model to plan over diverse abstractions rather than deep single chains beats simply sampling more solutions at large compute budgets Can abstractions guide exploration better than depth alone?. Across all of these, the win comes from restructuring what the planner operates on, not from a bigger brain.

But there's a sharp boundary, and it's the most useful thing here. Weak models matching strong ones is not free — a committee of weak model calls only catches up when there's an external *soundness signal* (tests, proofs, type checks) to select the correct proposal from the noise; sampling alone amplifies coverage but can't pick the winner When can weak models match strong model performance?. Reorganizing behavior into a verifiable map is one way of smuggling in exactly that kind of external anchor. This connects to a deeper finding that pure self-improvement is circular and every reliable gain sneaks in an outside signal — a judge, a past checkpoint, tool feedback Can models reliably improve themselves without external feedback?.

The twist you might not expect: reorganizing the harness doesn't help *every* model equally. The ability to write useful harness edits is flat across model tiers, but the ability to *benefit* from them follows an inverted-U, peaking at mid-tier models — weak models fail to even invoke the scaffold, and very strong models stumble on faithfully following it Do stronger models always evolve harnesses better?. So 'weaker planner + better structure = stronger model' has a sweet spot; go too weak and the model can't use the reorganization at all. This sits inside a broader map of self-improving agents as a slow weight-updating loop plus a fast scaffold-updating loop, where most recent progress lives in the cheap, reversible fast loop precisely because reorganizing behavior is so much cheaper than retraining Do self-improving agents really split into two distinct loops?.

The takeaway a curious reader leaves with: a lot of what looks like 'the bigger model is smarter' is actually the bigger model reconstructing structure on the fly that a smaller model could be simply *handed*. Externalize that structure — as a behavior map, a decomposition, a verifiable check — and the capability gap partly dissolves, up to the point where the small model is too weak to read the map at all.