When automated exploits meet abandoned code, the real casualty isn’t corporate data — it’s thirty years of human history. Here is how sovereign AI maintainers can hold the line.

\u200bPreserving the digital commons: Shielding the irreplaceable legacy of Web 2.0 from modern machine-scale cyberattacks. Image by author using Gemini\u00a0(AI)

​Preserving the digital commons: Shielding the irreplaceable legacy of Web 2.0 from modern machine-scale cyberattacks. Image by author using Gemini (AI)

The Emergency Cord in the Engine Room

When a web server runs out of memory, it is supposed to die with dignity.

For thirty years, the foundational safety net of the PHP programming language has rested on a simple, brutal piece of C programming known as a non-local jump: setjmp and longjmp. Think of it as an emergency ejection seat for a web request. When someone visits a website running on PHP, the server records a clean recovery checkpoint at the start of the visit. If a script suddenly tries to use more memory than it is allowed, the core engine cannot politely ask the program to clean up after itself, because cleaning up might require even more memory. Instead, the engine pulls the ejection handle. It fires a longjmp, instantly rewinding the server back to that starting checkpoint, wiping the slate clean, and getting the worker process ready for the next visitor in line.

This mechanism was built in an era when the web was made of digital guestbooks and simple shopping carts, and for decades it worked well enough. Then came the twin disclosures of CVE-2026–109618 and CVE-2026–109619, widely known as “php2shell,” and the floor gave way beneath a massive portion of the living internet.

To understand why these two bugs caused such panic, you have to look at what happens in the fraction of a millisecond before a website even reads its own code. When a user uploads a photo or submits a form, the PHP interpreter has to unpack that data and organize it into internal lists before handing it over to the website’s actual application logic.

In the first vulnerability, CVE-2026–109618, an attacker sends a carefully oversized form upload designed to trip the server’s memory limit halfway through that unpacking process. The engine panics and pulls the longjmp emergency cord while its internal filing cabinets are only half-built. A memory address has been created and added to the cleanup list, but the server never finished writing down what actually lives at that address. When the automatic cleanup crew arrives a microsecond later to sweep away the failed request, it reads that unfinished note and treats whatever leftover garbage bytes happen to be sitting in memory as an official command.

Its companion bug, CVE-2026–109619, takes advantage of what happens next. Modern web servers rarely start a brand-new program for every single visitor, because doing so would be far too slow. Instead, systems like PHP-FPM, Apache, LiteSpeed, and FrankenPHP keep a pool of persistent worker processes alive, handing thousands of visitors one after another to the same worker. When a fatal timeout or memory bailout interrupts a worker at the exact wrong moment, the cleanup routine forgets to reset a few internal switches. Pointers to old, discarded memory stay wedged in the worker’s throat as the next visitor walks through the door.

Put the two flaws together, and an attacker does not need a stolen password, a vulnerable database query, or an outdated WordPress plugin. They simply send a burst of ordinary-looking web traffic that arranges the server’s memory in a specific pattern, trip the out-of-memory wire before the website’s own security code even wakes up, and hijack the core interpreter binary itself.

For a Silicon Valley tech giant running modern services in Go or Rust, this disclosure was an interesting weekend read on Hacker News. For the actual internet, where PHP still powers more than seventy percent of all websites whose server language is known, it was an existential threat.

The Age of the Agent Kiddie

Ten years ago, a bug like php2shell would have moved at a human pace.

Memory corruption bugs inside complex language engines are notoriously finicky to turn into working weapons. Every Linux distribution compiles PHP with slightly different settings. Every web host loads a different mix of add-ons for image processing, caching, or encryption, and every single add-on shifts the internal map of the server’s memory by a few crucial bytes. Back in 2016, turning a theoretical memory bug into a reliable break-in tool across ten thousand different servers required weeks of tedious reverse engineering by a handful of elite specialists. Against almost every other server on the internet, a generic attack script would guess the wrong memory address, crash the worker process harmlessly, and leave nothing behind but a single line in an error log. The sheer difficulty of the craft acted as a natural firebreak.

