Google Wave's Failure Is a Great Lesson for Modern Real-Time Collaboration (2026)

When Google Wave previewed at the 2009 I/O conference, it was a tool like no other. Not just the first unified workspace before the remote-work boom — it tried to solve many of the same problems we're still solving today. Fifteen months later, it was dead.

But the engine inside Wave never stopped running. The Operational Transformation algorithm that powered Wave's real-time editing went on to power Google Docs, Etherpad, ShareJS, and — through a direct lineage of code and people — Taskade Projects today.

This is the story of why Wave failed, why its substrate survived, and how Aaron Iba — the Etherpad co-founder who joined Google to work on Wave — became a Taskade angel investor and closed the loop.

TL;DR: Google Wave was 15 years early. The unified-workspace thesis was right; the rollout, onboarding, and timing were wrong. Wave's Operational Transformation engine lives on in Google Docs, Etherpad, and Taskade Projects — Taskade's Project editor is built on ot-json0, the open-source descendant of Wave's OT primitives. Aaron Iba (Etherpad co-founder, Google Wave engineer) is a Taskade angel. The lineage isn't a metaphor — it's a cap-table receipt. Try Taskade Genesis →

🌊 The Lineage in One Diagram

Before we walk through Wave's rise and fall, here's the lineage that holds the whole story together — the people, papers, and code that connect 1968's Mother of All Demos to today's AI-agent workspaces.

The dotted line from Etherpad to Taskade Genesis is the receipt: Aaron Iba, who co-founded Etherpad in 2008 and joined Google to work on Wave, is now a Taskade angel investor. One person carrying the same architectural conviction across three decades of collaborative software.

🌱 The History of Google Wave

Google Wave started with a single question: "What would email look like if it were invented today?" That question gave rise to one of the most ambitious real-time collaboration tools ever shipped.

Let's see how Wave's development unfolded — from its inception under the codename "Walkabout" to the eventual shutdown in April 2012 and open-source retirement in 2018.

2006–2008: Inception to Product Release

Wave's story started in October 2004 when Google bought a mapping startup called Where 2 Tech. That acquisition came bundled with a fledgling technology that would eventually become commuters' favorite — Google Maps.

The responsibility for the new project was given to brothers Lars and Jens Rasmussen who became its lead developers. As they worked toward an initial Maps release, the brothers started to think about what might be next for them at Google.

The idea to focus on communication came from Jens who noticed a significant shift in the way people interacted online. The consensus between the brothers was that they should build a platform that would reflect those changes in its functionality.

When the Maps project was completed, Lars and Jens moved on to develop a product dubbed "Walkabout." Their ultimate goal was to answer a number of questions about how people communicated online:

• 💬 Why are there divisions between email, chat, and document-based communication?
• ⚖️ Is there a way to create a single communication channel that spans all or most of these systems seamlessly?
• ⚙️ Is there a way to make that type of communication simple?
• 🖥 How do we design a platform that takes advantage of the current computers' capabilities?

From there, the Rasmussen brothers assembled a tiger team of developers to execute on this idea. After several months, they came up with a prototype which, over the next few years, evolved into a product release.

They called it Google Wave.

2009–2010: The I/O Preview

In May 2009, Lars, Jens, and product manager Stephanie Hammond previewed Wave at Google's I/O conference. In one fell swoop, Walkabout officially became a product, a platform, and a protocol for real-time communication via a process called waves.

Here's how Google's official blog release described Wave:

"In Google Wave you create a wave and add people to it. Everyone on your wave can use richly formatted text, photos, gadgets, and even feeds from other sources on the web. They can insert a reply or edit the wave directly. It's concurrent rich-text editing, where you see on your screen nearly instantly what your fellow collaborators are typing in your wave. That means Google Wave is just as well suited for quick messages as for persistent content — it allows for both collaboration and communication. You can also use 'playback' to rewind the wave and see how it evolved."

— Wave's announcement blog

The keynote was a 90-minute live demo built around a hypothetical sailing trip — Lars, Jens, and Stephanie walking the audience through planning a boat trip, live updates, contextual threading, and image sharing.

