The Product We Didn't Know We Were Building: How Taskade Became Taskade Genesis (2026)

Taskade joined Y Combinator in the summer of 2019 as a collaborative workspace.

Projects. Tasks. Outlines. Real-time collaboration.

We were not trying to build an AI operating system. We were not trying to build agents. We were not trying to generate apps from prompts. Most of those things barely existed yet.

We were trying to make work simpler.

Seven years later, I look at Taskade Genesis and see something I could not see at the time. We spent years thinking we were changing the product. We were actually assembling its primitives.

We thought we were building features. We were building pieces of a system.

TL;DR: Taskade did not plan Genesis in 2019. Four primitives changed one by one: projects became memory, AI became agents, workflows became execution, and the workspace became the interface. In 2025 they connected into Taskade Genesis, which has since powered 150,000+ apps built from a single prompt. This is how the pieces became one system. Build yours →

This is not another founder story. The personal chapters already exist: Build Without Permission is the manifesto, From Bronx Science to Taskade Genesis is the intellectual lineage, and From Web Hosting to AI Infrastructure is where the systems instinct came from. The full release-by-release record lives in the complete history of Taskade.

This essay is the missing chapter between them. It starts in 2019, not in childhood. And it asks one question: how does a product become something its builders never planned?

🧱 What Is the Difference Between a Feature and a Primitive?

A feature solves one visible problem at one moment. A primitive is a foundational building block that does one thing well and is designed to combine with other building blocks. Features are replaced when needs change. Primitives are recombined, so their value grows with every new connection. That distinction explains the entire Taskade story.

The clearest definition I know comes from Amazon. In the 2003 vision document for what became AWS, quoted by Andy Jassy in his 2023 letter to shareholders:

"Primitives are the raw parts or the most foundational-level building blocks for software developers. They're indivisible (if they can be functionally split into two they must) and they do one thing really well. They're meant to be used together rather than as solutions in and of themselves."

Jassy's letter also describes what happened next. When S3 launched in 2006, developers were "excited, and a bit mystified." Only after EC2 and SimpleDB arrived did people realize Amazon was building a set of pieces "that would allow them to build anything they could imagine." The meaning of the first primitive became clear only after the second and third existed.

Our fifty-year history of computing primitives traces this idea from the file to the task. The Unix pioneers said the same thing a generation earlier. Doug McIlroy's 1978 summary in the Bell System Technical Journal, now known as the Unix philosophy: "Write programs that do one thing and do it well. Write programs to work together."

The hard part is that a primitive usually looks like a feature when you ship it. Our outliner looked like an outliner. Our first AI command looked like a writing assistant. Our automation builder looked like a Zapier alternative. Nothing on the surface said "memory," "intelligence," or "execution." Those words came later, when the pieces started explaining each other.

🗓️ What Was Taskade When It Joined Y Combinator in 2019?

In 2019 Taskade was a real-time collaborative workspace: nested outlines, tasks, multiple project views, chat, and video calls in one place for remote teams. It joined Y Combinator's Summer 2019 batch and raised a $5M seed round on October 24, 2019. The software stored and displayed work. People did everything else.

The first commit in the Taskade codebase is dated September 2016. The beta was announced on December 5, 2017. Taskade 2.0 shipped on January 22, 2019, a few months before YC. By then the product had its shape: a tree of tasks that many people could edit at the same time, which could be shown as a list, a board, a table, or a mind map.

Look at where the intelligence lived in that picture. It lived entirely in the humans.

TASKADE, 2019
    HUMAN
      │
      ├── thinks      (what matters?)
      ├── decides     (what next?)
      ├── executes    (send it, update it, ship it)
      │
      ▼
  WORKSPACE
      │
      ├── Projects    (a tree of tasks)
      ├── Views       (list, board, table, mind map)
      ├── Chat        (talk about the work)
      └── Real time   (everyone sees the same tree)

The workspace remembered what humans put into it.
Humans still did almost everything else.


I want to be honest about 2019. We did not see a hidden AI roadmap in that outliner. We saw a better way for distributed teams to think together. The YC batch was about growth, sync speed, and templates. Nobody in that room said "agents."

But one decision from those years mattered more than we knew. We stored work as structure, not as pages. Every task was a node with a parent, children, an owner, a date, and a history. Structure is what machines read well. We did not know yet that a machine would soon be reading it.

