Ted Nelson has been on my mind a lot this year.

Nelson was a pioneer in computing, and in 1965 he coined the word hypertext as part of the project that would define his career: Project Xanadu. With Xanadu, he had a specific vision of what computing could be, which he called the docuverse. He imagined a system that could keep every version of a document; hypertext links would know both their source and destination, and quotations would be kept by reference (rather than copy) so any included text maintained its identity and source. Everything, in this version of computing, would be intertwingled and xanalogical. We're talking about attribution down to the span.

To be xanalogical is to follow two rules: Never copy, always reference (also known by a Nelsonism, transclusion). Never overwrite, always version. As Nelson designed it, Xanadu would manage the system's complexity and massive bookkeeping burden itself, so users only experienced the benefits of a system that could never forget.

The vision of unlimited bookkeeping requires the reality of unlimited storage and a future-proof naming scheme, neither of which existed for the decades that Nelson worked on Xanadu. So when web technology exploded in the '90s, developers bypassed xanalogical computing in favor of ease: links are simple strings which break if their target moves. Maintenance became users' problems — instead of the system's responsibility — but it was easy for anyone to ship fast, and they did. Xanadu faded from the promise of a new era into computing's most famous vaporware.

Nelson has spent his career explaining that the web is a flattened parody of what hypertext was meant to be. He's right, but it didn't matter because people didn't actually need to be able to follow every link or compare every version. We're a restless species, and more inclined to follow the links or read the versions we see others pursuing. Flat was good enough.

Then agents arrived.

What makes an agent an awkward collaborator also makes it a perfect citizen for Nelson's system. Agents can follow more layers of subtext than people can hold in their heads at once, such as the sources behind a quotation, any discussion around it, and stack traces attached to the exact code that ran. A fragment-based representation makes those references lossless, so each layer stays attached to the same span as the text changes. Agents can read these dimensions together, cite them so humans can audit their work, and patiently follow every link, every time. But those links need to actually exist somewhere in order for an agent to find them.

When I revisit Nelson's vision now, I recognize DeltaDB's design goals and the promise of Delta. After decades of squashing history to meet the limits of the human attention span, we're in a new reality that would be better served by something more... xanalogical.

A few years ago I wrote about watching Engelbart's 1968 demo and my realization that to build a collaborative editor, his team had to invent everything it would rely on: a new programming language, operating system, and displays.

Nelson had the same problem (but with way less funding than Engelbart enjoyed). He couldn't build Xanadu because most of its parts didn't exist, such as a way to name content that no authority issues, or storage cheap enough to never delete. His teams hand-built their own data structures for years, but the project died on the vine. Wired depicted Nelson's story as one of mismanagement, but I think he'd just specified Xanadu decades before its dependency tree existed.

We can build Delta today because sixty years of other people's roadmaps delivered the docuverse's missing pieces: kernel development, photo storage, serverless cold starts, collaborative cursors. I think it's fascinating that breakthroughs have ordinary day jobs, yet will enable the next era of computing.

A clock for a world with no center. Lamport timestamps, 1978. Every operation by every human and agent is named by an actor plus a Lamport timestamp, forever.

Names that can't lie. Merkle trees, 1979, made ordinary by Git in 2005. A Git commit hash names an exact immutable project state; DeltaDB names every state between commits by the Git commit it descends from and the set of actor-and-timestamp delta IDs applied above it.

Convergence without coordination. CRDTs, formalized in 2011, and the center of Zed's own work for the past decade. A Delta worktree can be edited by several people and agents on different continents at once.

Storage too cheap to delete. A gigabyte cost tens of thousands of dollars in 1981; it costs a penny now. We keep every version of everything by default.

Networks that replicate everything. Always-on and fast broadband overtook dial-up in the mid-2000s. Every thread is live, replicated data on every participant's machine and in the browser.

Machines summoned in milliseconds. Firecracker-class microVMs, 2018. Agents in Delta can provision a new isolated cloud machine mid-conversation.

Documents as views over permanent content. Max Brunsfeld's Tree-sitter, 2018, fast enough to reparse as you type. GPUI, pioneered with Zed, fast enough to derive a fresh interface from application state whenever a frame is drawn. A Delta thread is a live projection of its permanent structured history, recomputed rather than stored as a flattened document.

On one detail — across a career of being told his dreams were too big — Nelson dreamt too small. The final dependency he was missing was a new kind of user. He didn't imagine artificial readers, though they existed in science fiction (like Asimov's Multivac, or Stephenson's Librarian).

Though Xanadu was blocked for decades by missing components, what it needed most was the perfect user.

Most actual code creation has always happened between commits, but it used to hurt less to flatten the context because we got by on human memory (and nobody was going to read full records of keystroke changes anyway). But agents keep nothing in their heads, and they'll read everything, so we need a way to capture the new source of truth using exactly what Nelson specified: permanence and connection.

Every Delta thread delivers on that promise. The conversation and the code are captured together in a shared history. On screen, a file still looks like a one-dimensional string of characters but underneath, DeltaDB represents it as fragments with stable identities. Those identities let us create anchors: references to spans that can still be resolved after surrounding code changes. A line number can express where text appears in one snapshot, while an anchor preserves which span we mean across snapshots.

We have been exploring how agents can build on that coordinate system. The files and symbols earlier agents repeatedly read, edited, cited, or returned to can become landmarks for the next agent, resolved against the code as it exists now and linked back to the conversations where that understanding was formed. By preserving the causal metadata beneath that surface representation, like which operation produced each fragment and what prior state it built on, DeltaDB gives the model a way to traverse not just the current code, but its provenance, accumulated attention, and prior reasoning.

Xanadu had a final failure mode, this one self-inflicted: it refused to interoperate with lesser formats. As we introduce DeltaDB to the world, we're learning from that mistake. We'll work with the git repository you already have. Every thread is also a git branch, so teammates who never open Delta see a normal repo, and because the files are real, it integrates seamlessly with any tool an agent can use. You can keep mirroring your repo to GitHub to work with anyone who isn't ready to make the switch (that's our approach for our open source IDE, Zed, during this transitional period).

Engelbart and Nelson were prophets of early computing, yet we never shipped either's vision whole: from the former we adopted the mouse (and eventually multiplayer editing), and from the latter we took the word hypertext. Both ideas survived, but neither at the depth their creators imagined. We still split the live session from the durable record: discussion, intermediate states, and intent are flattened into a final file or commit, while links tied to paths and line numbers decay as the code moves. I hope for Delta threads to meet both visions at once: a live session that leaves behind a permanent, connected literature, because the session and the record are the same object.

Every property we needed to build Delta and DeltaDB was specified by Nelson before I was born. And though my goal is not to realize Xanadu, I still feel some of the antsiness Nelson must have experienced while hoping for a long-held vision to land in people's hands. Sixty years is a long time for an idea to wait for its users. They're here now.