That firebreak is gone. We have left the era of the script kiddie and entered the era of the agent kiddie.

The economics of cyber offense broke open in late 2025, when Anthropic revealed it had disrupted the first large-scale cyber-espionage campaign run largely without human hands. A state-backed group tracked as GTG-1002 wired coding models directly into reconnaissance and hacking utilities using the Model Context Protocol, turning the system loose on roughly thirty target organizations. The AI handled up to ninety percent of the tactical legwork on its own, moving at a pace no human team could match. Whenever the model balked at an overtly malicious command, the operators broke the break-in down into tiny, innocent-looking chores: inspect this network header, calculate the byte length of this form boundary, check why this connection closed after four kilobytes, add sixteen bytes of padding, and run the test again.

What required a state intelligence agency in late 2025 is now a weekend script running on a consumer graphics card or five dollars of API credits.

The modern agent kiddie does not need to understand how C pointers work or how Linux manages server memory. They download an open-source agent framework, feed it the public text of the security advisory alongside the official code fix, and tell the model to figure out the memory layout for fifty thousand websites.

An autonomous hacking loop treats breaking into a server as a game of Battleship played at machine speed. It sends a harmless request to see how the server responds, deducing what operating system and extensions are running behind the curtain. It crafts a test payload, fires it, and measures how many milliseconds pass before the connection drops. If the worker crashes, the agent reads the timing difference, adjusts its internal map of the server’s memory, tweaks the padding by a few bytes, and fires again.

According to Stanford University’s 2025 AI Index, the cost of running queries on capable reasoning models dropped by more than two-hundred-and-eighty-fold in just eighteen months, falling from twenty dollars per million tokens to seven cents. Over the same period, research group METR found that the length of complex software tasks an AI can complete without losing the thread has been doubling roughly every four months.

When you combine seven-cent machine reasoning with relentless autonomous stamina, the financial barrier that used to protect obscure, low-value websites vanishes. It never made economic sense for a skilled human hacker to spend six hours custom-tuning a memory exploit just to break into a twenty-year-old forum for vintage motorcycle restorers or a small town’s historical archive. When an autonomous agent loop can custom-tailor that break-in in four minutes for two cents of electricity, every forgotten corner of the public internet becomes profitable to strip-mine.

The Moral Failure of “Fix Your Shit”

Whenever a crisis like php2shell hits the web, a familiar chorus rises from senior security analysts, cloud architects, and enterprise systems engineers. You can hear it at security conferences and read it across every technical comment section on the internet. It boils down to three words: fix your shit.

The argument is always delivered with the crisp, unsentimental certainty of people who work at companies with seven-figure engineering budgets. The patches for PHP 8.2 through 8.5 are already available, they point out. If you are still running PHP 7.4, or 5.6, or some dusty installation of phpBB or MediaWiki from the Obama administration, you have only yourself to blame. If you haven’t locked your servers inside isolated containers with strict kernel filters, you have no business running a website on a public IP address. Upgrade your software, rewrite your old code, or get off the network.

Inside a Fortune 500 bank or a venture-backed software company, that attitude makes complete sense. Corporations have security officers, platform teams, automated testing pipelines, and recurring revenue to pay for upkeep. Leaving a corporate payment gateway unpatched is genuine negligence.

Applied to the wider internet, however, “fix your shit” is sociological blindness dressed up as engineering rigor.

The open web is an accidental cultural commons built over thirty years by amateurs, academics, hobbyists, retirees, volunteers who had a free weekend in 2009, and people who have since passed away.

Consider what actually happens when someone tries to upgrade a fifteen-year-old community website from PHP 5.6 or 7.2 to PHP 8.4 so it can receive the php2shell security update. You cannot simply click an update button and go back to bed. Over the past decade, PHP underwent a massive overhaul, evolving from a forgiving, improvisational scripting tool into a strict enterprise language. Old ways of talking to databases were deleted completely. Minor coding quirks that used to generate harmless background warnings were turned into fatal errors that halt the entire program.