🧬 How Did Taskade's Primitives Change Between 2019 and 2026?

Between 2019 and 2026, each of Taskade's original primitives changed its meaning. The project became memory. The AI command became an agent. The workflow became execution. The workspace became the backend, and the page became the app. The changes happened one at a time, over six years, and each one made sense on its own.

The important part is what this table does not say. It does not say we designed these five changes as one plan. Each row was a separate bet, made for a separate reason, usually because users pulled us there. Only when the last row landed did the earlier rows start to look like a sequence.

Here is the same story in real screenshots. Each frame was a product change we shipped for its own reasons. Read left to right, they look like one idea unfolding.

The next four sections take the primitives one at a time.

🌳 How Did Projects Become Memory?

Taskade projects became AI memory because they were always structured, persistent, and shared. A tree of tasks with owners, dates, comments, and history is exactly the kind of context a language model needs and cannot keep on its own. On December 12, 2022, when Taskade AI first read a project to help with it, the outline quietly became memory.

Start with the tree.

Project
 └── Task
      ├── Subtask
      │    └── Note, file, comment
      └── Subtask
           └── owner, due date, status, history

The outliner is an old idea. Doug Engelbart's 1962 report Augmenting Human Intellect set out to increase "the capability of a man to approach a complex problem situation," and his team's NLS system showed hierarchical outlines to the world in the 1968 "Mother of All Demos". Outliners have been with us ever since, as the best outliner apps show. We built ours for teams, in real time.

For years the tree organized human work. But persistent structured work has a second property that nobody talked about: it remembers. A project knows who asked for what, what was decided, what changed, and why. A chat window forgets all of that when you close it.

We later summed up that December 2022 moment in four words on our About page timeline: think in tasks, not prompts. The AI did not start from an empty text box. It started from your project. That one design choice carried through everything that followed.

Once the tree persists, it becomes memory. Once memory can be traversed, the past becomes useful computation.

That is the first lesson of this essay, and it is the one I would have paid the most to learn earlier. Why memory matters for agents is a longer argument. The short version: every model is smart and forgetful. The team that keeps the memory keeps the value.

🤖 How Did AI Become Agents Inside Taskade?

Taskade's AI became agents when it gained a role, persistent knowledge, tools, and a place to work. The first AI commands in early 2023 answered prompts and stopped. AI Agents launched in beta on May 29, 2023, custom agents followed on November 13, 2023, and multi-agent teams arrived in April 2024.

Early generative AI had a simple shape.

An agent has a different shape. It sits in a loop between memory, models, and tools, and its output changes the state of the world.

A chatbot ends when the answer appears. An agent becomes interesting when it has somewhere to work.

That sentence is the whole reason Taskade agents took the form they did. Many companies in 2023 had a model. Very few had a place where the model could work: structured data, files, people, history, and permissions, all in one shared space. We had that place already. It was the workspace we had been building since 2017.

If you want the concept in depth, read What Are AI Agents? and Chatbots Are Demos. Agents Are Execution.. The point for this essay is narrower. The agent primitive was only as good as the memory primitive under it. We did not have to build that memory for agents. We had been building it for people for six years.

⚡ How Did Workflows Become Execution?

Taskade workflows became execution when triggers and actions let work happen without a human click. The first automation work in our codebase, in 2022, connected Taskade to other tools through webhooks. The automation builder previewed in October 2023, entered beta in January 2024, and grew into automations that run across 100+ integrations.

AI can decide. Something still has to happen.

That gap between thinking and doing was the most important thing we learned in 2023. An agent that writes a perfect follow-up email and then waits for you to copy and paste it is a clever demo. An agent whose email is actually sent, logged in the CRM project, and scheduled for a reminder in three days is a system.

Intelligence without execution is a demo. Execution closes the loop.

The detail I find most interesting in hindsight is the last row. Our automations did not write their results to a log file somewhere. They wrote them back into projects, because projects were where everything already lived. That one habit turned execution into new memory. We did not call it a "loop" yet. It was simply the obvious place to put the output.

The Execution Layer makes the long version of this argument. Introducing Taskade AI Automation & Agents, published on January 29, 2024, put agents and automations in the same announcement for the first time. Reading it now, the two primitives are already reaching for each other.

