I first really spent time with Lotus Agenda was because of a guest post I wrote for 512 Pixels, which meant I approached it with the half-serious curiosity of someone who’d long harbored a suspicion that MS-DOS software might change the way he thought.

I’d been Agenda-curious for a long time, but never tried to actually use it for real. I booted it up on my Pocket 8086, watched cards crawl into place, watched queries resolve themselves into slices of sense, and realized with annoying clarity: none of the modern “task management” apps I’ve used—not Todoist, not OmniFocus, Amazing Marvin, Remember the Milk, not Microsoft To Do—could do any of this. Not really. Agenda wasn’t “a to-do list.” It was a cognitive environment, a place where items could belong to more than one thing at once, where priorities didn’t march in a line but emerged from the way pieces related to one another.

This is not a user guide (Tavis Ormandy already wrote a careful, generous one here). It’s more of a lament—or maybe more of a small civic memorial—for an unexplored avenue in productivity software that modern tools only approximate in fragments. The utopian tools-for-thought vision of Agenda didn’t vanish because it was wrong; it vanished because it was weird and unprofitable.

The city that could rearrange itself

Agenda arrived in the late 1980s, back when DOS reigned, mice were a nice-to-have, and “personal information manager” still meant something closer to augment your mind than make a dashboard. Part of the program’s strangeness is conceptual: it treats pieces of information as first-class citizens, and treats “organization” as a set of overlapping relationships you can keep recombining on the fly. You don’t file a thought, you assign it—often in many places at once—and then you ask the system to show you different views of the mess based on rules you declare after the fact. (The rules are the interesting part; the rules are where the thinking is.)

If you want the canonical period feel, the original manuals live on the Internet Archive—start with the Users Guide and leaf through “Quick Start,” “Working with Macros,” and “Working with Definition Files.” It’s not just software; it’s a stance toward information, one where you retain permission to change your mind about how things fit together long after you’ve written them down. (In a modern app, that’s called “refactoring a database schema.” In Agenda it’s called “Tuesday.”)¹

The old community documentation still reads like a transmission from an alternate reality. Bob Newell hosts a trove of material, including the very plainspoken Agenda FAQ and an index of resources. The model boils down to three ideas: items (free-form text), categories (overlapping conceptual buckets), and views (query-driven windows that splice those relationships into meaning). It sounds mundane until you realize what it enables: you can tag promiscuously, look laterally, and conjure new slices of your work without reorganizing the work itself. The structure is a lens, not a prison. You can do whatever you want with the stuff you have in Agenda, and once you see that, you can’t really un-see it.

If you need a quick fact dump beneath the romance, the Wikipedia entry puts names and dates to things, and you can always go download the thing at WinWorld and look at screenshots. But the encyclopedia tone, and even the manuals themselves, can’t convey the feeling of it: Agenda behaves like a little city that rearranges itself when you ask a new question.

GTD, capture, and the tyranny of places

When Getting Things Done landed in the early 2000s, it didn’t just become a bestselling book—it became a lifestyle, especially in Mac and designer circles. The method spread through blogs, podcasts, and the burgeoning world of productivity forums. Merlin Mann was explaining it on 43 Folders, OmniGroup was building OmniFocus as the “Mac-ass Mac app” for it (full disclosure: I was one of the early users on the invite-only “Sneaky Peek” builds of OmniFocus 1, so I know whereof I speak), and every independent developer with a copy of Xcode seemed to be designing their own GTD-inspired task manager.

The appeal was obvious: GTD promised to tame life’s chaos with a deceptively simple premise: capture absolutely everything that has your attention, process it into a trusted system, and review it regularly. In the design community, where aesthetics and workflows intertwined, GTD became more than a system; it was the design brief for a whole generation of task apps. It was also the progenitor of a million blogs and podcasts, “productivity hacks,” and a bunch of other things, including the widely-misunderstood but brilliant Inbox Zero. Interfaces were built around inboxes, projects, and contexts because that’s what the method demanded. Soon, the GTD-shaped template was the default for “serious” productivity software.

But baked into GTD’s promise is a subtle, rigid assumption: if you’re going to have everything in your system, that system has to have a place for everything. Which means you need to decide—often very early—what those “places” are. And then you have to keep deciding.

Once you have that structure, it starts shaping the way you think about the stuff you put into it. Capture leads to categorization; categorization leads to a fixed set of buckets; the buckets become the mental map. It’s clean, and it works—if you’re comfortable letting your first pass at organization become the scaffolding for everything that follows.

The obvious counterpoint is that GTD is supposed to be as flexible as you want it to be. You can rename your contexts, refactor your projects, blow away your tag structure entirely. Nothing is technically fixed. But in practice, that flexibility invites endless “tuning”—fiddling with categories, reorganizing lists, tweaking perspectives—all of which feels like productivity but often isn’t. (Merlin Mann, years after popularizing GTD, would openly joke about this “meta-work” trap: the point where the system stops serving you and starts existing just to be fussed with.)

Agenda never asked that of you. It didn’t care how you captured things, or whether you processed them at all. You could dump in whatever you had—fragments, ideas, tasks, raw notes—and worry about what they meant later. The categories, the queries, the “workflow” could emerge from the material itself. That’s the part that doesn’t survive in GTD-land: the permission to let meaning arrive late, to let your structure be provisional until the content tells you otherwise.