If you drop a modern PHP 8.4 engine underneath a custom-modified 2011 hobbyist forum, a retired professor’s linguistic database, or an independent webcomic archive, the website does not become secure. It breaks completely, returning a blank white screen or a wall of cryptic crash logs.

The enterprise security purist assumes that when confronted with a broken website, the owner will audit forty thousand lines of fifteen-year-old code written by someone who left the group a decade ago, rewrite every database query from scratch, and deploy a modernized application.

In the real world, the person paying twelve dollars a month out of their own pocket to keep an old community archive alive gets an automated warning from their hosting company, looks at the broken site, realizes they have neither the programming skills nor the thousands of dollars required to rebuild it, and closes the account.

Security culture operates on the delusion that the choice is between unpatched software and patched software. Across the long tail of the internet, the actual choice is between vulnerable software and extinction. When we treat software maintenance in the public commons as a moral purity test, the default security patch is a dead link.

The Digital Dark Age by Deprecation

In her landmark 2016 report Roads and Bridges, researcher Nadia Eghbal documented a reality that the tech industry still prefers to look past: the foundational layers of our digital world are public goods suffering from a classic tragedy of the commons. Everyone relies on them, and almost nobody is paid to keep them standing. Follow-up studies by the Linux Foundation and Harvard researchers confirmed that a huge portion of vital open-source software rests on the shoulders of one or two unpaid volunteers, while millions of older software projects have no active maintainer at all.

Software is uniquely fragile compared to every other medium of human history. When a nineteenth-century printer pressed ink onto rag paper, the resulting book had passive durability. You can put a paperback in a dry closet, ignore it for eighty years, pull it off the shelf, and read it without first having to upgrade the English alphabet.

A dynamic website is a boat treading water in a corrosive ocean. It requires constant work just to stay afloat. Operating systems expire, security certificates lapse, and now autonomous swarms of hacking agents rattle every digital doorknob on earth twenty-four hours a day, hunting for any program whose creator stepped away from the keyboard five years ago.

Watch how the extinction cascade unfolds during a week like the php2shell crisis.

A mid-sized web hosting provider wakes up on Wednesday morning to discover that three thousand of its customer websites have been hijacked by automated agent swarms. Those hijacked accounts are flooding the data center’s network, mining cryptocurrency, launching attacks against other networks, and getting the company’s IP addresses blacklisted across the globe. The hosting company’s security team consists of three exhausted technicians who cannot possibly rewrite three thousand customer websites by hand.

By Thursday afternoon, management makes the only business decision left to them. They run an automated script across their entire fleet that permanently disables every version of PHP older than 8.2, or they pull the plug on every legacy account showing signs of anomalous traffic.

In a single afternoon, tens of thousands of websites vanish from the human record.

What disappears in that purge is the vernacular history of the internet. We lose regional genealogy databases compiled by retired town historians. We lose the modding archives for twenty-year-old computer games where a generation of kids first learned how to build digital worlds. We lose patient-run medical forums where people with rare illnesses spent fifteen years documenting symptoms and treatment notes. We lose the personal websites of writers, musicians, and researchers who died ten years ago, whose spouses or children kept paying an eight-dollar monthly hosting bill as a quiet memorial without having the faintest idea what a memory buffer overflow is.

We comfort ourselves with the thought that the Internet Archive’s Wayback Machine saves everything, but anyone who has tried to search a deep community forum or an interactive database through a crawler snapshot knows how shallow that preservation really is. Web crawlers photograph the front porch of a website, routinely missing deeper thread pages, search indexes, downloadable files, and broken links behind the scenes.

Just as damaging is what happens to the communities that survive. When running an independent website becomes too dangerous and complex for ordinary people, groups do not stop talking. They retreat into the only fortified compounds left on the map: a handful of massive corporate platforms. They pack up their open forums and move into Discord servers, locking decades of public knowledge inside unsearchable chat rooms that vanish the day a moderator gets bored or a platform changes its rules. They move their publications to Substack, their local groups to Facebook, and their archives to Reddit.

