Tasks That Cascade: Ten Years of Building a To-Do List

In October 2016, the commit that made our to-do list work was titled "Able to recursively render nodes." A task was a node. A node could hold more nodes. The editor drew the list by calling itself, one level at a time, until it reached the thing you were supposed to do next.

We called the project Taskcade: tasks that cascade. Three months later a search-and-replace dropped the "c," and the product became Taskade. The company never changed its papers, so the legal entity is still TASKCADE INC.

This is a look back at ten years of building that tree, and at the two and a half centuries of to-do lists that came before it. The short version: nearly every task tool ever made, from Benjamin Franklin's daily schedule to the cloud apps of the 2010s, solved the same half of the problem. They helped a person decide what to do. Then the person did it. What changed in the last three years is that software can now do some of the second half. What has not changed enough is how often it gets that half wrong, and I will try to be specific about that too.

Katsushika Hokusai, Kirifuri Waterfall at Kurokami Mountain in Shimotsuke, about 1832. The Metropolitan Museum of Art, via Wikimedia Commons, public domain (CC0).

The print above is the picture I had in my head. One source at the top breaks into dozens of streams, and at the bottom three travelers stand and watch the water arrive. That is a task list in 2016: a beautiful structure, with people at the bottom doing the walking.

The cascade was the data structure

The name was never a metaphor we added later. The first commit landed on September 26, 2016, a Redux starter project from my co-founder Dionis Loire. On October 6, Dionis titled the README "Taskcade." The early commits read like a spec: "An initial implementation of the data structure," then, on October 24, "Able to recursively render nodes." Dionis and our third co-founder, Stan Chang, wrote all of the first few hundred commits.

In January 2017 the site title read "Taskcade: Free To Do List and Task Manager." On January 24 it became Taskade. Why drop the "c"? The honest answer is the boring one: Taskade was easier to say, easier to spell, and easier to find.

Five months later, someone else arrived at the same word on his own. Sam Rebelsky, who teaches computer science at Grinnell College, wrote a blog post about his Sunday afternoon: each task "leads to another task, which leads to another task. It's a cascade of tasks, or a taskcade, as I've come to call them." In a footnote he searched the word, found us, noted that we also own taskcade.com, and decided that his meaning was different from ours. (Rebelsky, 2017). He went on to use it as a verb: "My work is taskcading!"

Here is roughly what the tree looked like in our own workspace that year:

[ ] Launch Taskade
  ├─ [ ] Build the outline editor
  │    ├─ [x] Store tasks as a tree of nodes
  │    ├─ [x] Render nodes recursively
  │    └─ [ ] Sync edits between people live
  ├─ [ ] Ship the open beta
  │    └─ [ ] Write "Taskade is coming!"
  └─ [ ] Talk to every early user

The tree had one property we cared about more than any other: several people could edit it at the same time. The three of us had worked remotely across time zones for years, and our tasks lived in five apps. We wanted one tree that everyone could see and change at once. The open beta was announced on December 5, 2017.

A short history of the to-do list

Task management is much older than software, and its history splits along two threads. The first is structure: how to break work into pieces and order them. The second is who does the work. Almost every tool on the list below improved the first thread and left the second one alone.

Two caveats for the careful reader. The Ivy Lee method comes with a famous story, a consultant paid $25,000 by Charles Schwab after three months, and the story has probably been polished in the retelling. And Engelbart's demo was a lab system on a shared machine, not a product anyone could buy. Its outline editor still looks modern.

Read the right-hand column top to bottom and the pattern is plain. Each generation made the list better at telling you what to do next. None of them did it. Our longer histories of the to-do list and outliners trace the structure thread on its own.

Every homepage is a bet

The earliest tagline in our records is "Taskade - Get things done." from January 2017. The line I remember from our scratch pad went further: "from ideas to action, tasks to execution." No document from that time survives with it, so take it as my recollection, not a record.