Modern GTD-inspired tools enforce the place-for-everything worldview because they have to: it’s the only way to make capture-and-process work at scale. Agenda never gave a damn. And that indifference to workflow—that refusal to tell you what your process should be—is exactly what made it so weird, and so powerful. (Also so hard to learn, as someone whose brain has been poisoned by about twenty years of GTD knowledge at this point.)

“But what about Org mode?” (A fair question with a short answer)

Org mode belongs in this story, but not as the hero—more like a secret passage through the ruins. Its agenda views, tags and properties, and query-driven lists absolutely echo Agenda’s model; if you squint, it’s the same “write first, declare meaning later” ethic, implemented in plain text with Emacs as a friendly (well, for certain definitions of “friend” anyway) exoskeleton. If you already live in Emacs, Org’s fluency with emergent structure feels like a private privilege in a world of tidy linear apps. If you don’t, it feels like an alien monolith.

But Org’s virtues are also why it can’t carry the argument here. It’s a niche on purpose. It asks you to believe in it. It’s not trying to be a mass-market replacement for flattened software; it’s trying to make your thought-work livable on your terms. (Which, ironically, is the real shadow of Agenda: not a product, but a posture.) The lament isn’t that Org isn’t popular enough; the lament is that the mainstream either forgot this family of possibilities existed at all or, more likely, wouldn’t have cared even if they’d been exposed to it.

If you want one modern artifact that shows the old spirit survives in the open, Tavis’s post is it—a living museum of the mechanics and the ideas without the romantic haze. But even there, you can feel the distance between “here’s how it works” and “here’s why the world won’t pay for it.” Agenda’s lineage is just a subculture now, and subcultures are where weird things thrive quietly until the zeitgeist tilts (if it ever does).

What we lost (and why it was worth talking about)

Agenda teaches two lessons that most modern tools actively discourage.

1) Write first, decide what it means later.
In a GTD-shaped app, the categories define the work. In Agenda, the work could define the categories. You could over-assign items to overlapping categories, then build views that treat the same pile of stuff as a to-do list, a knowledge base, and a status report—without rewriting a thing. The “truth” of the item was relational, not essential. It tolerated ambiguity and rewarded curiosity, letting meaning emerge from the material instead of forcing you to decide too early.

2) Use queries as lenses, not cages.
Agenda’s views are invitations to ask new questions of the same corpus, not fences you’re forced to paint every week. If you’ve used any modern PKM system with a decent query language you’ve tasted this, but in Agenda it’s foundational: the query is the interface. Most of us now expect a list with a filter. Agenda expects a question with an answer that can keep changing. The difference is small until it isn’t.²

Why does this matter? Because software shapes thought, and mainstream tools teach us that “productivity” means “decide a structure early and obey it.” (Which is fine for keeping up with logistics, but it’s deadly for discovery.) Tools in the Agenda lineage teach a competing lesson: that you can improve your thinking by letting your structures arrive late, by learning from how the work wants to group itself, by refusing to declare premature victory over meaning… and doing so without having to manage a rat’s nest of hyperlinks like you do in a tool like Obsidian or Logseq. Rheingold’s Tools for Thought history of mind-expanding systems glows with this ethos—computing not as a factory but as a prosthesis for the weird parts of people’s intelligence. Agenda was one of the last mainstream artifacts that tried to embody it in everyday work.

The little memorial at the end

While I was trying to use Agenda, I’d shut down the Pocket 8086 (or DOSBox-X) and open a modern app and would feel (for a second) like I’d stepped from a city that could rearrange itself into a grid of cul-de-sacs, like I was returning from Tlon, Uqbar, and Orbius Tertius. The modern apps are fine—they keep you busy, get you home on time, keep you from forgetting to water the houseplants on the days you’re supposed to do that—but they rarely let your work teach you how it wants to be seen. That’s the loss. There’s simply no widely-available tool that captures the same spirit, and it seems unlikely that there ever will be another one. Everything is a checklist now, because everything is a checklist now.

Agenda’s utopia didn’t die because it was wrong; it died because it was weird. And yet, in the corners (an Emacs buffer here, a vintage manual there, an enthusiast’s blog that reads like field notes, the long-abandoned open source attempt to recreate it), it’s still alive enough to haunt the imagination. If you’ve ever suspected that the best part of “productivity” is the part that changes your mind, Agenda is waiting—not for you to adopt it permanently, but for you to feel what it’s like to live in a tool that expects your structures to arrive late. Problem is, you need a DOS machine to explore it.

It’s a small thing, a private thing. But it’s the difference between software that manages actions and software that amplifies thought. And once you’ve seen how it could be, you’ll always miss it.

If you want to explore the ruins

A few places to wander, if you’re in the mood:

• Tavis Ormandy, “Lotus Agenda.” A modern, careful tour with working examples and lots of “oh that’s how it fits together” moments.
• Lotus Agenda on Wikipedia. Names, dates, versions—the factual scaffold beneath the romance.
• Original manuals on Internet Archive. The best way to feel how function-key-forward, query-first, and gloriously un-app-store the whole thing is.
• Bob Newell’s Agenda resources and FAQ. Dry as saltine crackers on the set of Ishtar, but they give you the mental model in plain language.
• Howard Rheingold, Tools for Thought. Readable online; a window into the ethos Agenda came from.