🖥️ When Did the Interface Change, and Why Did Apps Come Last?

The interface changed last because it depended on everything else. Between July and October 2025, Taskade moved from a workspace you navigate to an app generated around the work. In July 2025 one prompt could generate workflows, agent teams, and subspaces. In August 2025 Taskade Genesis entered preview, and in October 2025 it launched.

For most of Taskade's life, the human had to learn where everything was.

BEFORE                                  TASKADE GENESIS
  Workspace                               Intent
│                                      │
▼                                      ▼
Human learns where                      Prompt
everything is                             │
│                                      ▼
▼                                    System (memory, agents, automations)
Human does the work                       │
▼
Interface generated
around the work

On June 22, 2025, I opened an internal issue with a plain working title: "Taskade App Generator." The next day I wrote the plan in one line: simplify each app into (1) knowledge, (2) AI agents, (3) automation. Three primitives we had already spent years building, with a new surface on top. The name Taskade Genesis came sixteen days later. The full 110-day journey is below.

Even the container was old. We introduced subspaces in February 2020 as folders with their own members and permissions, to help remote teams organize. Five years later, the same subspace became the unit of an app: one subspace, one app, with its own knowledge, agents, and automations inside. Another feature that turned out to be a primitive.

Bill Atkinson, the creator of HyperCard, died on June 5, 2025. A few weeks later, on July 1, I wrote in that issue: "HyperCard let you build your own tools using words. Taskade lets you build your own AI agents and apps using ideas." Projects were the cards. Agents were the scripts. Subspaces were the stacks. (Our history of HyperCard tells that story in full, and SaaS Has Quietly Evolved Into Living Software covers what it means for the software industry.)

Apps are not a fourth feature. They are the surface through which the other primitives become usable.

A later design note put the product principle in one line: every prompt to app must mean execution. A generated screen that is not wired to memory, intelligence, and execution is a mockup. We had spent six years making sure that, by the time the screen arrived, there was a working system behind it. The official definition of that architecture lives in the Taskade Genesis overview and Workspace DNA.

🗓️ What Happened in the 110 Days Between the First Issue and the Launch?

Taskade Genesis went from an internal issue to a public launch in 110 days: the issue opened on June 22, 2025, and the launch post shipped on October 10, 2025. Those 110 days did not create the primitives. They connected primitives that had taken eight years to build, and they fixed two tickets I had filed long before anyone said "Genesis."

I went back through that issue thread, the pull requests around it, and our release notes to rebuild the sequence. Here it is, with nothing smoothed over.

The line I wrote on June 28 is the thesis of this whole essay, six weeks before the product had a name:

"projects = knowledge for agents / projects = database for automation / agents = chatbots for web apps with context, knowledge / agents = logic and LLMs for automation, flows / automation = forms + mini-apps for data intake and processing / automation = what a button (CTA) can trigger on-click via web-app, and can be anything."

Read it again with the four primitives in mind. Every clause is one of the twelve connections in the matrix below. I did not know I was describing a system. I was writing notes.

Which old tickets did Taskade Genesis finally close?

Two of the tickets that made Taskade Genesis possible were ones I had filed myself, years earlier, as a frustrated user of my own product.

My note on the 2017 ticket was one line of customer pain: "New Space is not there, requires hard refresh." In August 2025 I described its fix differently: "this completes the real-time vision for taskade v1 + unlocks genesis apps." The same ticket, read eight years apart, meant two different things. In 2017 it was a collaboration bug. In 2025 it was the live data layer under every generated app.

The 2021 ticket had the same arc. When I finally opened the pull request for it, I called it "a big part of connecting the dots." I meant the dots inside a project editor. It turned out to mean the dots between every primitive we had.

What did we try and abandon on the way to Taskade Genesis?

Taskade Genesis looks inevitable in hindsight. It was not. These are the directions we explored in 2025 and left behind, and each one taught us which primitive we already had.

That last row matters to me. Some of the early work was so large that reviewers cut most of it down before anything merged. The version of Taskade Genesis that shipped is smaller than the one we first imagined, and it works because it is smaller. Every abandoned direction tried to build something new. Every direction that survived reused something we already had.

🔁 When Did the Pieces Become a System?

