The history of digital technology is a history of virtualization — the progressive separation of function from substrate. We virtualized servers first: a workload that once required a specific physical machine could run anywhere, on any hardware, because the abstraction layer absorbed the differences. Then we virtualized work: an office was a substrate, and remote work proved the function could survive without it. Then social life, then memory, then identity itself — each time the same move, separating what the system does from where it physically happens, and each time gaining flexibility while reducing cost. But there is one layer where the pattern breaks, and it is the layer that operates all the others.
What virtualization actually does
Virtualization is not magic. It is abstraction — the insertion of a layer between function and substrate that makes the function portable. A virtual machine doesn’t need a specific server; a remote worker doesn’t need a specific building; a digital identity doesn’t need a physical body. In each case, the move works because the substrate was never the point. The server was a means to compute; the office was a means to coordinate; the body, in the context of identity verification, was a means to recognize. When the function can be separated from its carrier, the carrier becomes interchangeable, and the system gains freedom. This is why virtualization has been so powerful: it converts physical constraints into software problems, and software problems are cheaper to solve than physical ones — they iterate faster, scale more easily, and don’t bill you in materials. But what happens when the substrate is the function?
The layer that won’t abstract
The human body is the one layer in the stack where abstraction fails, because the body is not hosting the interface — it is the interface. You can virtualize the server that runs the model, the network that delivers the output, the platform that hosts the conversation; but you cannot virtualize the nervous system that processes the result, the metabolic engine that funds the processing, or the attention apparatus that decides what matters. These are not functions sitting on top of a replaceable substrate. They are the substrate itself doing the work, and there is no abstraction layer between them.
The biological algorithm — DNA encoding, metabolism allocating, homeostasis regulating — does not run on hardware it can be separated from. It runs on the body, as the body, and the body bills in the only currency it has: calories, sleep, cortisol, recovery. The brain consumes roughly 20% of resting energy while being 2% of body mass — a finite compute budget that no software optimization can expand, because the constraint is not algorithmic but metabolic. You cannot upgrade the hardware without changing the organism. This is why fatigue, attention loss, and cognitive degradation are not bugs in a virtualized system. They are the interface cost — the cost of running everything through a substrate that cannot be abstracted away.
The unvirtualized interface
The body is the unvirtualized interface: the last layer in the stack where the function cannot be separated from the physical conditions that produce it. Every layer above it can be virtualized, abstracted, distributed, and scaled — and increasingly is. But the layer that uses all of those systems, the layer where judgment happens, where decisions are made, where meaning is registered, remains stubbornly physical, biological, and non-negotiable.
This creates a structural asymmetry that the digital era has been quietly ignoring. The stack keeps moving upward — more abstraction, more layers, more virtualization — but the base layer still bills the cost in the same currency it always has. A remote worker can be anywhere, but their prefrontal cortex still needs sleep; an AI tool can generate at scale, but the person evaluating its output still pays full metabolic price for integration; a digital identity can be frictionless, but the nervous system that holds it still responds to stress, isolation, and overload the way it evolved to — slowly, chemically, and without regard for the abstraction layers above it. The agency-as-biological-condition framing applies here directly: agency requires nervous system function, metabolic stability, cognitive clarity, and enough physiological margin to sustain deliberate thought over reflexive response. None of those requirements have been virtualized. None of them can be.
Why the stack keeps moving upward
The economic incentive is clear. Virtualization is profitable because it reduces unit cost, and every layer that can be abstracted will be. The same objective-function misalignment I explored in From DNA to GDP — where the economy optimizes for measurable activity regardless of biological cost — operates here too. The system virtualizes everything it can because virtualization scales, and what it cannot virtualize it treats as an externality. Fatigue becomes a productivity problem; attention loss becomes a wellness problem; cognitive degradation becomes a healthcare problem. But these are not problems to be solved at a higher layer. They are the cost of running a non-virtualizable interface inside a system that has virtualized everything else.
Can the stack keep moving upward indefinitely while the base layer bills in a currency the upper layers don’t recognize? At some point, the interface cost exceeds the abstraction savings — not because the software fails, but because the organism that runs it degrades past the point where better tools compensate. The question is not whether we can build better tools for tired people. We can, and we are. The question is whether those tools respect the base layer or merely push more demand through it while pretending the cost doesn’t exist.
What this makes visible
Framing the body as the unvirtualized interface does something useful: it explains why wearables, remote work, AI tools, and embodiment all turn out to be the same problem at different scales. They are all attempts to mediate the relationship between a virtualizing stack and a non-virtualizable base. Some of them succeed by respecting the base layer — measuring it, protecting it, feeding it back to itself, the way a reinforcement mirror could reflect physiological states back to the person, as I explored in What If Your Best Self Became Visible?. Others fail by pretending the base layer doesn’t exist — treating attention as infinite, recovery as optional, and fatigue as a bug in the user rather than a bill from the substrate.
I am not sure the stack can virtualize its way past this constraint. But naming it — treating the body not as a limitation to be overcome but as the interface that cannot be abstracted — might be the first step toward building systems that respect the cost they have been ignoring.
Stack Takeaway
- Digital systems can virtualize work, memory, communication, and identity, but they cannot virtualize the biological conditions required to use them. The body is the unvirtualized interface — the last layer where the function cannot be separated from the substrate.
- The stack keeps moving upward through abstraction, but the base layer still bills in calories, sleep, cortisol, and recovery — a cost the upper layers don’t recognize because they don’t measure in that currency.
- Wearables, remote work, AI tools, and embodiment are all the same problem at different scales: mediating between a virtualizing stack and a non-virtualizable base. Systems that respect the base layer succeed; systems that pretend it doesn’t exist degrade the very agency they depend on.