The first half reached the homepage on August 19, 2020. The second half stayed a promise for years, because in 2016 software could hold a task but could not carry it out. You can watch that change in our homepage headline, which we rewrote at least eleven times:

Eleven headlines in ten years is not a sign of a team that knew exactly what it was building. Each one was a bet about what the product was, made with the information we had that year. Read in order, though, they drift in one direction: from a list, to a shared list, to a place, to ideas becoming action, to steps done by software.

Ten years in five eras

2016 to 2019: a live tree. The product was a shared tree of tasks. Our earliest archived newsletter, on August 7, 2018, shipped uploads, video and voice calls, due dates, and comments, because work was never only a list. Taskade 2.0 shipped on January 22, 2019. A month later, on February 19, you could switch the same tree between views, such as a list, an action view, and a mind map.

2019 to 2021: one workspace for remote teams. We joined Y Combinator in the Summer 2019 batch and announced a $5M seed round from Grishin Robotics and Y Combinator that October. TechCrunch called us "the love child of Notion, Slack and Asana," which was more colorful than our own pitch. In a March 31, 2020 newsletter, as offices closed, I wrote: "Despite our experience working remotely, we were frustrated about having to hack together multiple tools in order to get things done." On August 25, 2020, the Free plan dropped its project and collaborator limits. In 2021 "action" still meant people. The workspace got a team on the same page, and the team did every step.

2022 to 2024: a second pair of hands. Taskade AI launched on December 12, 2022, with commands like expand, rewrite, and summarize. AI agents entered beta in May 2023, and automations went live on January 29, 2024. This was the first time the bottom of the cascade changed. A task could be handed to something that was not a person. The hand-offs started small (draft this, summarize that) and grew (research this topic, sort these leads, send this update every Monday).

2025: the pieces connect. We had shipped projects, agents, and automations as separate tools, and users had to wire them together by hand. Taskade Genesis builds all of it from one prompt: the projects that hold the data, the agents that reason over it, the automations that act, and the interface people use. Taskade EVE, the builder agent, does the assembly. The preview newsletter drew a line back to 1987: "In 1987, HyperCard let anyone build software. In 2025, Taskade Genesis lets anyone build intelligent, connected systems." Our year-end letter compressed the idea into five words: "The loop is the product." The longer story of those 110 days is in The Product We Didn't Know We Were Building.

2026: a kernel with memory. Workspace Memory arrived in May. On July 8 we introduced TSK-1, a coordination layer that, by default, picks a model for each step of a build and connects it to the workspace's projects, agents, and automations. In August we started publishing a benchmark, which is the part of this story I trust least and like most.

What "execution" means now

In 2016, a task had two states: open and done. Today the same task has a path, and most of the path can run without anyone touching it. Here is one task, followed through an app built this way. A visitor fills in a client sign-up form:

The architecture underneath is a loop more than a pipeline. Memory feeds reasoning, reasoning triggers an action, and the action writes new memory for the next run:

┌──────────────┐     ┌────────────────┐    ┌──────────────┐
│ MEMORY       │────▶│ INTELLIGENCE   │───▶│ EXECUTION    │
│ projects,    │     │ agents         │    │ automations, │
│ fields, files│     │                │    │ integrations │
└──────▲───────┘     └────────────────┘    └──────┬───────┘
       │                                          │
       └──────────── results become memory ◀──────┘

We call this Workspace DNA. The name matters less than the design choice behind it: the agent and the automation read and write the same rows a person sees. If the agent scores a lead wrong, you can open the row, see the score and the reason, and fix it. That choice came straight from the 2016 tree. Everything sits on one shared structure, so a person can always inspect what the system did.

Measuring what finishes

Most AI benchmarks test what a model knows. We wanted to test what it finishes. The TSK-1 Benchmark gives each model the same real app request inside Taskade Genesis, then uses the finished app like a customer would: add records, change a setting, ask for one more feature. Each build earns a tier on four axes (Interface, Task, Memory, Adapt), rolled into a score out of 100.

