Remember when every AI announcement came with a parameter count attached, like a horsepower figure on a muscle car? Bigger number, better model, end of discussion. Labs raced to publish increasingly absurd figures, and the rest of us nodded along because the scaling curves looked so clean. Parameter count became a proxy for intelligence, and for a few years that proxy held up well enough that nobody wanted to question it.
That era is closing, and not because scaling stopped working. It’s closing because the assumptions built on top of scaling turned out to be shakier than expected, and because the practical work of deploying agents has started pulling in the opposite direction.
Two signals pointing the same way
Two recent stories sit next to each other in a way that deserves attention. MIT Technology Review reported that AI’s recursive self-improvement might not come so quickly after all. Meanwhile, the Australian Financial Review covered Australia leading a rise of the small language model.
On the surface these are unrelated. One is about the ceiling of AI capability, the other about a regional trend in model sizing. But read them together and a pattern shows up. The recursive self-improvement thesis, the idea that a sufficiently capable model bootstraps itself into something far more capable, was always the strongest argument for pouring everything into scale. If the takeoff is coming, you want to be holding the biggest model when it arrives. Weaken that thesis and the calculus changes. Scale stops being a bet on a discontinuity and becomes an ordinary engineering tradeoff, measured against latency, cost, memory, and control.
Small models look very different under that framing. They stop being the compromise you accept when you can’t afford the good stuff and start being a legitimate design choice.
Why agent architecture pushes small
This is where my own work keeps landing. If you build agent systems, you learn quickly that a single enormous model handling every step is an awkward fit for the problem. Agents do a lot of small, repetitive, structurally simple things. They classify. They route. They extract fields. They decide whether a tool call is needed. They check whether output matches a schema. None of that requires the kind of reasoning depth that justifies a frontier model, but all of it sits on the critical path, which means every call pays the full latency and cost penalty.
An agent loop that makes forty model calls to complete one task has a fundamentally different cost structure than a chatbot answering one question. Multiply a small per-call inefficiency by forty and it stops being small. This is why the interesting architectural work right now is about composition rather than capability. Route the easy steps to something fast and cheap, reserve the expensive model for the genuinely hard reasoning, and treat model selection as a scheduling problem.
Small models also give you something large hosted models mostly can’t: they run where your data already lives. A model small enough to sit on a laptop, a phone, or a modest server changes what’s architecturally possible. No network round trip. No inference bill that scales linearly with usage. No dependency on someone else’s uptime.
The hardware is quietly cooperating
Look at the AppleInsider reporting on 2027 iPhone 18 rumors: 12GB or 9GB of RAM, a 2nm A20 chip. Treat those numbers as rumors, because that’s what they are. But the direction is unambiguous. Phone RAM is climbing, and process nodes keep shrinking. RAM is the binding constraint on local inference. A device with that much memory has real room for a capable local model.
Consider that consumer hardware is being specced for on-device inference several years out, and the small model trend looks less like a cost-saving detour and more like the industry positioning itself for a world where a large share of inference happens at the edge.
Geography is part of this too
Rest of World’s reporting on Americans choosing Chinese AI points at something related. Model provenance is becoming a factor in adoption decisions, which means where a model runs and who controls it are now product questions, not just compliance footnotes. Small models that run locally sidestep a lot of that. And the AFR piece on Australia’s small language model push suggests that regions without hyperscale compute budgets aren’t sitting out the AI buildout. They’re competing on a different axis, one where efficiency and specialization matter more than raw scale.
What this means for builders
If you’re designing agent systems, the practical takeaway is to stop treating model choice as a one-time decision. Assume a heterogeneous fleet. Build routing logic. Measure per-step cost, not just end-to-end quality. Instrument which steps actually need deep reasoning, because in most systems the answer is fewer than you’d guess.
The scale-worship era gave us a lot: it proved the capability existed. The next phase is about spending that capability carefully. Small models aren’t a downgrade. They’re what happens when the field starts optimizing for something other than a leaderboard.
đź•’ Published: