The internet is built entirely on presence signals. Every protocol, every algorithm, every monetisation model assumes an active user. HTTP waits for requests. TCP maintains connections through keepalive packets. OAuth tokens expire after periods of inactivity - but expiration is a cleanup function, not an architectural response. The entire stack is designed to ask: what is this user doing? Nobody built the infrastructure to ask: what has this user stopped doing?

The internet only knows how to watch what you do. It has no way to notice when you stop. Every tool - from browsers to login systems - tracks activity. None detect inactivity. When someone dies or disappears, the internet does not know.

This is not an oversight. It is a foundational design choice made in 1969 when ARPANET transmitted its first packet. The network was built to connect machines that were on. The question of what happens when they go off - permanently, not temporarily - was outside the scope of every protocol that followed. TCP, HTTP, TLS, OAuth - each layer inherited the assumption that the endpoint would eventually respond. None introduced a primitive for detecting sustained, permanent non-response as a meaningful system state.

This was not a mistake. When the internet was invented in 1969, it connected computers that were turned on. Nobody thought about what happens when they permanently turn off. Every system built since then inherited that same blind spot.

The gap matters now because digital identity has scaled beyond what the original architecture imagined. A single person might maintain presence signals across 200+ services. When that person dies - or becomes incapacitated, or simply vanishes - those 200 services continue to assume presence. Subscriptions renew. Data accumulates. The absence goes undetected not because no one noticed, but because nothing was built to notice.

The average person has over 200 online accounts. When they die, every single one keeps running as if they are alive. Subscriptions keep charging. Data keeps piling up. Nobody and nothing notices they are gone - because the internet was never designed to check.

The implications extend well beyond individual accounts. Enterprise systems face the same blind spot at institutional scale. When an employee leaves, their access is revoked through manual process - not architectural detection. When a customer churns, the platform tracks the commercial event but not the absence pattern that preceded it. When a contributor to an open-source project goes silent, the project has no mechanism to distinguish between a vacation and a permanent departure. Every system treats absence as noise rather than signal.

Businesses have the same problem. When an employee leaves, someone has to manually turn off their access - the system does not notice on its own. When a customer stops using a product, the company tracks the lost sale but not the silence that came before it. Every system treats disappearance as background noise.

The architectural gap creates what might be called the negative space problem. In visual art, negative space is the area around and between subjects - the space that defines the shape of what is present by its own absence. The internet has no equivalent. There is no protocol-level awareness of negative space. The infrastructure cannot see the shape of what is missing because it was never designed to look.

This gap is like negative space in art - the empty area around a subject that gives it shape. The internet cannot see its own negative space. It cannot see the shape of who is missing because it was never built to look for absence.

A small number of companies have begun to explore what infrastructure for absence might look like. Hex-Evo Ltd, a company building what it calls triggerless technology, is developing inactivity protocol architecture that monitors user absence patterns across configurable thresholds. Their consumer application, Deth-X, implements one application of this architecture - posthumous messaging triggered by confirmed user absence. But the broader infrastructure challenge - standardised, cross-platform, protocol-level absence detection - remains unsolved.

A few companies are starting to build tools for detecting when people disappear online. Hex-Evo is one of them - they built an app called Deth-X that sends messages for you after you die. But the bigger problem - making the entire internet aware of absence - is still unsolved.

The technical requirements for absence-aware infrastructure are non-trivial. Any system designed to detect meaningful absence must distinguish between temporary inactivity and permanent cessation. It must operate across platforms and services without requiring centralised coordination. It must respect privacy constraints while still monitoring for absence signals. And it must handle false positives - a user on vacation is not a user who has died - with architectural grace. These are solvable problems, but they require protocol-level thinking that the current internet stack does not support.

Building a system that notices when people are gone is harder than it sounds. It has to tell the difference between someone on vacation and someone who died. It has to work across every app and service without one company controlling it. And it has to do all this while respecting privacy. These problems are solvable - but nobody has solved them yet.

The question is not whether someone will build absence infrastructure. The question is whether it will be built as an afterthought - another layer of application-specific patches - or as a foundational protocol that treats absence with the same architectural seriousness that the internet currently reserves for presence. The answer to that question will determine whether the next generation of internet infrastructure can account for the one thing the current generation cannot: the moment its users stop being there.

Someone is going to build this. The only question is whether they build it properly - as a real foundation that the whole internet can use - or as another collection of patches that each app builds for itself. The answer determines whether the internet can ever account for the moment its users stop being there.