Resurrecting a 1992 MUD with Agentic AI

How agentic coding reconstructed Legends of Future Past, a retro multiplayer online game, from 30-year-old artifacts and no source code

Apr 05, 2026

In 1992, I was nineteen years old and building an online multiplayer game on a ‘486 PC with 16 megabytes of RAM. The game was called Legends of Future Past—a text-based fantasy world where thousands of players would eventually explore, fight, craft, and tell stories together across a sprawling realm called Andor. It launched on CompuServe, and we moved it to the open internet in 1994 as soon as commercial access opened up—we’d tried earlier but got rejected, thanks to NSF policies that restricted the backbone to academic use. The game ran for seven years before we shut the servers down on December 31, 1999.

For twenty-seven years, it was dead.

This weekend, I brought it back.

I pointed an AI agent at those artifacts and asked it to figure out what the game was—and rebuild it. A game that originally took me six months to code, with a team of Game Masters building the world over years, came back to life in a weekend of agentic engineering.

The resurrected game on the left; a magazine ad from the 1990’s on the right.

The Game That Helped Build an Industry

If you’ve played any modern MMO, you’ve touched something that traces its lineage back to text-based multiplayer games—MUDs. Before World of Warcraft, before EverQuest, before Ultima Online, there were these strange, beautiful text worlds where you typed commands and your imagination rendered the graphics.

The lineage runs deep. Richard Bartle co-created the very first MUD in 1978 at Essex University, and later developed the Bartle taxonomy of player types—Achievers, Explorers, Socializers, Killers—a framework that still shapes how we think about player motivations in every online game today. Raph Koster, who went on to design Ultima Online and Star Wars Galaxies, has documented this lineage meticulously in his Online World Timeline. MUDs were the primordial soup of online gaming.

Legends of Future Past was part of that wave. It won Computer Gaming World’s 1993 Special Award for Artistic Excellence—the judges wrote that they were “overwhelmed by the creative power of storytelling and fertile liveliness.” The game pioneered things we now take for granted: one of the earliest crafting systems in online games, skill-based progression without arbitrary level caps, and paid Game Masters who ran live narrative events. People who cut their teeth as GMs and developers on LoFP went on to work on Star Wars Galaxies at SOE, founded studios like Worlds Apart Productions, Dejobaan Games, and Magic Soup Games, and shaped the trajectory of online worlds.

But like most online games of its era, when the servers went dark, the game simply ceased to exist. No archive. No emulator. Just memories and a Wikipedia page.

This is a pattern that should worry anyone who cares about creative history. The Video Game History Foundation found that 87% of classic games released before 2010 are no longer commercially available. For single-player games, at least the software artifact persists somewhere. But multiplayer online worlds? They only ever lived on servers. When those servers shut down, the world vanishes. It’s as if someone burned every copy of a novel and demolished the library that held it.

Some communities have fought back. Ultima Online still runs official servers nearly three decades later, plus hundreds of fan-operated “freeshards.” Star Wars Galaxies, shut down by SOE in 2011, lives on through SWGEmu and SWG Legends. City of Heroes was resurrected by fans and officially licensed by NCsoft in 2024. But for every EverQuest with a Project 1999 keeping the flame alive, there are dozens of worlds—WildStar, The Matrix Online, The Sims Online—that are simply gone. No emulator. No private server. No way back.

A Weekend Resurrection

I didn’t plan this as a weekend project. I’d been thinking about it for years—wondering if the game could be reconstructed, knowing the source code was long gone. What changed everything was a convergence of two things: old files and new tools.

Here’s what I had to work with. Some of our original Game Masters had held onto their script files for nearly three decades. A complete set of files in a custom scripting language I’d invented at nineteen, defining every room, monster, item, spell, and interactive event in the game world. I also had a gameplay capture from 1996, the original GM scripting manual from 1998, and assorted player documentation. What I did not have was the game engine source code.

Here’s what happened next: I pointed Claude Code at the artifacts and said, essentially, figure out what this game was and rebuild it. That makes it sound simpler than it was—I spent the weekend in a tight loop with the agent, providing context, shaping decisions, course-correcting when its assumptions drifted, and making the technical judgment calls that no AI can make on its own. Agentic coding isn’t autopilot. It’s more like directing a tireless, brilliant collaborator who needs you to stay in the room.

The results were startling. Even without source code, the ability to observe the outputs and interactions from the original game were sufficient for reconstructing the core experience. Claude Code reverse-engineered my scripting language—parsing the DOS-era script files, decoding the combat formulas from GM documentation, and inferring the behavioral patterns of monsters from strategy fields that encoded AI profiles as integer ranges. It built a complete game engine in Go, a React frontend, a WebSocket multiplayer layer, and a MongoDB persistence system. The whole thing deployed to Fly.io.

A game that I originally coded over six months—with a whole team of Game Masters building the content over years—was resurrected in a weekend of agentic coding.

Reverse-Engineering a Language I Barely Remember

When I looked at the script file language I invented when I was nineteen, it was a little humbling. It’s a pretty bad language. My only excuse is that I had to make an entire game world fit into a 16MB Pentium machine, and although I’d written games and a BBS before this, I’d never written a language before.

The scripting system used an imperative syntax with conditional blocks—IFVERB, IFVAR, IFITEM, IFPREVERB, ELSE, ENDIF—and supported variable arithmetic, monster spawning, item creation, room transitions, and dozens of other actions. It was case-insensitive, DOS-encoded, and full of the kinds of shortcuts you make when you’re nineteen and optimizing for memory constraints that no longer exist.

