# History of Etherpad: How Aaron Iba's Open-Source Editor Shaped the Modern Web (2026)

> The complete history of Etherpad, from Aaron Iba's MIT bet through the Google acquisition, the Wave team, the open-source resurrection, and the lineage that runs through ShareJS to Taskade Projects today. With Aaron Iba on the Taskade cap table.

- Source: https://www.taskade.com/blog/etherpad-history
- Published: 2026-05-09
- Updated: 2026-05-11
- Author: Taskade Team

In 2007, three engineers in their twenties left Google's Search Quality team to start a JavaScript developer-tooling company in Boston called **AppJet**. As a Friday-afternoon demo for their server-side JS runtime, they built **a collaborative pad in the browser**.

Eighteen months later, that pad, **Etherpad**, was being used by Wikipedia editors, NPR newsrooms, Mozilla engineers, and student study groups. Two weeks before Christmas 2009, Google bought the company. The three engineers moved to Sydney to work on Google Wave. The Wave team's OT engine absorbed Etherpad's tricks. Then Wave failed, the team scattered, and one of those engineers, **Aaron Iba**, eventually showed up as an angel investor in [Taskade](https://www.taskade.com), the AI workspace platform whose Project editor runs on `ot-json0`, the open-source descendant of the Wave OT engine.

This is the story of how a Friday demo became the editor that taught Google how to collaborate, and how its OT lineage runs all the way to AI-agent workspaces today.

> **TL;DR:** Etherpad launched November 19, 2008 as the first character-by-character real-time browser editor. Google acquired its parent AppJet in December 2009 for the Wave team. After Wave shut down, Joseph Gentle extracted the OT primitives as open-source ShareJS / ot-json0, what Taskade Projects runs on today. Aaron Iba (Etherpad co-founder, ex-Wave engineer) is a Taskade angel investor. The lineage isn't a metaphor; it's a cap-table receipt. [Try Taskade Genesis →](https://www.taskade.com/create)

---

## 🌐 Etherpad in One Diagram

```mermaid
graph TD
    subgraph era1["2005–2008: The MIT-Google-AppJet Years"]
        A["2005<br/>Aaron Iba graduates MIT<br/>BSc Mathematics"] --> B["2005-2007<br/>Iba + Zamfirescu<br/>Google Search Quality"]
        B --> C["2007<br/>AppJet founded<br/>Iba · Greenspan · Zamfirescu"]
    end
    subgraph era2["2008–2009: Etherpad Ships"]
        C --> D["Nov 19 2008<br/>Etherpad launches<br/>~15s lag killed by 0s lag"]
        D --> E["2009<br/>Wikipedia editors<br/>Mozilla · NPR adoption"]
    end
    subgraph era3["Dec 2009: The Google Deal"]
        E --> F["Dec 4 2009<br/>Google acquires AppJet<br/>'low eight figures'"]
        F --> G["Dec 17 2009<br/>Etherpad open-sourced<br/>Apache 2.0"]
        G --> H["Iba + Greenspan + Zamfirescu<br/>join Google Wave · Sydney"]
    end
    subgraph era4["2010–2014: The Diaspora"]
        H --> I["Aug 4 2010<br/>Google Wave killed"]
        I --> J["2011<br/>Joseph Gentle extracts<br/>ShareJS / ot-json0"]
        J --> K["2011-2014<br/>Peter Martischka<br/>Etherpad Lite Node.js rewrite"]
        I --> L["2011<br/>Iba joins YC<br/>as full-time partner"]
    end
    subgraph era5["2017–2025: The Lineage Closes"]
        K --> M["2017<br/>Taskade founded<br/>Project editor on ot-json0"]
        L --> N["2013+<br/>PayGarden · Matrix Ops<br/>angel investing"]
        M --> O["2025<br/>Taskade Genesis launches<br/>AI agents on OT wire"]
        N -.angel investor.-> O
    end
    style D fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:2px
    style F fill:#1a140a,color:#ffb74d,stroke:#e65100,stroke-width:2px
    style G fill:#2a1225,color:#ff8fa3,stroke:#ff2d60
    style I fill:#1a0d0d,color:#ef9a9a,stroke:#b71c1c
    style J fill:#2a1225,color:#ff8fa3,stroke:#ff2d60
    style M fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
    style O fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
    style era1 fill:#0a1a14,stroke:#1b3d2a
    style era2 fill:#0a1420,stroke:#1a2a45
    style era3 fill:#1a140a,stroke:#3a2a1a
    style era4 fill:#1a0d24,stroke:#3a1d4a
    style era5 fill:#0a1a14,stroke:#1b3d2a
```

Twenty years, four founders, one OT engine, and a cap-table receipt. Let's walk it.

---

## 📝 What Is Etherpad?

Etherpad is an open-source real-time collaborative text editor. You open a URL, share the link, and anyone with the link can edit the document at the same time, every keystroke appearing on every screen in roughly the time light travels through the cable.

Today the project lives at [github.com/ether/etherpad-lite](https://github.com/ether/etherpad-lite). Key facts:

| Fact | Value |
|------|-------|
| First public launch | **November 19, 2008** |
| Original parent company | AppJet (Boston) |
| Original founders | Aaron Iba, David Greenspan, J.D. Zamfirescu |
| Open-source license | Apache 2.0 (since December 17, 2009) |
| Current canonical project | Etherpad (formerly Etherpad Lite) |
| GitHub stars | ~18,300 |
| Community plugins | 290+ |
| Production users | Wikimedia, Mozilla, European Commission, universities, newsrooms |
| OT engine | Easysync / Changeset library |
| Steward | Etherpad Foundation |

Etherpad's contribution to computing history is not size or commercial success. It's the **first time the open web saw character-by-character real-time editing actually work**.

---

## 🎓 2005–2007: The MIT → Google → AppJet Path

**Aaron Iba** graduated from MIT in 2005 with a Bachelor of Science in Mathematics. After graduation he joined **Google's Search Quality team** in Mountain View, working on the ranking algorithms that decide which results show up when you search. Search Quality was, and still is, a magnet for people who like solving hard signals problems at large scale.

**J.D. Zamfirescu** followed a similar path: MIT, then Google Search Quality. **David Greenspan** had been at MIT around the same window.

In 2006, the three of them watched Google Docs ship its collaborative editing, and noticed something. The Google Docs collaborative engine of 2006-2007 was *slow*. Edits took around fifteen seconds to propagate between collaborators. For two people writing a document together that was usable; for ten people trying to brainstorm on the same outline it was painful.

The Iba/Greenspan/Zamfirescu insight was simple: **what if it was instant?**

In 2007 they left Google and founded **AppJet** in Cambridge, Massachusetts. The pitch was an alternative to Google App Engine, server-side JavaScript hosting for developers, with a built-in editor for writing JavaScript apps in the browser. AppJet would never quite achieve traction on its own. But as a side project, the founders built a multiplayer collaborative pad using AppJet's runtime to demonstrate the platform.

The pad ate the parent company.

---

## 🚀 November 19, 2008: Etherpad Goes Live

Etherpad launched publicly on **November 19, 2008**. The initial demo was simple: open `etherpad.com`, create a pad, share the URL, and any number of people could type into the document at the same time. Each user got a colored cursor and their text appeared in their assigned color so everyone could tell who wrote what.

```
     etherpad.com/abc-2008-launch
     ┌──────────────────────────────────────────┐
     │ ▍ alice   ▍ bob    ▍ carol               │
     │                                          │
     │ Welcome to Etherpad. ▍                   │
     │ Try typing here at the                   │
     │ same time as the other ▍ users.          │
     │                                          │
     │ Every keystroke arrives ▍                │
     │ as fast as the network                   │
     │ can carry it.                            │
     └──────────────────────────────────────────┘
        Three colored cursors. One document.
```

Three things made Etherpad land:

### 1. The latency was right

Google Docs collaborative editing in 2008 had a noticeable lag, Etherpad felt **instant**. The pad's central server linearized every changeset and broadcast it to all clients via long-poll HTTP (WebSockets didn't exist yet); the round-trip was tens of milliseconds. Typing into a shared Etherpad felt like typing into your local editor while someone read over your shoulder.

### 2. The URL was the share button

You created a pad, copied the URL, sent it. No accounts. No invitations. No permission dialogs. Anyone who clicked the link was in. That permissionless model fit the open web of the late 2000s perfectly and made viral propagation trivial.

### 3. The "Time Slider"

Etherpad shipped one feature Google Docs wouldn't ship for years: a **time slider** that let you scrub through the document's edit history. You could replay how a meeting transcript was written, character by character, in whatever order it happened. It was an extraordinary debugging tool for collaborative work and the most-screenshotted feature of the product.

Within months Etherpad had:

- **Wikipedia editors** drafting articles in pads before pasting them in
- **NPR newsrooms** doing live coverage and editorial briefings
- **Mozilla engineers** running team standup notes
- **University study groups** working through problem sets
- **Conference organizers** running collaborative agendas

The product had hit nerve-endings.

---

## ⚙️ How Etherpad Actually Worked: The Easysync Engine

```mermaid
sequenceDiagram
    actor U1 as User A
    actor U2 as User B
    participant C1 as Client A (browser)
    participant S as Etherpad server
    participant C2 as Client B (browser)
    U1->>C1: types "h"
    C1->>C1: build changeset:<br/>Z:0>1 |0 +1 $h
    C1->>S: send changeset @ rev 0
    S->>S: stamp rev 1, apply
    par broadcast
        S->>C2: changeset @ rev 1
    and ack
        S-->>C1: ack rev 1
    end
    Note over U2,C2: User B was typing "i" concurrently at rev 0
    U2->>C2: typed "i"
    C2->>S: send changeset @ rev 0 (stale)
    S->>S: transform against rev 1 → adjusted at rev 2
    S->>C1: changeset @ rev 2
    S-->>C2: ack rev 2 with rewritten op
    Note over C1,C2: Both clients converge on the same text<br/>without locking. This is Easysync.
```

Etherpad's OT engine, called **Easysync** internally (and sometimes the **Changeset library**), is one of the canonical references in the collaborative-editing literature. The Easysync Technical Manual in the Etherpad docs is still recommended reading for anyone implementing a text OT engine.

The model:

```
A pad is a string with attributes.
A changeset is a delta: (old_length → new_length, ops, char_bank).
Three operators:

    =N              retain N characters (no change)
    -N              delete N characters
    +N              insert N characters (drawn from char_bank)

Each op carries an attribute spec.
Attributes are interned in an attribute pool keyed by short IDs.
```

A typical Etherpad changeset for inserting `"H"` at index 1 with author "alice" into the document `"cat"` would look something like:

```
Z:3>1|0=1*0+1$H
```

Decoded:
- `Z:3>1`, changeset header: source length 3, increases by 1
- `|0`, no line-attribute changes
- `=1`, retain 1 character
- `*0`, apply attribute pool entry 0 (which references `author:alice`)
- `+1`, insert 1 character
- `$H`, the character bank: the letter `H`

When two clients submit concurrent changesets, the Etherpad server:

1. Linearizes the order (whichever it received first wins the local order)
2. **Follows** (transforms) the later changeset against the earlier one so indices stay correct
3. Composes both into the canonical document state
4. Broadcasts both transformed changesets to all participants

This is OT, central-server, TP1-compliant, rich-text-via-attribute-pool. The full transformation rules for `compose`, `follow`, and `unpack` are spelled out in the canonical Easysync paper that ships with the Etherpad source code. It's the kind of document that takes a careful reader an afternoon to internalize and a lifetime to forget.

Joseph Gentle would later extract these primitives into open source as **ShareJS** and the **ot-json0** type. Today's `ot-json0` traces its operational genetics through ShareJS, through the Wave OT engine, through Easysync, into Taskade Projects.

---

## 📰 The Press Wave (2008–2009)

The 2008-2009 press cycle for Etherpad reads like a primer on how a developer-tools cult builds a category.

**TechCrunch, December 2008**, *"Etherpad: Real-Time Collaborative Editing That Doesn't Suck."* The post called out the contrast with Google Docs' lag and predicted Google would either buy or copy.

**LWN, early 2009**, extended write-ups on the Easysync engine and the implications for open-source documentation infrastructure.

**TidBITS, Hacker News, Slashdot**, community-driven amplification. Etherpad threads regularly hit Hacker News' front page through 2009.

**Wikipedia community, mid-2009**, the Wikipedia Foundation began running a self-hosted Etherpad instance (still live today at `etherpad.wikimedia.org`) for collaborative article drafting. Wikipedia's adoption was the most consequential. It told the open-source world that Etherpad was production-grade.

By summer 2009, the pad service handled tens of thousands of pads per day. AppJet's other products (the original developer-tools play) were essentially abandoned. **The pad was the company.**

---

## 💼 December 4, 2009: The Google Acquisition

```mermaid
sequenceDiagram
    actor Iba as Aaron Iba
    actor Greenspan as David Greenspan
    actor Zamfirescu as JD Zamfirescu
    participant AppJet
    participant Google
    participant Wave as Google Wave team
    Note over AppJet: Etherpad has ~tens of thousands<br/>of daily users. AppJet's core<br/>products are abandoned.
    Google->>AppJet: Nov 2009 — acquisition talks
    Google->>AppJet: Dec 4 2009 — deal announced<br/>("low eight figures", < $20M)
    AppJet->>Wave: Iba + Greenspan + Zamfirescu join Sydney team
    Note over Wave: Google Wave is launching;<br/>OT engine needs production scale.
    Wave->>Wave: Absorb Easysync know-how<br/>into Wave OT engine
```

On **December 4, 2009**, TechCrunch broke the news: Google was acquiring AppJet. The deal was reported in the "low eight figures", by all accounts under $20 million. Other coverage at GigaOM and the Wall Street Journal confirmed the rumor within hours.

What Google wanted:

- The Etherpad team, specifically Iba, Greenspan, and Zamfirescu, for the **Google Wave** project, which was struggling to scale its OT engine for public launch
- The Easysync rich-text-OT know-how that Etherpad had productionized
- The user community, which Google initially planned to migrate to Wave

What Google did not want:

- The Etherpad codebase as a Google product. The plan was to **shut Etherpad down** within weeks.

The community erupted.

---

## 📢 The Backlash and the Apache License

The Etherpad shutdown announcement triggered one of the largest open-source community responses of 2009. Hacker News threads, Wikipedia editorial discussion, Mozilla developer letters, university newsroom petitions, the consensus was that Google was killing a beloved product to acquire-hire a team, and that the loss to the open web would be significant.

To Google's credit, they reversed course quickly. On **December 17, 2009**, thirteen days after the acquisition announcement, Google **open-sourced the entire Etherpad codebase under the Apache 2.0 license** and committed to running the hosted etherpad.com service through **March 2010** to give the community time to spin up self-hosted instances.

The Apache 2.0 release was the inflection point that made Etherpad's lineage durable. Without it, Etherpad would be a Wikipedia footnote. With it, Etherpad became:

- A self-hostable real-time editor used at universities, NGOs, and EU institutions across the next decade
- The reference open-source OT engine cited in dozens of subsequent academic and engineering papers
- The codebase that the Etherpad Lite rewrite would later build on

---

## 🔄 2011–2014: Peter Martischka and the Etherpad Lite Rewrite

By 2011 the original Etherpad codebase was showing its age. Built in a mix of Java, Scala, and JavaScript with a custom build system, it was difficult for community contributors to extend.

**Peter Martischka**, a German developer, began a Node.js rewrite called **Etherpad Lite** in 2011. The "Lite" suffix was meant to distinguish it from the legacy code. But the design goals were ambitious:

1. **Single-language stack**: Node.js end to end
2. **Plugin architecture**, third parties should be able to extend Etherpad without forking
3. **Simpler deployment**, `npm install` and you're running
4. **Modern UI**: HTML5 instead of the original Etherpad's heavier client

Etherpad Lite's progress was steady. By **2012-2013** it had feature parity with the legacy codebase. By **2014** it had overtaken it, the "Lite" suffix was dropped, and Etherpad Lite became simply **Etherpad**, the canonical implementation under the new **Etherpad Foundation** stewardship.

Today the project lives at `github.com/ether/etherpad-lite` with roughly **18,300 GitHub stars** and **290+ community plugins**. The plugin ecosystem includes spell-checking, version-control integration, image embedding, math rendering, custom authentication providers, and dozens of UI variants, most contributed without coordination by self-hosting administrators who needed specific features.

---

## 🌐 Who Runs Etherpad in 2026

```
The five largest public Etherpad Lite instances (estimates, May 2026)

  Wikimedia Foundation         ███████████████████████  ~5M pads, ~12M ops/day
  etherpad.wikimedia.org       (used by all WMF projects, Phabricator, GLAM)

  Framapad (French free-soft)  ████████████████          ~3M pads, ~6M ops/day
  framapad.org                 (Framasoft non-profit, used by EU public sector)

  Riseup Pad (activist tech)   █████████████             ~2M pads (anon)
  pad.riseup.net               (anonymous + ephemeral pads, security-first)

  DuckDuckGo Pad               ████████                  ~900K pads
  pad.duckduckgo.com           (internal use + public test instance)

  scratch.mit.edu (LCS)        █████                     ~600K pads
  internal Etherpad            (used in MIT Lifelong Kindergarten teaching)

  Plus thousands of self-hosted instances on Riseup hosts, EU public sector,
  universities, and Hetzner / DigitalOcean droplets globally.
```

Etherpad has a quiet but enormous self-hosted footprint. A non-exhaustive list of production deployments:

| Organization | Etherpad use |
|--------------|-------------|
| **Wikimedia Foundation** | `etherpad.wikimedia.org` — used by Wikipedia editors for drafting articles, agenda planning, Wikimania conference notes |
| **Mozilla** | `public.etherpad-mozilla.org` — engineering team notes, contributor onboarding, public roadmap drafting |
| **European Commission** | Multiple institutional deployments for cross-language drafting under EU data-sovereignty rules |
| **OpenStreetMap** | Volunteer mapping coordination |
| **Universities (global)** | Often deployed as the privacy-friendly alternative to Google Docs; many seminar groups run their own pads |
| **Civic-tech / participatory budgeting** | Used by citizen-assembly facilitators and participatory-budgeting platforms across Europe, Latin America, and East Asia |
| **Newsrooms** | Live-coverage collaboration during elections, breaking news, and editorial-board sessions |
| **Free Software Foundation** | Internal collaboration on activism documents |
| **Hosted services (CryptPad, Framapad, Riseup Pad, etc.)** | Privacy-focused providers run multi-tenant Etherpad deployments as user-facing services |

Etherpad doesn't have a single mega-customer story like Google Docs. It has thousands of medium-sized deployments quietly doing the work, owned by the institutions running them, in a way that Google Docs structurally cannot offer.

---

## 🧬 The Diaspora: Where the Etherpad / Wave Team Went

### AppJet alumni in 2026: the small team's outsized lineage

| Name | Role at Etherpad / AppJet | Joined Google Wave (2009) | Post-Wave destination (2010s) | Current (2026) |
|---|---|---|---|---|
| **Aaron Iba** | Co-founder, CEO | Yes — Wave engineering | Hammer & Co. → MIT Industrial Liaison | Matrix Operations co-founder; angel in Taskade and several real-time / workspace startups |
| **David Greenspan** | Co-founder, Easysync architect | Yes — briefly | **Meteor co-founder (2011)** → Sails / observe-and-modify-everything | Meteor Software (acquired by Tiny in 2022); independent advisory |
| **J. D. Zamfirescu-Pereira** | Engineer | Yes | UC Berkeley HCI PhD (2017–) | Academic — HCI / generative-AI research, papers at CHI / UIST |
| **Daniel Clemens** | Engineer | Yes | Various Bay Area startups | Independent OSS / dev tools |
| **Other AppJet engineers** | YC W07 alumni | Most joined Wave | Spread across Bay Area startups | Indie founders, Meteor ecosystem, Stripe early hires |

Three of the five core people came back to real-time collaboration in different forms within a decade. Meteor's reactive query system (Greenspan) and Etherpad's changeset model (Iba) both descend from the same Easysync intuition: *transform conflicting edits, don't lock.*

After Google Wave was killed in August 2010, the engineers spread out:

```mermaid
graph TD
    W[Wave shutdown<br/>Aug 4 2010] --> A[Aaron Iba<br/>→ YC partner 2011<br/>→ PayGarden 2013<br/>→ Matrix Operations<br/>→ Taskade angel]
    W --> B[David Greenspan<br/>→ Meteor JS framework]
    W --> C[J.D. Zamfirescu<br/>→ multiple startups<br/>incl. Reflect]
    W --> D[Joseph Gentle<br/>→ ShareJS / ot-json0<br/>→ Diamond Types]
    W --> E[Lars Rasmussen<br/>→ Facebook Search]
    W --> F[Stephanie Hammond<br/>→ Quip → Salesforce]
    A -.cap-table.-> T[Taskade Projects]
    D -.code DNA via ot-json0.-> T
    style W fill:#1a0d0d,color:#ef9a9a,stroke:#b71c1c
    style A fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
    style D fill:#2a1225,color:#ff8fa3,stroke:#ff2d60
    style T fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
```

### Aaron Iba's path

- **2011**: One of six full-time Y Combinator partners. Helped early-stage startups through the YC program for two years.
- **2013**: Left YC to found **PayGarden**, an alternative-payments startup focused on prepaid-card-to-merchant conversion.
- **Later**: Co-founder of **Matrix Operations**, a high-frequency trading infrastructure company with offices in New York and London. Designed real-time trading systems, the same low-latency coordination problems Etherpad solved for text, applied to finance.
- **Today**: Active angel investor in early-stage workspace and real-time collaboration startups. **Listed as an angel investor in Taskade** in the company's Genesis launch pitch deck (slides 04 and 12, "Authority chain" and "Featured angel"). The real-time-collaboration thread runs through eighteen years of his career.

### David Greenspan's path

Founded **Meteor**, the full-stack JavaScript framework, in 2011. Meteor's real-time-data-sync architecture inherits intellectually from the Etherpad/Wave model, the framework's `meteor.subscribe` pattern is conceptually a thin OT replication layer over MongoDB.

### Joseph Gentle's path

Independent. Extracted Wave's OT primitives as **ShareJS** (2011) → **ShareDB** → **`ot-json0`**. Later built **Diamond Types** (a state-of-the-art text CRDT, 2023). Gentle's blog posts, "Implementing OT sucks" (2011), "I was wrong. CRDTs are the future" (2020), "CRDTs go brrr" (2021), are the most-cited practitioner writing in the field.

---

## 🧷 The Lineage Receipt: Etherpad → Wave → ot-json0 → Taskade

Most "lineage" claims in tech writing are metaphors. **This one isn't.**

Three primary-source receipts connect Etherpad to Taskade:

### Receipt 1: The Code

Taskade's Project editor, the substrate of every list, board, calendar, table, mind map, Gantt chart, and org chart you can build, is built on `ot-json0`, the open-source JSON OT type extracted by ex-Google-Wave engineer **Joseph Gentle**. The Wave OT engine that Gentle extracted absorbed Etherpad's Easysync know-how when AppJet was acquired in December 2009.

The Taskade entry point literally is:

```typescript
// Taskade Projects · OT type registration (shape only)
import { type as json0 } from 'ot-json0';
import DeltaSubtype from './subtypes/Delta';   // Quill rich-text subtype
import Text0Subtype from './subtypes/Text0';   // plain-text subtype

json0.registerSubtype(DeltaSubtype);
json0.registerSubtype(Text0Subtype);

export default json0;
```

The public `ot-json0` library, [github.com/ottypes/json0](https://github.com/ottypes/json0), extracted from Wave by Joseph Gentle and descended from Easysync conceptually, is imported directly. Taskade's Project editor registers `Delta` (Quill rich text) and `Text0` (plain text) subtypes on top, then layers a custom changeset compose / transform / invert engine to drive every list, board, calendar, table, mind map, Gantt chart, and org chart view from one OT-driven document.

### Receipt 2: The Organization

December 4, 2009: Google acquires AppJet. The Etherpad founders join the Google Wave team. The Wave OT engine, already in development under Lars and Jens Rasmussen, absorbs the Easysync experience. The combined know-how becomes the OT primitives Gentle later extracts.

### Receipt 3: The Cap Table

Aaron Iba is an angel investor in Taskade. Listed in the Genesis launch pitch deck (slides 04 and 12). The same person who co-founded Etherpad in 2008 and joined Google Wave in 2009 has now backed the workspace-software company shipping the same architectural conviction across two more decades.

Three receipts. Engineering, organizational, and capital. **Not a metaphor.**

---

## 🤖 The Next Chapter: AI Agents on the Etherpad Lineage

![Taskade AI agents writing alongside humans into the same workspace.](https://www.taskade.com/static_images/blog/AI-Agent-Team.png)

*Etherpad shipped colored cursors for humans in 2008. Taskade adds AI agents, Custom Agents v2, the meta-agent EVE, and 100+ external integrations, all writing changesets into the same OT-driven document. Same `ot-json0` substrate, four classes of co-editor.*

What Etherpad did in 2008 was put colored cursors on the same document. What [Taskade Genesis](https://www.taskade.com/create) ships in 2026 is the next class of cursor: **AI agents.**

Where Etherpad showed:

- `▍ alice    ▍ bob    ▍ carol`

Taskade shows:

- `▍ alice    ▍ EVE (meta-agent)    ▍ Sales Agent    ▍ Onboarding Agent    ▍ bob`

Same substrate. Same OT engine (via ot-json0). New class of participant.

### Workspace DNA: Memory + Intelligence + Execution

Taskade frames the runtime loop as **Workspace DNA**:

- **Memory**: Projects, the OT-edited substrate. Every edit (human or agent) is captured in causal order.
- **Intelligence**: AI Agents v2 with built-in tools (web search, file editing, image generation, slash commands, web fetch, project read/write, agent-to-agent), persistent memory accumulating expertise across sessions, and custom tool schemas you define yourself
- **Execution**: Automations across 100+ bidirectional integrations (Slack, Stripe, Notion, GitHub, Shopify, Salesforce, Calendar, Linear, Monday, Airtable, Telegram, RSS, Webhooks). Triggers pull external events in; actions push data out.

EVE, Taskade's meta-agent, reads the entire workspace DNA and orchestrates work across all three loops. EVE writes through the same OT engine humans and agents use; her edits interleave with everyone else's in causal order.

### Genesis Apps: One Prompt → One App in Seven Minutes

The Etherpad demo of 2008 was *"watch this document being edited live."* The [Taskade Genesis](https://www.taskade.com/create) demo of 2026 is *"watch this app being built live."*

| You say... | Genesis builds (in ~7 minutes) |
|------------|--------------------------------|
| "Team Knowledge Base with wiki + Mind Graph + ask-the-wiki agent" | Knowledge graph + collaborative wiki + AI search + sidebar agent |
| "Booking system for my coaching practice with Stripe checkout" | Real-time scheduling + payments + confirmations + customer history |
| "Customer feedback app with sentiment analysis" | Ratings DB + photo uploads + sentiment + manager Slack alerts + follow-up workflows |
| "Help desk with AI routing and SLA tracking" | Ticket submission + AI categorization + KB integration + SLA timers |
| "Sales pipeline with Shopify-style storefront" | Pipeline DB + product catalog + checkout + automation triggers |

**150,000+ Genesis apps built since launch.** 3M+ automations executed. MIT Technology Review recognized vibe coding as a "breakthrough technology of 2026."

### Vibe Coding & Living Software

The Etherpad pattern that Genesis carries forward:

- **Vibe Coding**, describe apps in plain language → instant builds
- **Vibe Payments**: Stripe-powered flows triggering automations
- **Vibe Workflows**, forms and requests creating automated processes
- **Vibe Marketing**, content aggregation and cross-platform publishing
- **Vibe Tracking**, leads and data synced across tools via webhooks
- **Hosted MCP server**: Claude Desktop, Cursor, and VS Code connect *into* your workspace and drive it, on every paid plan. The reverse works too — an automation's MCP Client step calls out to third-party MCP servers on every plan, including Free — with the call living in the workflow rather than in the agent; Notion, Linear, and Salesforce are also reachable through 100+ integrations

Eighteen years after Etherpad opened the first pad in November 2008, the same architectural conviction, real-time, OT-based, server-mediated, rich-text-first, runs through one of the most interesting workspace platforms on the market, with the original founder on the cap table.

---

## 📊 Etherpad vs the 2026 Real-Time Workspace Stack

Etherpad's 2008 design choices set the bar for every collaborative editor that followed. Here's how the lineage's three best-known descendants stack up, and where the only one that ships the full Workspace DNA loop lands:

| Capability | Etherpad (2008→2026) | Google Docs (2010→2026) | Notion (2016→2026) | Taskade Genesis (2025→2026) |
|------------|----------------------|-------------------------|--------------------|------------------------------|
| **Sync engine** | Easysync OT (Changeset library) | OT (proprietary, Wave-derived) | Hybrid OT-for-text + LWW-for-property | OT (`ot-json0` + Quill Delta + Text0) |
| **Lineage receipt** | Aaron Iba co-founded | Built by ex-Wave engineers | No public OT lineage | Aaron Iba on cap table · `ot-json0` from Joseph Gentle (ex-Wave) |
| **Self-hostable** | Yes — Apache 2.0 | No | No | No (cloud-native; SOC 2) |
| **Live cursors for AI agents** | None (plugins only) | Gemini sidebar (assistive, not a co-editor) | Notion AI block (one-shot completion) | Custom Agents v2 + EVE editing the same OT stream |
| **Built-in automations** | None | None native | Limited (Buttons) | 100+ bidirectional integrations · durable execution · triggers pull events in, actions push data out |
| **Memory persistence** | Per-pad only | Per-doc only | Per-page only | Workspace DNA · agents accumulate expertise across sessions |
| **Project views** | 1 (pad) | 1 (document) | Many database views | List · Board · Calendar · Table · Mind Map · Gantt · Org Chart (Timeline lives inside Gantt) |
| **RBAC** | Plugin-dependent | 3 tiers | 4 tiers | Roles: Owner to Viewer |
| **Clone the app** | Pad templates | Docs templates | Page templates | Genesis Apps · 150K+ in [Taskade App Factory](https://www.taskade.com/apps) · clone in 60 seconds |
| **Hosted MCP server** | No | No | No | Yes — Claude Desktop, Cursor, and VS Code connect in |
| **Models** | None | Gemini only | Anthropic + OpenAI (chat only) | Frontier models from top AI labs, auto-routed by plan |
| **Pricing (paid entry)** | Free (self-host) | $7/mo Workspace Business Starter | $10/mo Plus | $10/mo Pro · $25/mo Business |

Etherpad's permissionless URL-as-share-button design is still the right call. Google Docs scaled the OT engine to consumer mass. Notion built the workspace database. **Only Taskade Genesis carries Etherpad's open-source OT lineage forward and adds AI agents, automations, and a cloneable Genesis App surface on the same substrate.**

---

![Taskade Workspace DNA, Memory feeds Intelligence, Intelligence triggers Execution, Execution writes back to Memory through the OT engine.](https://www.taskade.com/static_images/newsletter-gifs/2026-05-03-dna-knowledge-graph.gif)

*The Workspace DNA Knowledge Graph visualizes what happens when Etherpad's OT substrate hosts AI agents: Memory (Projects on `ot-json0`) feeds Intelligence (Agents v2 with built-in tools), Intelligence triggers Execution (Automations across 100+ bidirectional integrations), Execution writes back to Memory. Same OT wire Aaron Iba helped pioneer in 2008, now with three more classes of co-editor on it.*

---

## 📚 What We Can Learn from Etherpad

For builders today:

### 1. The substrate outlives the product

Etherpad's hosted service ran from November 2008 to March 2010. Sixteen months. The substrate, Easysync, the OT engine, the open-source code, the lineage to ShareJS and ot-json0, has been running for **eighteen years and counting**. Products fade. Substrates compound.

### 2. Open-source under fire is the highest-leverage decision you can make

If Google had shut Etherpad down quietly in December 2009 without open-sourcing, there would be no Etherpad Lite, no Etherpad Foundation, no Wikipedia / Mozilla / EU deployments, no eighteen-year lineage. The Apache 2.0 license decision, made under community pressure within thirteen days of acquisition, is one of the highest-leverage decisions in the history of collaborative software.

### 3. URL is the share button

Etherpad's permissionless URL-as-share-button design is still the right call in 2026 for collaborative tools. Most failed real-time-collaboration products of the last fifteen years lost at the "how do I invite Bob" step.

### 4. Latency is the product

Google Docs' 15-second sync lag in 2008 was a design choice (batch-and-merge), not a technical constraint. Etherpad's near-instant sync was also a design choice. Users feel latency in their fingertips; they don't read engineering blog posts about why your sync is slow. Make it instant.

### 5. People are the lineage

The "Etherpad lineage" is not a metaphor. It's a set of named engineers (Iba, Greenspan, Zamfirescu, Gentle, Martischka) who carried the same architectural conviction across multiple companies over twenty years. Tech history is biography. Track the people, not just the products.

---

## 🔗 Further Reading

- [History of Real-Time Collaboration: From Engelbart to AI Agents](https://www.taskade.com/blog/realtime-collab-history), the pillar piece on the full lineage
- [Google Wave Lessons: OT Internals + Aaron Iba Lineage](https://www.taskade.com/blog/google-wave-lessons), the product that absorbed Etherpad
- [OT vs CRDT: The Two Algorithms Behind Every Real-Time App](https://www.taskade.com/blog/ot-vs-crdt), engineering deep-dive
- [History of ServiceNow](https://www.taskade.com/blog/history-of-servicenow), enterprise workflow lineage sister piece
- [History of Markdown](https://www.taskade.com/blog/markdown-history), the text-format lineage Etherpad influenced
- [What Is Taskade? Complete History](https://www.taskade.com/blog/taskade-complete-history), the AI workspace built on the Etherpad/Wave OT lineage
- [Etherpad project on GitHub](https://github.com/ether/etherpad-lite), 18.3K stars, 290+ plugins, active community
- [Easysync Technical Manual](https://docs.etherpad.org/api/changeset_library.html), the canonical OT-engine documentation

---

- [14 Best AI Collaboration Tools for Remote Teams (2026)](https://www.taskade.com/blog/ai-collaboration-tools-for-remote-teams)

## ❓ Frequently Asked Questions

### Is Etherpad still being developed in 2026?

Yes, actively. The Etherpad project at `github.com/ether/etherpad-lite` is maintained under the Etherpad Foundation, has roughly 18,300 GitHub stars and 290+ community plugins, and ships regular releases. Major institutions (Wikimedia, Mozilla, EU bodies, universities, newsrooms) keep deploying it because no other open-source real-time editor has Etherpad's combination of maturity and self-hostability.

### Can I self-host Etherpad?

Yes. Etherpad is Apache 2.0 licensed and designed for self-hosting. `npm install` plus a database (MariaDB, PostgreSQL, or SQLite) and you're running. The Etherpad docs include deployment guides for Docker, Kubernetes, Nginx reverse-proxy, and various Linux distributions. Wikipedia, Mozilla, and most EU institutions all self-host.

### What's the difference between Etherpad and Etherpad Lite?

Historically: Etherpad was the original Java/Scala/JS codebase (2008-2014); Etherpad Lite was Peter Martischka's Node.js rewrite (2011-2014). After 2014, the "Lite" suffix was dropped, modern Etherpad **is** the Node.js codebase. The original code is preserved for historical interest but is no longer maintained.

### Who currently runs etherpad.com?

After Google shut down the hosted etherpad.com service in March 2010, the domain went dormant. The community refers to the broader project as "Etherpad", `etherpad.org` is the project home, and the canonical code lives on GitHub. Many hosted Etherpad services exist (CryptPad, Framapad, Riseup Pad), each running multi-tenant Etherpad deployments.

### Did Etherpad influence Google Docs?

Directly, through people. When Google acquired AppJet in December 2009, the Etherpad founders joined the Google Wave team. Google Wave's OT engine, built primarily by the Lars/Jens Rasmussen-led team in Sydney, absorbed Easysync experience from the joining engineers. Google Docs' concurrent editing (launched April 2010) shipped on the same OT engine family. Etherpad didn't *become* Google Docs, but its DNA was absorbed into the Google collaborative-editing stack.

### What is the connection to Aaron Iba and Taskade?

Aaron Iba, Etherpad co-founder, ex-Google Wave engineer, is an **angel investor in Taskade**. The Taskade Genesis launch pitch deck (slides 04 and 12) lists him explicitly as the workspace-software-lineage angel. Taskade Projects is built on `ot-json0`, the open-source JSON Operational Transformation type extracted from Google Wave by Joseph Gentle (another ex-Wave engineer). The Etherpad → Wave → Taskade lineage runs through both Iba's cap-table position and the open-source code itself.

### What was the deal price when Google bought Etherpad?

Reported in the "low eight figures", under $20 million. The exact figure was never disclosed publicly. The deal was primarily an acqui-hire: Google bought AppJet to add Iba, Greenspan, and Zamfirescu to the Google Wave team. Etherpad the product was initially planned for shutdown.

### Why was Etherpad open-sourced?

Community pressure. When Google announced the AppJet acquisition on December 4, 2009 and the plan to shut down Etherpad, the open-source community erupted, Hacker News threads, Wikipedia editor petitions, Mozilla developer letters, and newsroom protests. Within thirteen days, Google reversed course and open-sourced Etherpad under Apache 2.0 on December 17, 2009. The hosted service ran until March 2010 to give the community time to spin up self-hosted instances. The open-source release made Etherpad's eighteen-year-and-counting lineage possible.

### What is the Easysync engine?

Etherpad's custom Operational Transformation engine. A changeset is a sequence of three operators (`=` retain, `-` delete, `+` insert) applied to the previous document state. Rich-text attributes (bold, italic, author, color) are interned in an attribute pool and referenced by short IDs. The Etherpad server linearizes changesets, applies TP1 transforms, and broadcasts the canonical sequence. The Easysync Technical Manual in the Etherpad docs is the canonical reference for the algorithm.

### How does Etherpad compare to Google Docs in 2026?

For online-first, vendor-managed, rich-text collaborative editing with a polished UI, Google Docs is still the dominant choice. For self-hosted, open-source, privacy-friendly, customizable real-time editing, Etherpad. The two have coexisted for sixteen years because they serve different parts of the market. For AI-agent workspaces where humans, custom agents, and a meta-agent edit one OT-driven workspace together with automations and integrations, [Taskade Genesis](https://www.taskade.com/create) is the workspace-native option built on the same OT lineage.

![Taskade AI banner.](https://www.taskade.com/static_images/blog/taskade-ai-banner-768x198-1.png)