There’s probably at least one computer in your house that you’ve written off. Maybe it’s in a drawer, or on a shelf, or under a pile of boxes you keep meaning to sort out.
In October 2025 Microsoft ended support for Windows 10. Overnight, an enormous number of working machines that didn’t meet Windows 11’s hardware requirements were simply declared obsolete. The same applies for ageing Mac hardware too, with pre-2017 devices now considered end-of-life. Nothing about those machines has physically changed - just that label.
Of course your computer keeps getting older as time passes. But now in one very specific sense, it’s also getting younger.
Every piece of hardware has two ages. Its manufacturing vintage is when it was built. Its cognitive vintage is the class of cognitive work it can actually do. And for most of computing history the machine’s usefulness just declined steadily over time. But these two things have started moving in opposite directions.
A machine can get physically older while it gets cognitively younger.
That’s the core idea I’m presenting in this post. And once you really absorb how this is working then the installed base of hardware stops looking like a pile of depreciating devices. Instead, it’s now more like a reservoir.
Moore’s Law, running in reverse
Under Moore’s Law, compute was the key variable. Every year or two a new generation of hardware arrived that could do more. If you wanted more capability, you bought new hardware. While the machine you already owned stayed locked in to exactly the capability it had the day you bought it.
But in practice it actually became less useful over time, thanks to Wirth’s Law: software gets slower, faster than hardware gets faster. Old machines didn’t become useless because they aged. They actually became useless because the software around them kept demanding more.
Right now we’re passing through a threshold where a new inverse Moore’s Law (iML) can take effect. This iML effect changes which variable moves. It holds the hardware constant, while the software stack improves increasing the useful cognition that a fixed machine can deliver.
iML: The minimum hardware required for
a fixed level of cognition falls over time.
These improvements come from everywhere. Models are becoming more capable per parameter. Weights are being compressed into low-bit and ternary forms. Runtimes, kernels and memory layouts keep getting better. KV-cache compression and prompt caching cut the cost of holding state, and speculative decoding cuts the cost of generating. Tools move work out of the model entirely, and harnesses increasingly make a fixed model far more capable as a system.
But you can’t just multiply all these gains together, because they attack different bottlenecks. What’s important is that each one can push a workload across a practical threshold. A machine that’s too weak today can become an overnight worker next month, an asynchronous agent soon after, an interactive agent after that, and finally possibly even abundant cognition. While the machine itself never changes.
Cognition-focused optimisation is making Wirth’s Law run backwards. This isn’t about trimming the interface and feature bloat that drove Wirth’s Law in the first place. It’s the core cognitive software itself becoming less demanding for a specific level of cognition, making ageing hardware more capable.
The consequence is simple, and I think currently underappreciated:
The world’s existing installed base of hardware
can deliver an ever-growing amount of useful cognition.
And no one has to buy anything new for that to happen.
Why this has been easy to miss
Most serious analysis of algorithmic progress looks forward, at the frontier. Epoch’s work on this is a great example. Their Shapley-value analysis suggests that 60–95% of performance gains have come from more compute and training data, and only 5–40% from new algorithms. At the frontier, algorithmic efficiency plays a supporting role.
But turn the question around. Instead of asking what pushes the vanguard forward, ask what happens behind it.
At the rearguard, compute is fixed by definition. The hardware is whatever is already sitting there. So algorithmic and software gains aren’t a minority contributor. They’re the whole story.
At the frontier, algorithms are a minority contributor.
At the rearguard, they’re the only contributor.
The rearguard isn’t a model category. It isn’t simply “small models” or “open models” or “local models”. It’s the capability that has crossed three practical thresholds on some cohort of hardware:
Intelligence. The model is good enough to do a useful class of work.
Viability. The hardware can run it cheaply and quickly enough for the use case.
Reliability. The surrounding system can verify, constrain, retry or escalate well enough to make the work dependable.
The frontier is the best capability available at any given moment. The rearguard is a boundary moving backwards through the installed hardware base. As it passes each cohort of machines, it pulls them into a younger cognitive vintage.
That’s the Benjamin Button effect that’s now in play.
Why now, and why a staircase not a slope
The progression isn’t smooth, and that’s important.
Speed is a good example. One token per second is hopeless for a conversation, but it’s perfectly adequate for an overnight batch worker. There are distinct regimes here: too slow to matter, overnight batch, asynchronous agent, background automation, interactive agent, conversational agent. Crossing from one regime to the next matters far more than small improvements within a regime.
Memory works the same way, only more sharply. Consumer hardware comes in tiers: 4GB, 8GB, 16GB, 32GB. When a capable model plus its runtime finally fits inside a tier, every device in that tier crosses the threshold at once. That doesn’t show up as a gradual trickle of new capacity. It shows up as a step.
We’ve just hit one of these first big steps. PrismML’s Bonsai 2 puts full 27B-class reasoning into ternary weights at 5.9 GB, running on a computer or a single GPU, and reports retaining 98.2% of FP16 intelligence at roughly a ninth of the size. It also supports native tool calling and long context. Those are the vendor’s own figures and independent evaluation will matter. But if they hold up, a 27B-class agentic model now fits inside the 16-32GB tier (including room for longer context, OS overhead, etc.). That’s a lot of machines!
This is why I think of the iML effect as a staircase of S-curves. One bottleneck falls, a cohort crosses a threshold, and then the next bottleneck becomes visible.
The rearguard also won’t move uniformly. Text, speech, vision and video each have their own requirements. So the same computer might be frontier-adjacent for speech, rearguard for text, and hopeless for video generation, all at the same time.
Removing the meter
In the dark distant days of the dial-up internet people religiously watched the clock. Every minute online cost money, so they’d connect, grab what they needed, and hang up. Then came download caps, and the monthly ritual of checking how many gigabytes they had left - many people are like this with mobile data and minutes today. Every click carried a tiny calculation: is this worth it?
Then flat-rate, effectively all-you-can-eat broadband arrived, and something bigger than a price cut happened. The calculation disappeared. People stopped going online and simply were online. Streaming, cloud backups, always-on devices, software that updated itself overnight. None of it was designed for a world where every byte was counted. The internet stopped being something you bought and became something you assumed. It became internalised.
Cognition is at the dial-up stage right now. Epoch’s latest analysis shows the cost of a given level of AI performance falling about 47% per quarter, or roughly 13× per year, faster than any other transformative technology in history. Their headline example is a PhD-level science question that cost 30 cents to answer in early 2025 and, less than 18 months later, for just four hundredths of a cent.
That’s an extraordinary fall. But it’s still a meter. Someone still has to hold an account, approve a budget, work within rate limits, and at some level decide each task is worth paying for. Metered things get rationed, however cheap they are. And token-bill-shock is a very real thing for many people today.
But cognition running on hardware you already own has no meter. Its marginal cost is effectively zero, and the gap between $0.0004 and zero isn’t small. In ratio terms it’s close to infinite. But even more importantly, it’s the gap between should I? and simply doing it.
Remove the meter and a whole category of work appears that no one would ever pay for, however cheap. Speculative exploration, always-on monitoring, background agents working on problems just in case. And once the meter is gone, four other properties matter at least as much as price:
Persistence. An agent can run indefinitely without accumulating a bill.
Privacy. The data never leaves the building.
Control. No one else can deprecate the model, reprice it, or quietly change its behaviour.
Freedom. The capability can’t be switched off by someone else’s policy decision.
This is submarine cognition: cognition running below the metered cloud surface.
The obvious objection is that owned hardware isn’t really free. Laptops sleep, run on battery, get used by their owners, and computers in general are a pain to manage as a fleet.
That’s true for the computer you’re using right now. But a huge and growing number of devices aren’t being used at all. They’re sitting idle, or literally on shelves, written off as redundant. Many are ideal candidates for a lean headless Linux install, which leaves more memory for the model and runs local inference tools like llama.cpp well.
Managing a fleet of mismatched machines is also exactly the kind of repeatable, verifiable task agents are good at. So the rearguard’s first job can be looking after itself.
Then add energy. For a growing number of households and businesses, daytime electricity comes from rooftop solar and home batteries. So near-zero marginal cost isn’t just a theoretical limit. For a lot of hardware, for a lot of hours in the day, it’s simply the situation. And because so much rearguard work is batch or asynchronous, it can follow the sun.
But none of this makes the cloud irrelevant. Utility cognition is the same broad class of good-enough cognition delivered elastically by cloud providers: cheap bursts, massive parallel search, overflow when local capacity is saturated. If submarine cognition is behind the meter, utility cognition comes from the grid, and the two complement each other. Even a tiny cloud escalation rate, multiplied across an enormous volume of local work, could generate more cloud demand than all of today’s human-initiated usage. I’ll be posting more about these points soon.
Where the work actually goes
Once cognition exists in all these forms, no sensible system uses one model for everything. It routes each task to the cheapest (or best by some other measure) resource that can complete it reliably within the deadline.
That creates a merit order, much like the one used to dispatch electricity generators. At the bottom is plain deterministic code. Above that come tiny reflex models, then task-specific specialists, then general models on owned hardware, then utility cognition, then older frontier models, and finally the current frontier, which is reserved for the genuinely hard cases. The layer that makes these decisions, the cognitive control plane, starts to matter more than any single model.
The best analogy I’ve found is a just-in-time compiler - you may not think about it much but it makes your web browser sing:
The frontier model is the interpreter.
Workload traces are the profiler.
Distillation and fine-tuning are the compiler.
Specialist models are optimised machine code.
Verification is the test suite.
The control plane is the runtime scheduler.
Novel work starts in expensive general intelligence. Work that repeats becomes a hot path, and hot paths get compiled downward, into a specialist, sometimes into ordinary code. Future requests skip the expensive interpreter.
This gives you a second iML effect on top of the first:
The hardware needs less for a fixed level of cognition.
And the task needs less cognition over time.
The two reinforce each other. So the right metric isn’t dollars per million tokens. It’s cost per verified completed task at a fixed capability threshold. One expensive frontier call that helps compile a specialist, which then makes the same decision a million times, has effectively amortised itself away. Cognition stops being purely rented and starts being capitalised into the system.
The key word in that metric is verified. Cheap cognition is only useful if the system can tell when it’s wrong. Where cheap verification exists, like code with tests, schemas, calculations and reconciliations, an 80%-reliable model plus attempt, verify, retry and escalate becomes a dependable system. Where checking the work needs near-frontier judgement, the economics fall apart and that work stays higher up the stack. So the rearguard will spread first, and fastest, wherever verification is cheap.
Yesterday’s frontier becomes tomorrow’s infrastructure
We tend to measure AI progress at the frontier: the smartest model, the hardest benchmark, the newest capability. That’s where new possibilities appear, and it will keep mattering.
But the frontier only decides what’s possible. The rearguard decides what’s abundant. And the developing control plane decides where all of it flows.
One of the most consequential AI transitions facing us is not just the frontier getting dramatically smarter. It is now also yesterday’s intelligence becoming cheap, local, specialised, verifiable and truly abundant everywhere.
I think “who ends up using that capacity?” and “who captures the value it produces?” are the really interesting questions we need to think through very deeply.
In the meantime, go and take a look at that old computer. What is sitting on your shelf that might be getting younger every day? And how will you use your growing submarine cognition?