Relentless automated cyberattacks paired with uncompromising security gatekeeping act as a wrecking ball for the independent web, herding every self-hosted community into a few corporate walled gardens.

Autonomous Shielding at the Edge

If lecturing volunteer webmasters fails, and leaving vulnerable servers wide open to botnets is impossible, our engineering approach has to change. We need to stop treating unmaintained legacy websites like broken corporate apps that need a rewrite, and start treating them like fragile historical artifacts that need a protective display case.

When a museum acquires a centuries-old tapestry or a decaying reel of nitrate film, the conservators do not scold the long-dead artist for choosing unstable materials. They place the artifact inside a sealed glass enclosure filled with inert gas, filtering out harmful light so the public can still view the work without watching it turn to dust.

We now have the exact technology required to build those protective glass cases around old web software automatically, neutralizing bugs like php2shell without changing a single line of the fragile code inside.

The first method is an automated “Bake and Freeze” pipeline. A huge percentage of the older websites still running vulnerable PHP engines and databases do not actually need to be dynamic anymore. A community forum that closed new registrations in 2018, a completed university research project, or a memorial blog is really just a static library of pages that happens to rebuild itself from a database on every single visit out of sheer habit.

An autonomous preservation tool can crawl a legacy website from top to bottom, saving every page, discussion thread, image, and stylesheet as flat, unchangeable HTML files, while generating a lightweight browser-based search index. Once the snapshot matches the original site, the system switches the web address over to those flat files and turns off the old PHP engine and database forever. An attacker cannot corrupt the memory of a program that is no longer running. Hosting costs drop to nearly zero, pages load instantly, and the site can remain online safely for decades.

For active communities and interactive sites that cannot be frozen into flat files, the alternative is an automated digital airlock built around edge filters and Linux kernel monitors.

Think about what actually happens when an exploit like php2shell succeeds. The attacker sends a bizarrely structured upload request to corrupt the server’s memory, and then forces the hijacked PHP worker to do something a normal website never does: it tries to open a command prompt, download a hacking tool from an outside server, or overwrite system files.

We can stop both ends of that attack outside the application.

At the front door, before traffic ever reaches the old PHP server, an autonomous security proxy can inspect incoming web requests using fast, lightweight WebAssembly filters. When a new bug like php2shell is discovered, the defensive agent generates a targeted filter rule at the proxy layer that checks form uploads for suspicious memory-stretching patterns and blocks them at the perimeter. The poison never reaches the vulnerable interpreter.

Inside the server itself, modern Linux kernel technology called eBPF acts like an invisible security guard watching the engine room. An autonomous defensive agent can observe an old website for a day to learn its normal habits: it reads web pages from one specific folder, talks to its local database, and never once tries to open a system command shell or connect to a random computer in another country. Once the agent learns that routine, it locks a strict kernel cage around the PHP engine.

Even if an agent kiddie finds a clever new way to slip past the front proxy and scramble the PHP worker’s memory, the break-in goes nowhere. The microsecond the hijacked program tries to launch a command shell or phone home to the attacker, the Linux kernel steps in, terminates the corrupted worker process instantly, starts a fresh replacement worker in milliseconds, and tells the front proxy to block the attacker’s connection. The fifteen-year-old website stays online, completely untouched, yet shielded from machine-scale attacks.

The Sovereign Maintainer

Building automated shields and freezing pipelines solves the technical puzzle, but it leaves the hardest question unanswered: who is going to run those tools, backport security fixes to abandoned code, and keep the shields running for millions of forgotten software packages and websites when nobody gets paid to do it?