The pieces became a system in 2025, when every primitive could read from and write to every other primitive through the same workspace. For years Taskade had projects, agents, automations, and a workspace UI as separate features. Connected, they formed a loop: memory feeds intelligence, intelligence triggers execution, execution writes new memory, and the app serves all of it.

This is the center of the essay, so I want to slow down.

For years these looked like separate features. Connected, they became something else.

feature + feature + feature  ≠  system
primitive ⇄ primitive ⇄ primitive  =  system
The system emerges from the relationships, not from the parts.

Here is the simplest way I know to show why. With four primitives, there are twelve directed connections between them. Each connection is a way one part can use another. Every one of those twelve is a real behavior in a Taskade Genesis app today.

Now count what happened as we added primitives. The number of possible connections grows much faster than the number of parts, because it grows as n × (n − 1).

One primitive has zero connections. Two have two. Three have six. Four have twelve. That is why Taskade Genesis felt sudden from the outside and slow from the inside. Six years of adding parts produced a modest line. Adding the last part tripled the connections at once, because the new part touched every old one.

The Genesis Equation writes the same idea as multiplication rather than addition, and Workspace DNA architecture documents the loop in engineering detail. The founder version is simpler:

The breakthrough was not any one piece. It was connecting them.

🗄️ Why Did the Workspace Become the Backend?

The workspace became the backend because it already held everything a backend holds: data, logic, background jobs, integrations, permissions, and history. Instead of building a new backend for every app, Taskade Genesis points each generated app at the workspace. The app becomes a view into a living system that people and agents already share.

The traditional stack looks like this.

This is the flip that took me the longest to see. We always thought of the workspace as the destination: the place you go to do work. It turned out to be the engine: the place work happens, whether or not a person is looking at it.

When Taskade Genesis launched, we wrote it as a short line: your workspace becomes the backend, and your prompt becomes the app. It sounded like a slogan. It was really a description of six years of accidental backend engineering. The deeper thesis is in Software That Runs Itself.

⏳ How Did Seven Years Compress Into One Prompt?

Seven years of Taskade product architecture now sit behind the first prompt a user types. In 2019 a team had to assemble a workspace, create projects, and organize work by hand. In 2026 a person describes what they need, and Taskade Genesis assembles projects, agents, automations, and an app into a running system in minutes. More than 150,000 apps have been built this way.

2019                                       2026
assemble the workspace by hand             describe what you need
↓                                          ↓
create projects by hand                          GENESIS
↓                                          ↓
organize work by hand                  assembles Projects
↓                                    + Agents
do the work by hand                            + Automations
+ App
↓
running system

What took us years to assemble as a product can now be assembled for you in minutes.

That is the part I find most moving about this work. Every year of building did not disappear. It compressed. A new user never sees the 2019 sync engine or the 2023 agent roundtable, but both are inside the app they generate on their first day. You can see what people build with it in the Community Gallery.

🧪 Was Taskade Genesis Planned From the Start?

No. Taskade Genesis was not planned in 2017 or 2019. It emerged in 2025 from primitives the team built for other reasons. Strategy researchers call this an emergent strategy: in Mintzberg and Waters' 1985 definition, "patterns or consistencies realized despite, or in the absence of, intentions." The pattern was real. The plan came afterwards.

Founders are told to have a vision, and I believe in vision. But I have learned that vision works differently than the pitch deck version. In their 1985 paper Of Strategies, Deliberate and Emergent, Henry Mintzberg and James Waters wrote that deliberate and emergent strategies are "two ends of a continuum along which real-world strategies lie." Taskade sits much closer to the emergent end than our marketing ever admitted.

There is also a law about this. John Gall's 1975 book Systemantics gave us Gall's Law: "A complex system that works is invariably found to have evolved from a simple system that worked. A complex system designed from scratch never works and cannot be patched up to make it work." Taskade Genesis is a complex system. It works because every piece of it worked alone first.

How is converging different from pivoting?

A pivot throws the old product away. A convergence keeps it. That is the key difference between Taskade's path and the famous accidental-product stories.

This matters for users as much as for founders. Because we converged instead of pivoting, nobody lost their workspace. The team that joined Taskade in 2019 to share a meeting agenda still has that agenda. It just happens to be memory now, available to every agent and app they build.

🧠 Why Were AI Models the Catalyst but Not the Product?