The method has limits, and they belong next to the numbers. We ran 37 tests between July 30 and September 30, 2026, with one to three builds per model per test, so read the scores as directional, not precise. The requests are real app shapes, not a fixed public suite. And we sell a product that runs these models, so you have every reason to discount our grading. That is why every test, including every miss, is public.

Scores as of October 2026. Equal scores share a rank. Claude and Gemini run on your own API key in automations, and Claude also runs in custom agents on Enterprise.

The misses teach more than the scores. In our newest test, on September 30, several models built the same family intake form: parents fill it in on a phone and add two to four photos, and a teacher sees every family on one page. Some builds worked end to end. One build's public assistant told a visitor a child's name. One wrote no app page within the 15-minute test limit. A model can write a correct-looking app and still fail the one thing the person asking cared about. You only find that out by using the app.

What Bill Atkinson taught us

Bill Atkinson's HyperCard, released in 1987, let people who were not programmers build their own software. Teachers, doctors, and kids made stacks. It is the closest ancestor of what we build now, and when Atkinson died in June 2025 I reread what he had said about it.

In 2002 he told Wired: "I have realized over time that I missed the mark with HyperCard. I grew up in a box-centric culture at Apple. If I'd grown up in a network-centric culture, like Sun, HyperCard might have been the first Web browser." And then: "I thought everyone connected was a pipe dream. Boy, was I wrong." (Wired, 2002)

We started from the opposite end by accident. In 2016 our first goal was a tree that many people could edit at once, so the network came before everything else. Three lessons from Atkinson still shape how we work:

1. Let anyone build. If an app needs a developer to finish it, the tool has not done its job.
2. Put it on the network from day one. A stack on a floppy disk is a beautiful dead end. Software that lives in a shared workspace keeps working after you close the tab.
3. Sweat the details people touch every day. Andy Hertzfeld's story "Round Rects Are Everywhere!" tells how Steve Jobs walked Atkinson around the block, pointing out rounded rectangles on signs and windows, until Atkinson went back and made them draw fast on the original Macintosh. That story is why our benchmark opens every app and uses it, instead of reading a score.

Our longer HyperCard history covers the rest.

What we got wrong, and what is still open

Ten years is enough time to be wrong in public a few times. A partial list:

1. We shipped the easy half first, for a long time. Capture and structure, the "ideas to action" half, was solid by 2020. For most of the decade we could not do the other half.
2. We changed our story eleven times. Some of those headlines were right for their year. Some followed the vocabulary of the moment. The tree under them barely changed, and in hindsight the tree was the part worth talking about.
3. A better model was never the whole answer. The first agent loops of 2023 broke goals into subtasks and then wandered off. What has helped us since is less about any one model and more about two habits: keep every step on shared state that a person can open, and test results by using them.
4. Our records undercount our own early years. Our public changelog lists only landmark releases before 2023, so the early bars in the chart below are a floor.

What is still open, as of October 2026:

• Memory that gets measurably better with every run. Agents and automations share one memory today. Showing that the memory makes the next run better, with numbers, is not done.
• Longer work with less supervision. Scheduled and triggered work runs while you are away. Long, multi-step agent work still needs a person to check it.
• Honest measurement at scale. One to three builds per model per test is a start. It is not a benchmark anyone outside should rely on alone.

Ten years in numbers

We have published more than 690 release notes on our public changelog and sent more than 260 newsletters. The release pace jumped in 2023, when AI work turned weekly releases into the normal rhythm.

Counted from the public changelog through October 6, 2026. Before 2023 the changelog lists only landmark releases, so read the early bars as a floor.

The bottom of the cascade

Ten years ago, the bottom of our cascade was a person with a list. Today it is a person with a system that can do some of the walking. The person is still the point. You decide what matters, you approve what ships, and you check the work, because the system is still wrong often enough that checking matters.

The tree from 2016 is still there, under everything, at taskade.com. The benchmark, with every miss, is at taskade.com/tsk.

Dates and sources

For the full company profile, read What Is Taskade? The Complete History.

Frequently Asked Questions