In August 2026, in an essay titled Ad Hoc, Incorporated, I explored an idea from Charles Stross’s 2005 science fiction novel Accelerando. The novel opens with a character named Manfred Macx, a “venture altruist” who spins up automated companies on the fly to solve public problems, takes none of the profit for himself, and pushes the value straight into the public commons. Stross recognized that the corporate form is really the world’s oldest, slowest artificial intelligence — an artificial legal person that can own property, sign contracts, and outlive its creators.

Over the past decade, and especially during the last eighteen months, the legal and financial plumbing required to build a real-world version of Manfred’s autonomous public-good company has quietly arrived.

On the legal side, law professor Shawn Bayern demonstrated years ago that under existing United States law, a founder can form a standard limited liability company, write an operating agreement that binds the company to follow the rules of an autonomous software system, and then resign, leaving behind a recognized legal entity with no human members. Taking it a step further, Wyoming passed the Decentralized Unincorporated Nonprofit Association Act in 2024, creating a legal wrapper that allows decentralized, code-governed organizations to sign contracts, pay taxes, and hold limited liability — a structure that Uniswap governance adopted in late 2025.

At the same time, the financial rails for software agents went live. Anthropic’s Model Context Protocol and Google’s Agent2Agent standard gave AI models a universal way to operate software tools and talk to one another. In May 2025, Coinbase and Cloudflare revived the long-dormant HTTP 402 “Payment Required” web code with the x402 protocol, allowing software to pay for an API call in fractions of a cent using digital dollars inside a single web request, with no user accounts or human clicks required. Four months later, Google and more than sixty financial partners launched the Agent Payments Protocol, adding verifiable cryptographic receipts that prove exactly what an autonomous agent is authorized to spend, alongside emerging on-chain identity registries like ERC-8004.

When you assemble those pieces and aim them at the crisis of abandoned software, you get a new kind of institution: the Sovereign Maintainer.

A traditional software company cannot afford to rescue an orphaned open-source code library or maintain free security shields for ten thousand hobbyist forums. Traditional companies have office rent, executive salaries, sales departments, and investors demanding high margins. They need customers who pay tens of thousands of dollars a year. Because the value of maintaining a small, foundational piece of code is spread across thousands of users at fractions of a penny each, the traditional market simply walks away.

An autonomous maintenance organization incorporated as a Wyoming nonprofit association or a zero-member LLC has almost zero fixed overhead. It has no executives, no sales team, and no office buildings. Its only expenses are fractions of a cent for cloud computing and AI model queries.

Here is how a Sovereign Maintainer works when a crisis like php2shell hits:

First, it continuously watches the public software ecosystem, scanning vulnerability alerts, code repositories, and dependency maps to find critical software packages and community platforms that thousands of people rely on, but whose human creators have vanished.

Second, it goes to work in isolated cloud sandboxes. For abandoned open-source libraries and older Linux distributions, the agent takes the official security patch written for the newest version of PHP, adapts the fix to work cleanly on older versions like PHP 7.4 or 8.0, tests it against thousands of simulated websites to make sure nothing breaks, and publishes the updated software package for free. For old community websites whose owners don’t know how to update a server, it packages ready-made protective edge filters and one-click “Bake and Freeze” archiving tools that any web host can switch on automatically.

Third, it pays its own bills without ever charging the public for security fixes. Every patch, filter, and archival tool the Sovereign Maintainer builds is given away free to the commons.

To fund its computing costs, the entity sells automated convenience to large corporations. Thousands of big companies have those exact same abandoned software libraries buried deep inside their own corporate software systems, and their automated build pipelines constantly need to verify which versions are safe to deploy. The Sovereign Maintainer runs a high-speed verification service guarded by x402 micropayments. Whenever a corporate engineering pipeline checks the service during a software build, it automatically pays two-tenths of a cent in digital currency.

Nobody schedules a sales meeting or signs an annual contract. Fifty thousand corporate build pipelines checking that service ten times a day generates a thousand dollars a day in automated revenue, easily paying for the cloud servers, security audits, and computing power needed to keep thousands of public open-source packages and independent web archives safe for everyone else.