While there were a few hiccups, Lars and Jens attributed them to Wave being in developer preview. The initial reception was overwhelmingly positive — Wave became Twitter's top-trending technology topic of 2009.

Wave's Active Testing

With a preview account, each developer would gain access to Google Wave's API — another significant aspect of the release. At that point, the platform was still an open-source project in Lars's mind. Using the API would give users the ability to connect Wave to existing web applications and create individual integrations.

As it turned out, inviting developers to active testing was risky — and became the first misstep in Wave's rollout plan. The approximately 5,000 attendees at Google I/O were about to become the first "outsiders" to use Wave and spot some of its headaches.

The First Wave of Problems

By July 2009, Google had rolled out approximately 6,000 developer accounts and was processing an additional 20,000 requests. Wave gained traction on forums, Twitter, and other social media.

People were scrambling to access the platform but Google was holding back. The company would only send out single-person invites, effectively undercutting Wave's purpose for team collaboration.

While Google wanted to play smart and not pressure a brand-new platform with an influx of users, gating invites also meant the company couldn't capitalize on the buzz surrounding their product. When Google finally decided to open up Wave and allow 100,000 new users in September 2009, there were only 27,000 active developer accounts using Wave's API — nowhere near Lars's optimistic predictions:

"Millions of people wanted to try out the invitation-only preview we were launching later in the year. Wave became Twitter's top trending technology topic of 2009. It was quite a bit more attention — some would call it hype — than we had expected."

— Lars Rasmussen via Huffington Post

Once new users gained access to the platform, the enthusiasm waned and was quickly replaced by confusion:

"Twitter filled with 'Got Google Wave — now what?' memes. Worse yet: early, enthusiastic users slowly trickled out as their friends weren't quite up for using Wave, yet. Awe of our demo was quickly replaced by predictions of certain failure."

Much of the dissatisfaction happened because group conversations in Wave weren't as easy to pull off as users would have liked. Oddly enough, teams still weren't the target audience of Google's new product.

Groups, Restore, and Other Updates

The long-awaited support for Groups was added to Wave in December 2009 — seven months after the platform had been publicly announced. In January 2010, Groups were followed with two other features that allowed users to add read-only participants and restore an existing wave from a previous version (version history).

In March 2010, Google introduced notifications. In May 2010, after a full year of closed user testing, Google released Wave to the public as part of Google Labs:

"Since starting our invitation-only preview about half a year ago, we have significantly improved Wave's speed, stability and ease of use. And I believe that, in the lingo of Gartner's Hype Curve, Google Wave has reached the foothills of the 'Slope of Enlightenment.'"

— Lars Rasmussen

It wasn't enough. August 2010, Google announced they would cease active development.

⚙️ Wave's Real Achievement: The Operational Transformation Engine

The reason Wave matters to anyone building real-time software today isn't the product. It's the substrate. Wave shipped the most ambitious production Operational Transformation engine the industry had seen — and then open-sourced its DNA.

What Operational Transformation Actually Does

Two people typing in the same document at the same time looks effortless. To the computer it's a distributed-systems nightmare. The canonical failure is the index-shift problem:

Document is "cat". Alice and Bob both see it.
Alice: insert "h" at index 1   → expects "chat"
Bob:   insert "s" at index 3   → expects "cats"
Apply Alice first → "chat", indices shift right by 1.
Bob's "insert s at index 3" now lands BEFORE the 't'.
Result: "chast"   ✗

Both operations were valid against the snapshot each user saw. The document changed underneath one of them. With deletes it gets worse — the index might no longer exist and the program crashes.

OT solves this by transforming every incoming operation against the operations already applied locally, so its indices stay correct against the now-current state:

The server is the linearizer. Every client sends operations, the server orders them globally, transforms each one against the operations it has already ordered, and broadcasts the canonical sequence back out. Every replica converges on the same final state.

Wave's OT Contribution

Operational Transformation wasn't invented at Google. The technique was published by C.A. Ellis and S.J. Gibbs in 1989, refined into the Jupiter system at Xerox PARC in 1995 (a paper by David Nichols et al. that every collaborative-editor engineer eventually reads), and used by countless smaller experiments through the 2000s.

What Wave contributed was three concrete advances:

1. OT on XML-style document trees, not just text. Wave's documents were rich — bold spans, embedded gadgets, threaded replies, image insertions. Wave's OT engine could transform operations across all of these uniformly.
2. The Wave Federation Protocol. Wave attempted to run OT across servers, so a wave on google.com could include collaborators on wave.example.com. This is the part history mostly forgot — but the federation idea echoes today in Matrix, ActivityPub, and AT Protocol.
3. A production-grade open-source distillation. When Wave's engineers later left Google, they extracted the operational primitives into open source. The most consequential was ot-json0 by Joseph Gentle, a Wave engineer who went on to build ShareJS and ShareDB — the libraries every "use OT in your own app" stack today is built on.

Why this matters for Taskade. The Taskade Project editor — the substrate of every list, board, mind map, table, Gantt, and Org Chart you can build in the workspace — is built on ot-json0 with custom rich-text and plain-text subtypes registered on top. Wave's open-source descendant is literally the engine that keeps multiple humans and AI agents typing into the same Taskade Project from corrupting each other's edits. See our deep-dive on OT vs CRDTs for the engineering trade-off.

👤 The Aaron Iba Lineage: Etherpad → Wave → Taskade

The history of real-time collaboration runs through a small number of people who carried the same conviction across companies. Aaron Iba is one of those people.

Iba co-founded Etherpad in 2008 with David Greenspan and J.D. Zamfirescu, under the company name AppJet. Etherpad was the first mainstream real-time collaborative document editor — character-by-character live editing in the browser, predating Google Docs collaborative editing as the public knew it. It launched on November 19, 2008, and was an immediate hit with developers, journalists, and Wikipedia editors.

In December 2009, Google acquired AppJet. Iba and his co-founders joined Google specifically to work on Google Wave. Etherpad was scheduled for shutdown, but a community backlash convinced Google to open-source the code under the Apache 2.0 license — birthing Etherpad Lite (now just "Etherpad"), which is still actively developed and runs on thousands of self-hosted instances today.

After Wave was wound down, the Etherpad/Wave engineers diffused throughout the industry:

• Joseph Gentle built ShareJS / ot-json0, now the de-facto JSON OT engine
• David Greenspan went on to build Meteor
• Aaron Iba angel-invested in early-stage workspace and collaboration startups — including Taskade

Taskade's Project editor is built on ot-json0. The same engine Joseph Gentle extracted from Wave. The same lineage Aaron Iba carried from Etherpad to Wave. Same architectural conviction, three companies, one cap table.

💀 2012–2018: Scuttling and a Slow Death in Open Source

Over the next two years, Google Wave was pretty much tucked under the carpet. But that didn't stop some people online from discussing the vision of the product as well as its user experience woes.

This interest flickered until January 2012 when Wave was permanently moved to a read-only phase. Users could still export existing waves, but the core technology was no longer supported.

In April 2012, Google completely shut down Wave's servers. The only remnants of the platform were Apache Wave and an experimental, open-source variant of Wave called Walkaround.

Although Wave was pretty much dead by that point, the Apache Software Foundation still managed its offshoot of the product. However, having seen little investment from the open-source community, it too was officially retired in January 2018.

The product died. The protocol died. The OT engine — and its open-source descendants — never stopped running.

🤔 So Why Did Google Wave Really Fail?

With the full weight of Google behind it, why aren't we all using Wave today? Looking back, four root causes:

1️⃣ Wave Was (Way) Ahead of Its Time

Google was trying to solve problems the market didn't fully understand at the time. Email + chat + wiki + social inside a single live document was a 2024-era idea launched into a 2009-era market.

2️⃣ It Lacked Direction and Faced Positioning Problems

The development team didn't really know what Wave should become and who it was for. Even Lars Rasmussen admitted later that the team was "still sandboxing a large part of the platform's functionality" a full year after public launch.

3️⃣ It Had an Unfortunate Launch

The premature release made it impossible for Google to capitalize on the buzz surrounding their product from day one. The invite-only system fragmented Wave's network effect just as group features (which arrived seven months late) needed it most.

4️⃣ Performance Killed the Magic

Every keystroke replicating through OT across federated servers on 2009-era home internet made Wave feel slow at the moments when collaborative editing needed to feel instant. The substrate was sound; the substrate wasn't yet fast enough at scale.

✅ What Wave Got Right (That ChatGPT and Taskade Genesis Vindicate)

Most retrospectives focus on what Wave got wrong. Let's invert it: what did Wave get right that the market took 15 years to catch up on?

Read that table again. The Wave thesis wasn't wrong. The execution and timing were. Every single column on the left has a real product on the right today — and most of them are built on Wave's OT lineage.

🧬 How Taskade Genesis Became Wave's Heir

The clearest demonstration that Wave was right comes from comparing what Wave wanted to be with what Taskade Genesis actually is in 2026.

Genesis Capability Map — From the May 2026 Newsletters

The full surface area of Taskade Genesis was rolled out in chapters across the recent Taskade newsletters. Six surfaces, every one of them a thing Wave wanted to ship:

Plus the five vibe surfaces — Vibe Coding (apps from prompts), Vibe Payments (Stripe-powered flows), Vibe Workflows (forms-to-automation), Vibe Marketing (content engines), Vibe Tracking (lead sync) — and MCP both sides (Taskade-as-Server for Claude / Cursor / VS Code, Taskade-as-Client for external Notion / Linear / Salesforce). MIT Technology Review named vibe coding a "breakthrough technology of 2026."

Head-to-Head: Wave's Unfinished Bets vs Today's Workspace Platforms

Wave previewed seven big ideas in 2009. Fifteen years later, five major platforms each picked up a fragment. Only one carries the full surface — and the OT lineage to back it:

Wave imagined this whole row. Taskade Genesis is the only column that ships all seven — and the only one whose substrate is a direct open-source descendant of the Wave OT engine, with the Wave engineer who built Etherpad on the cap table.

Wave's Core Pillars vs. Taskade's Workspace DNA

Taskade calls this loop Workspace DNA: Memory (Projects) feeds Intelligence (Agents), Intelligence triggers Execution (Automations + Genesis Apps), Execution writes back to Memory. Wave imagined the same loop — robots + gadgets editing waves — but couldn't ship it because the AI half didn't exist yet.

The Autonomous Workspace

Wave's "robots" were Java-based server agents that responded to wave events. They were technically impressive and almost no one used them — the cost-benefit on hand-coding a bot for a Java server in 2009 was upside-down.

Today's Taskade AI Agents are a 2026-grade version of the same idea:

• 34 built-in tools — web search, file editing, image generation, slash commands, web fetch, project read/write, agent-to-agent, MCP tool-calling
• Persistent memory — agents remember context across sessions, train on your projects, accumulate expertise
• Custom tools via MCP — every Taskade agent can call external Model Context Protocol servers (Notion, Linear, Salesforce, your own internal tools)
• Multi-agent collaboration — agents can hand off to other agents; the OT substrate makes "team of agents editing the same workspace" architecturally trivial
• Public embedding — agents ship as embeddable widgets on any site

Where Wave needed a Java developer to build a robot, Taskade Agents take a one-sentence description and self-build. EVE — Taskade's meta-agent ("Entity of Vision & Execution") — reads your entire workspace DNA (projects, agents, automations, files) and orchestrates the work.

Real-Time Workspace Workflows

Wave's other ambition was making automation native to the workspace. The Wave API let third parties write to waves; the Wave Federation Protocol let waves cross servers. But there was no high-level workflow language — every integration was hand-coded.

Taskade Automations closes that gap with 100+ bidirectional integrations:

• Triggers pull events in — Slack messages, Gmail emails, Sheets row added, Calendly events, Stripe checkouts, GitHub PRs, Webhooks, RSS, Telegram, Linear, Monday, Airtable, Shopify orders, Salesforce updates
• Actions push data out — Notion syncs, Salesforce updates, Slack posts, Stripe checkout sessions, GitHub PR creation, Calendar event creation
• Conditional branching, loops, filters, AI-powered transformations — built on Temporal-style durable execution so workflows automatically retry, guarantee delivery, and never silently fail
• Vibe-coded — describe the workflow ("when a Stripe payment lands, create a Notion page and Slack the team"), Genesis builds it