Large language models were the catalyst for Taskade Genesis, but the model was never the whole product. A model supplies reasoning. A working system also needs context, memory, tools, permissions, data, execution, an interface, and persistence. Taskade had spent six years building those eight things for people. Models made them usable by software.

In 2017 Andrej Karpathy argued in Software 2.0 that neural networks "represent the beginning of a fundamental shift in how we develop software." In 2025 he went further and described large language models as a new kind of operating system. Both ideas point the same way. Models are becoming infrastructure.

Infrastructure alone does not ship outcomes. Gartner predicted in June 2025 that over 40% of agentic AI projects will be canceled by the end of 2027, citing escalating costs, unclear business value, and inadequate risk controls. Most of those projects will not fail because the model was weak. They will fail because the model had nowhere to work.

Look at the right-hand column. Only one row is as recent as 2025. The model arrived and found a system already waiting for it. That is also why Taskade works with 15+ frontier models from OpenAI, Anthropic, and open-weight providers instead of betting on one.

The model can be replaced. The accumulated system around it cannot. If you want the technical ladder behind that sentence, LLM → RAG → Agent → Agentic AI and the context engineering field guide walk through it.

🧩 How Does TSK-1 Organize the Pieces?

TSK-1, the Taskade System Kernel, is the layer that coordinates the primitives so the user does not have to. Launched on July 8, 2026, it picks a model for each task, connects the right memory, and runs agents and automations as one app. You describe what you want in plain language, and TSK-1 does the coordinating.

A kernel is the part of an operating system that quietly coordinates everything else. That is the right word for what the primitives needed once they were connected. Four primitives with twelve connections are powerful. They are also a lot of decisions: which model, which memory, which tool, which trigger. TSK-1 makes those decisions so a person can stay at the level of intent.

I will leave the details to the TSK-1 guide and the TSK-1 page. For this story, one point matters. TSK-1 is not a new primitive. It is the first thing we built that exists only because the primitives were already connected. It could not have existed in 2019, or 2023, or even 2024.

✏️ What Did Bill Atkinson Teach Us About Subtraction?

Bill Atkinson, who built QuickDraw, MacPaint, and HyperCard, is a patron saint of this story because he understood that simplicity comes after complexity, not before it. His most famous line of code was a negative number. Taskade Genesis applies the same idea to an interface: one prompt on top of years of hidden work.

The story is on Folklore.org. In February 1982, Apple's Lisa team began asking engineers to report how many lines of code they wrote each week. Atkinson had just rewritten QuickDraw's region engine with a simpler, more general algorithm that ran almost six times faster and removed about 2,000 lines. On the form, he wrote -2000. After a couple more weeks, they stopped asking him to fill it in.

Five years later, on August 11, 1987, Apple released HyperCard, which Atkinson described as a "software erector set." It let people who were not programmers build their own software out of cards and stacks. We have written about it in the history of HyperCard and Bill Atkinson's HyperCard legacy, and it is the direct ancestor of the Build Without Permission manifesto.

Simplification often happens after complexity. The final interface can be a single prompt precisely because years of complexity sit underneath it. You cannot start with the -2000. You have to write the 2,000 lines first.

📚 What Did Seven Years of Building Taskade Teach Me?

Building Taskade taught me that products are often discovered rather than designed. You build useful primitives, keep the ones that compound, and wait for their relationships to become obvious. Here are the five lessons I would give any founder building through a computing shift.

Lesson 1: You do not always discover the product from the top down. Sometimes you build useful primitives until their relationship becomes obvious. The discipline is not in predicting the destination. It is in building each piece well enough that it can survive a future you cannot see.

Lesson 2: Do not confuse a primitive with its current interface. Every primitive we shipped wore a disguise. The project wore an outline. The agent wore a chat window. The automation wore a flowchart. Ask what a thing is underneath the screen, because the screen will change and the primitive will not.

Lesson 3: Preserve what compounds. In every computing shift, there is pressure to rebuild from scratch. We resisted it. We kept the data model, the history, the real-time sync, and the habit of writing everything back into projects. Those are the things that compounded. Features did not compound. Structure did.

Lesson 4: Simplification comes after complexity. The one-prompt experience is the -2000. It was only possible because of everything we wrote first. Founders who try to start at the simple end usually ship a demo, which is Gall's Law in practice.