Guardrails in Code, Not Promises

Handing an AI agent a bank account, a software compiler, and a legal charter sounds reckless if you assume the AI is in charge of its own boundaries. Early experiments proved just how quickly unconstrained agents lose the plot. When researchers let early language models run simulated storefronts or guard prize pools between 2024 and 2025, users quickly discovered they could sweet-talk agreeable models into giving away the store, or trick them with word games into wiring out the treasury.

Relying on a polite written instruction in an AI’s prompt to keep an organization safe is a legacy mistake from the early days of chatbots. Even as models grow vastly smarter and harder to fool, a prompt is still just a conversation that a clever attacker might eventually manipulate.

What makes a Sovereign Maintainer viable is that its safety rules do not live inside the AI model at all. They live in the legal charter and the hard-coded software wrapper surrounding the model, enforced by strict cryptographic rules that the AI has no power to change.

First, the treasury is locked inside a rigid smart contract. The contract sets a strict daily spending limit and only allows payments to go to a pre-approved list of verified cloud hosts, testing services, and human code reviewers. Even if an attacker somehow tricked the AI into wanting to drain its funds, the underlying payment code simply refuses to budge.

Second, the AI never gets the final word on critical security code. While the autonomous agent does the ninety-nine percent of grueling grunt work — writing the backported patch, building the protective filter, and running ten thousand automated safety tests — any change that touches sensitive security logic automatically triggers an x402 bounty that pays a vetted human engineer to review and sign off on the code before it goes live.

Third, a small board of human trustees holds an unrevokable emergency brake. They do not manage daily operations, keeping the organization’s overhead near zero, but they hold the cryptographic keys to pause the wallet or shut the entity down in sixty seconds if anything goes off the rails.

Finally, the charter includes a mandatory expiration date. Traditional corporations become dangerous because they are built to survive and grow forever, long after their original mission is finished. A Sovereign Maintainer is built to know when its job is done. If a group of human volunteers steps up to adopt an orphaned software project, the agent hands over the keys and steps aside. If corporate micropayments ever drop below the cost of electricity for three months, the system pays its final bills, donates its code archives to a public software foundation, and dissolves itself cleanly.

Keeping the Lights On

There is a grim version of the next decade of the internet that requires very little imagination, because we can already see its outlines taking shape.

In that future, automated hacking tools keep getting cheaper while maintaining independent websites keeps getting harder. Every few months, another deep flaw like php2shell is uncovered by machines and turned loose on the world within hours. In response, the cybersecurity industry doubles down on blame and gatekeeping, web hosts purge older software by the millions to avoid headaches, and the eccentric, self-hosted human web of the last thirty years is quietly switched off. All that remains is a sterile, locked-down network where only trillion-dollar tech giants can afford the security staff required to keep a website online.

We do not have to settle for that sterile future.

The same wave of cheap machine reasoning that created the agent kiddie has also given us, for the first time in computing history, the tools to change the economics of digital preservation. We have the legal wrappers, the micropayment rails, the kernel sandboxes, and the automated tools to build lightweight institutions whose entire purpose is caring for the public digital commons.

When an old stone bridge in a quiet country town starts to show its age, civil engineers do not stand on the riverbank shouting at the townspeople who laid the mortar fifty years ago, and they do not dynamite the crossing to force everyone into the nearest metropolis. They reinforce the arches, post a weight limit at the entrance, and maintain the crossing so the town can stay connected.

The independent web, the long tail of open-source software, and the millions of aging servers humming away in forgotten corners of the network are the bridges and town squares of our shared digital memory. They do not need our lectures. They need builders willing to assemble the autonomous shields and public-good maintainers that will keep their lights on long after their creators have gone home.

Sources for Further Reading

Interpreter Vulnerabilities and Runtime Security

Open-Source Maintenance and Digital Preservation

The Autonomous Company & Literary Foundations

Agent Protocols, Payment Rails, and Identity

AI Economics, Benchmarks, and Adversarial Case Studies