This is what Wave's "gadgets + robots + federation" was reaching for in 2009. The market wasn't ready then. It is now.

Genesis Apps: One Prompt, One App

Wave's most demoable feature was the "embedded gadget" — a live map, a poll, a chess game inside a wave. The friction was that every gadget had to be hand-built by a developer.

Taskade Genesis compresses that to a sentence:

150,000+ apps built since launch. Three million automations executed. The same vision Wave previewed in 2009 — only the substrate is finally fast enough, and the AI half exists.

Taskade Today, In Wave's Words

If Lars Rasmussen had described Wave in May 2009 the way Taskade describes Genesis in 2026, the demo might have landed differently:

In Taskade, you describe what you want and one prompt connects everything into a running system. Your projects become memory, your AI agents become intelligence, your automations become execution. They form a living loop — memory feeds intelligence, intelligence triggers execution, execution writes back to memory. 100+ integrations on call. Frontier models from OpenAI, Anthropic, and Google auto-routed. Apps you can clone in 60 seconds, embed anywhere, charge with Stripe. Workspace DNA. Your workspace, alive.

Same conviction. Better tools.

📚 What We Can Learn from the Wave Story

There were several factors that contributed to Wave's eventual demise — each a valuable lesson for SaaS builders today:

Lesson 1 — Positioning Is Everything

The key takeaway: positioning is everything. We live in a world of choice. If you're building a product and don't understand the specific value it provides to end users, you're setting yourself up for failure.

Lesson 2 — Ship One Use Case Before Unifying Categories

Wave tried to be email + chat + wiki + social all at once. Taskade started as a focused real-time outliner in 2017 and earned the right to add views, agents, automations, and Genesis over six years. Surface follows substrate, not the other way around.

Lesson 3 — Onboarding Is the Product

Wave's empty-wave-first experience killed retention. Taskade Genesis inverts this — you describe what you want, and there's a working app in seven minutes. The blank-canvas problem is a design problem.

Lesson 4 — Substrate Survives, Surface Dies

Products fail. Substrates compound. Wave the product is dead. Wave the OT engine is alive in every collaborative editor including Taskade Projects. Build something true at the bottom of the stack and it lives forever, even if your storefront doesn't.

Lesson 5 — Be Patient with the Right Idea

The Wave thesis wasn't wrong — it was 15 years early. If you're building something the market doesn't understand yet, you have two choices: either find a way to ship a focused wedge that earns the right to keep going (Taskade's path), or accept that you're laying foundation other people will build on (Wave's path).

📈 Understanding Failure Helps You Grow

Google Wave was one of the first attempts at real-time collaboration. It had the potential to take the market by storm, but it didn't. Observing how the platform went from "promising" to "disappointing" shows that building successful tools boils down to a few essentials:

1. Know WHAT you want your product to be
2. Find out WHO your users are and tap them for feedback
3. Figure out WHEN it's the best time to launch
4. Get the SUBSTRATE right — the engine outlives the product

When you get that right, you'll attract users who truly understand how your product can help them get things done. The Wave team got the substrate right and the timing wrong. Taskade — building on Wave's substrate — is shipping the product Wave wanted to be, fifteen years later, into a market that finally understands the question.

The inspiration for this article came from our YC interview with Paul Buchheit, the mastermind behind Gmail and partner at Y Combinator. Updated in 2026 with the OT internals, the Aaron Iba lineage, and the Taskade Genesis connection.

— Team Taskade 🐑

🔗 Further Reading

• The History of Real-Time Collaboration: From Engelbart to AI Agents — the full lineage, from NLS in 1968 to today
• OT vs CRDT: The Two Algorithms Behind Every Real-Time App — engineering deep-dive into the two families
• The History of Etherpad: Aaron Iba's Editor That Shaped the Modern Web — the pre-Wave story
• What Is Taskade — Complete History — the workspace platform built on Wave's OT lineage
• History of Mermaid.js: Diagrams as Code — sister piece on developer tooling lineage
• History of Computing: From Binary to AI Agents — the hardware-side parallel story

❓ Frequently Asked Questions About Google Wave