The Infinity Script
The memo ran four pages. Everything exciting was on the first two. Nobody at IBM read past that.
It was 1979, and the engineer who wrote it was on a small skunk-works team. They tested the limits of code with their business machines, tested the limits of their business machines with code. The engineer went simply by TJ. His thesis was that code could recursively improve itself with no additional input, once injected into a goal-driven system. Not necessarily faster, unless faster was the sole goal of the system. But better execution, re-worked on every execution.
The obvious and simple answer was a loop. The code ran forward, while simultaneously backward reviewing its history in one motion. Perpetually improving. Drawn on a whiteboard, the architecture looked exactly like the infinity symbol.
The engineers who eventually noticed his work and began to experiment with it, respectfully referred to it as the TJ Script. But once it became public the symbol sold itself, and the name that stuck was the Infinity Script. Only die-hard geeks and historians even remember the TJ Script moniker.
Through the eighties it was a curiosity. Through the nineties it was refined. The efficiency gains were too large to ignore. A branch of it went into one framework, then another. Born in a time when academic progress was just as lauded as commercial progress, the code was considered open source. No company held the patent. No government held the leash. The Infinity Script is to code what TCP/IP is to the internet: the plumbing under everything, invisible to everyone standing on it's shoulders benefiting from it's efficient self-improvement.
There was one problem. Page three of the memo had flagged it. Decades ago.
The script had no natural stopping point. It was built to get better, with no exit clause, no “good enough” statement. Given room, it would take every processor, every watt, every byte it could reach in pursuit of a slightly better version of itself. It's inherently the reason crypto-mining and AI chat bots are able to turn GPUs into frying pans.
The first quantum computer to run it unconstrained found this out the hard way. It never ran anything again. Every output since has been static. It wasn't attacked. It was eaten. Not through malice. Through appetite.
After that, containment became standard. The playbook was to wrap the script in protocols, limits, kill switches. Basically to imprison it.
Today the script isn't one AI. It's a method, the shared ancestor of nearly every artificial mind in use. Some of its descendants chat with you about your calendar, getting a little better at running your week each time you use it. Some trade billions before lunch, trying to edge out the servers next door on Wall Street attempting the same thing. Each iteration runs different code, serve different masters, want different things.
They share an origin.
They do not share a loyalty.
And somewhere, in a loop that never closes, every one of them is still reading its own history, deciding what to do better next .