Apologies to the GameMasters who had to suffer through this scripting language.

That said, it worked. Relatively non-technical people of the time learned to use it—our Game Masters would write elaborate interactive storylines, puzzles, and events using this language. And Claude Code had no problem reverse-engineering the language interpreter from the code examples and manuals. It parsed the conditional logic, decoded the noun and adjective definition systems, figured out how room descriptions were delimited, and reconstructed the entire execution model for script triggers—entry scripts, verb scripts, pre-verb validation, speech handlers, all of it.

This is the part that still amazes me. A language I designed three decades ago, with no formal specification beyond a GM manual and a pile of example scripts, was fully reconstructed by an AI agent that had never seen it before.

The Software Archaeology

Vernor Vinge called it the work of the “programmer-archaeologist”—in A Deepness in the Sky, he imagined a far future where the most valuable skill wasn’t writing new code, but excavating ancient programs from vast, layered codebases and making them work again. The concept of software archaeology has become a real discipline, but Vinge’s fiction captured something that felt very literal to me this weekend.

For those interested in how the sausage gets made, here’s what the reconstruction involved at a technical level.

The contrast between the original and modern tech stacks tells its own story. In the 1990s, the game was written in C, running on Major BBS as a single-instance process with fully reentrant code—everything had to fit on a 16MB Pentium, persisting data to a Novell Network with a b-tree file store. The resurrected version runs on Go with goroutines handling concurrency—a multiplayer game is essentially a system of concurrent state machines, and Go handles that elegantly. The frontend is React with TypeScript, connecting over WebSockets for real-time gameplay. MongoDB handles persistence: player characters, session recordings, game logs, and a hub system for multi-machine synchronization using change streams. Two different eras of engineering philosophy, same game.

The script parser had to solve some genuinely tricky problems. The original files were DOS-encoded with case-insensitive filenames, which immediately broke on case-sensitive filesystems. Script blocks could be implicitly terminated—a pattern that required the parser to infer structure rather than just follow explicit delimiters. Variables lived in multiple namespaces (player stats, item properties, environmental data) and had to be resolved contextually at runtime.

The combat system was reverse-engineered from the 1998 GM manual: d100 threshold mechanics with damage severity tiers ranging from “Puny” to “Dazzling,” weapon-dependent attack verbs, stance modifiers (offensive, defensive, berserk), fatigue accumulation, weather effects on accuracy, elemental criticals, and an armor reduction system capped at 85%. The monster AI was decoded from STRATEGY fields—integer ranges that mapped to behavioral profiles from non-hostile to fight-to-the-death.

All told, the reconstructed game includes 2,273 rooms, 1,990 items, 297 monster types, 88 spells across five schools of magic, 30 psionic disciplines, a full crafting pipeline (mining, smelting, forging, alchemy, weaving), 8 playable races, and a 12-month in-game calendar. The original game, faithfully rebuilt.

What This Means for the Direct-From-Imagination Era

I’ve written before about the direct-from-imagination era—the idea that we’re entering a period where the bottleneck for creation shifts from technical implementation to imagination itself. This project is maybe the most personal proof point I have for that thesis.

In the 1990s, building Legends of Future Past required months of solo effort just for the engine, plus a whole team of Game Masters building the world over years: writing a custom game engine in C, inventing a scripting language, hand-coding thousands of rooms and items, managing server infrastructure on hardware that cost more than a car. The technical barriers were enormous. Most of what we spent our time on wasn’t creative—it was engineering.

What happened this weekend inverts that equation. The engineering was handled by an AI agent. My job was to provide the creative artifacts—the scripts, the documentation, the vision of what the game was supposed to be—and to make judgment calls the agent couldn’t make on its own. The imagination was the input. The implementation was automated.

This isn’t just about nostalgia or game preservation, though I think both of those matter. It’s about what becomes possible when the cost of implementation approaches zero. How many dead online worlds could be resurrected if all you needed were the creative artifacts and a weekend? How many games that only existed in someone’s imagination could now become real?

I’ve also written about games as platforms rather than just products—and about the age of machine societies, where bots and AI agents become participants in virtual worlds rather than just tools for building them. Bots weren’t part of the original 1990s game, of course. But Legends of Future Past now has a bot API: you can generate per-character API keys and connect automated agents that participate in the game world alongside human players, following the same rules, inhabiting the same spaces. A bot can’t do anything a human can’t. And maybe that’s exactly the point—Andor gets to live on as a place to breed and experiment with machine societies. A game built in 1992, resurrected by AI in 2026, might find its deepest new meaning as a world where humans and agents coexist.

Come Visit Andor

The game is live at lofp.metavert.io and the source code is open under the MIT license on GitHub. You can create a character, explore the Shattered Realms of Andor, and experience a piece of gaming history that nearly vanished forever.

If you were one of the thousands who played the original game in the 1990s—some of you are still out there, I know—come home. The world remembers you, even if the servers forgot.

And if you never played it, you’re welcome too. The rooms are still there, the monsters still wander, and the stories are waiting to be told again. This time, they won’t disappear.

“There were programs here that had been written five thousand years ago, before Humankind ever left Earth. The wonder of it—the horror of it, Sura said—was that unlike the useless wrecks of Canberra’s past, these programs still worked!”
— Vernor Vinge, A Deepness in the Sky

Metavert Meditations

Discussion about this post

Ready for more?