Lesson 5: Connections are worth more than parts. If I could go back to 2019, I would not tell myself to build Taskade Genesis. I would tell myself to make sure every new piece could read from and write to every old piece. That rule alone would have gotten us here faster.

🔮 What Comes After Software That Assembles Itself?

After software that assembles itself comes software that keeps running and improving on its own. Every era of Taskade added one capability to the system: first anyone could create, then software could understand, then it could act, then it could assemble itself. The next step is software that stays alive and gets better with every cycle of use.

I will not pretend to know the exact shape of the next five years. That would contradict everything this essay argues. What I know is the direction, and the direction has been steady since 2017: make work simpler, make software more useful, and keep connecting the pieces that belong together. The one-person company running on a living system is one version of where that leads. There will be others we cannot see yet.

The Product We Didn't Know We Were Building

We did not have a seven-year roadmap to Taskade Genesis. We had a direction: make work simpler, make software more useful, and keep connecting what belongs together. Then the pieces changed, one at a time, until they described a product we had never drawn on a whiteboard.

Projects became memory.
AI became agents.
Workflows became execution.
The workspace became the backend.
Apps became the interface.

The pieces became Taskade Genesis.

If someone finishes this essay, I hope they do not summarize it as a founder telling his story again. I hope they summarize it like this: Taskade spent seven years building what looked like separate features, until AI made it clear they were the memory, intelligence, execution, and interface of one system.

We thought we were building features.

We were building primitives.

The primitives became a system.

And now the system builds systems.

Sometimes the product only becomes obvious after you have built enough of the future to see it.

▲ ■ ● Memory, intelligence, execution.

The pieces are live now. Build your first system with Taskade Genesis →

— John Xie, CEO, Taskade

❓ Frequently Asked Questions

📖 Related Reading

The founder canon, in reading order

• Build Without Permission: The Taskade Genesis Manifesto: why we build
• From Bronx Science to Taskade Genesis: where the ideas came from
• From Web Hosting to AI Infrastructure: why systems must stay alive
• The Product We Didn't Know We Were Building: how the pieces converged (you are here)
• Software That Runs Itself: what Taskade Genesis is
• The Workspace Is the Runtime: what the pieces became
• The Genesis Equation: the architecture as a formula
• The Execution Layer: why the chatbot era is already over
• They Generate Code. We Generate Runtime: the workspace as the runtime
• Fifty Years of Computing Primitives: from the file to the task

The record

• What Is Taskade? The Complete History
• The Origin of Taskade Genesis
• The Origin of Living Software
• About Taskade

Build with the primitives

• AI App Builder: one prompt, one app
• AI Agents: agents that live in your workspace
• Automations: execution across 100+ integrations
• AI Workspace: the workspace as the backend
• Community Gallery: clone what others have built

📎 Sources

1. Andy Jassy, 2023 Letter to Shareholders, Amazon, quoting the 2003 AWS vision document on primitives.
2. M. D. McIlroy, E. N. Pinson, B. A. Tague, "Unix Time-Sharing System: Foreword," Bell System Technical Journal, 1978, via Unix philosophy.
3. Henry Mintzberg and James A. Waters, "Of Strategies, Deliberate and Emergent," Strategic Management Journal 6(3), 1985.
4. John Gall, Systemantics, 1975, via Gall's law.
5. Douglas Engelbart, Augmenting Human Intellect: A Conceptual Framework, Stanford Research Institute, 1962.
6. Andy Hertzfeld, "-2000 Lines Of Code," Folklore.org.
7. HyperCard, Wikipedia.
8. Andrej Karpathy, "Software 2.0," 2017.
9. Gartner, "Gartner Predicts Over 40% of Agentic AI Projects Will Be Canceled by End of 2027," June 25, 2025.
10. Wikipedia entries for Flickr, Twitter's history, Instagram, and Slack.
11. Taskade internal issue and pull-request history, June to October 2025, and the Taskade changelog entries for July 13, July 21, and August 7, 2025 (the author's own notes; teammates and internal names omitted).
12. Taskade release history: Taskade AI (Dec 2022), AI Agents beta (May 2023), Custom AI Agents (Nov 2023), Automation beta (Jan 2024), Multi-agent teams (Apr 2024), Taskade Genesis preview (Aug 2025), Taskade Genesis launch (Oct 2025), TSK-1 (Jul 2026).