(2025-08-14) Hidden Agendas Lost Cities

Kevin Lipe: Hidden Agendas, Lost Cities. I first really spent time with Lotus Agenda 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, and was determined to find out, armed with an impossibly small terrible keyboard

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

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.

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 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

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.

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.

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

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.

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

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.” (

doing so without having to manage a rat’s nest of hyperlinks like you do in a tool like Obsidian or Logseq

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

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.

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.