History of Virtualization: From IBM CP-40 to the Agentic Era (2026)

In February 1964, IBM established the Cambridge Scientific Center in Massachusetts. Within a year, a small team led by Robert Creasy began designing CP-40 — the first computer system that gave each user not just a time-slice of a processor, but a complete virtual machine of their own. CP-40 entered production in January 1967.

Sixty-two years later, an LLM running on a hosted Firecracker microVM clicks a button on a real desktop, books a flight, and writes a status report into a workspace shared with three human teammates and four other AI agents. The agent's "computer" is a virtual machine inside a sandbox inside a workspace inside a browser tab. The lineage runs unbroken from Creasy's mainframe to that click.

This is the story of how we got from one to the other.

TL;DR: Virtualization has gone through five waves — mainframe time-sharing, the x86 hypervisor, the VPS, containers + serverless, and AI-agent sandboxes — each one shrinking the unit of rental and pushing the operator closer to intent. The sixth wave is the workspace itself. Taskade Genesis is its native form factor: persistent project memory, multi-agent intelligence, and Temporal-backed automation execution, in one tenant-isolated environment.

🗺️ 62 Years of Virtualization in One Diagram

Each wave shrank the unit of rental and pushed the abstraction one layer closer to the user. Every era inherited the vocabulary of the wave before it: the VM borrowed "machine," the VPS borrowed "server," the container borrowed "image," the serverless function borrowed "endpoint," the agent VM borrowed "computer." The sixth wave borrows "workspace" — and promotes it.

🧠 Why Virtualization Got Invented (1964): The Time-Sharing Problem

The dream of virtualization is older than most of the engineers who work on it: give every user the illusion of a private machine while the real hardware is shared underneath.

In February 1964 IBM established the Cambridge Scientific Center under the direction of Norm Rasmussen. Within a year, Robert Creasy and Les Comeau began designing CP-40 — a system that did something time-sharing systems like CTSS and Multics couldn't. Those systems shared one operating system among users; CP-40 shared the hardware, and let each user run whatever OS they wanted (CP/CMS — Wikipedia; IBM CP-40 — Wikipedia).

Creasy's own 1981 retrospective in the IBM Journal of Research and Development lays out the intellectual origin: each user got a virtual System/360, complete with its own peripherals, memory, and supervisor. The control program ran underneath. The user OS — typically CMS, a single-user conversational system — ran on top (Creasy, 1981).

1967: How CP-40 sliced one IBM mainframe into N "personal" machines
┌──────────────────────────────────────────────────────┐
│            System/360 Model 40 (real hardware)       │
├──────────────────────────────────────────────────────┤
│                  CP-40 (control program)             │  ◄── the first hypervisor
├──────────────┬──────────────┬──────────────┬─────────┤
│   Virtual    │   Virtual    │   Virtual    │   ...   │
│   System/360 │   System/360 │   System/360 │         │  ◄── one per user
├──────────────┼──────────────┼──────────────┼─────────┤
│     CMS      │     CMS      │     OS/360   │   ...   │  ◄── guest OS
│   (user 1)   │   (user 2)   │   (user 3)   │         │
└──────────────┴──────────────┴──────────────┴─────────┘

CP-40 was ported to the System/360-67 as CP-67, and a third generation became VM/370, announced by IBM in 1972 (Robert Creasy — Wikipedia). VM/370 was the production hypervisor mainframe shops ran for decades. This is the original move: virtualization as a way to multiply expensive hardware among users who each get a full machine.

📐 1974: Popek and Goldberg Formalize the Idea

In July 1974, Gerald J. Popek (UCLA) and Robert P. Goldberg (Honeywell / Harvard) published "Formal Requirements for Virtualizable Third Generation Architectures" in Communications of the ACM (CACM 17:7). Their theorem stated the condition precisely:

An architecture is efficiently virtualizable if and only if its set of sensitive instructions is a subset of its privileged instructions.

In English: every instruction that could expose or alter machine state must trap to the supervisor when executed in user mode. This is the doctrinal test the next thirty years measures every CPU against. It would matter enormously when commodity x86 arrived — and failed it.

🌑 The Lost Decade (1980s–early 1990s): Why Virtualization Slept

Minicomputers and then PCs collapsed the economics that made VM/370 necessary. If hardware is cheap and personal, why share it? Virtualization survived only inside IBM mainframe shops.

Critically, when Intel designed the x86, it did not satisfy Popek-Goldberg. A 2000 USENIX Security paper by John Robin and Cynthia Irvine identified seventeen sensitive-but-unprivileged x86 instructions — instructions that could read or alter privileged state but failed silently in user mode instead of trapping (Robin & Irvine, 2000). For two decades, virtualization on commodity hardware was considered formally impossible.

The dark age ended not because Intel fixed x86 — they wouldn't until 2005 — but because a Stanford research group did the impossible.

🔓 1998–2001: VMware Cracks x86

In 1997, Stanford's Mendel Rosenblum, with PhD students Edouard Bugnion and Scott Devine, published "Disco: Running Commodity Operating Systems on Scalable Multiprocessors" at SOSP — using a virtual machine monitor to run multiple IRIX instances on Stanford's FLASH multiprocessor (SOSP '97).

In 1998, Rosenblum, his wife Diane Greene (then CEO), Bugnion, Devine, and Edward Wang founded VMware (VMware — Wikipedia). The team had the academic insight that Disco proved: if hardware can't trap, the hypervisor can scan kernel code at runtime and rewrite it.

VMware Workstation 1.0 launched at the DEMO conference in February 1999 and shipped that May (Workstation timeline). The trick was binary translation: the VMM scanned guest kernel code at runtime and rewrote the seventeen problem instructions on the fly, while letting user-mode code run natively. The performance was acceptable. The implications were enormous.

In March 2001, VMware shipped ESX Server 1.0 — a bare-metal hypervisor with no host OS (History of ESXi). The data-center consolidation era began.

Type 1 vs Type 2 hypervisors
Type 2 (VMware Workstation, Parallels Desktop)     Type 1 (ESX, Xen, Hyper-V)
┌────────────────────────┐                          ┌────────────────────────┐
│  Guest OS  │  Guest OS │                          │  Guest OS  │  Guest OS │
├────────────────────────┤                          ├────────────────────────┤
│   Hypervisor (VMM)     │  ◄── runs as app         │   Hypervisor (VMM)     │  ◄── runs on metal
├────────────────────────┤                          ├────────────────────────┤
│       Host OS          │  ◄── extra layer         │       Hardware         │
├────────────────────────┤                          └────────────────────────┘
│       Hardware         │
└────────────────────────┘
Slower, easier to install.                          Faster, fewer attack surfaces.

🔀 2003: Xen and the Paravirtualization Bet

VMware kept its binary-translation trick proprietary. The University of Cambridge Computer Laboratory took a different route. Ian Pratt, Keir Fraser, and colleagues published "Xen and the Art of Virtualization" at SOSP 2003 — proposing paravirtualization: instead of fooling the guest OS, modify it to replace sensitive instructions with explicit hypercalls into the VMM (Barham et al., 2003).

The performance was excellent. The code was open source. Three years later, Amazon EC2 launched on Xen — and the public cloud era began.

⚡ 2005–2006: Hardware Closes the Gap

Intel announced its virtualization initiative, codenamed Vanderpool, on January 20, 2005 (Intel press release) and shipped the first VT-x parts on November 14, 2005. AMD followed: the "Pacifica" specification published in May 2005, the first AMD-V silicon shipped May 23, 2006 (x86 virtualization — Wikipedia).

The seventeen problem instructions could now trap in hardware. Binary translation was no longer required. Popek-Goldberg, retroactively, was satisfied.

Avi Kivity, working at the Israeli startup Qumranet, recognized that with VT-x and AMD-V in place, a hypervisor was just a kernel module. KVM was posted in October 2006 and merged into Linux 2.6.20 on February 5, 2007 (KVM — Wikipedia; Ten years of KVM — LWN). Red Hat acquired Qumranet in 2008. Virtualization had completed its journey from million-dollar mainframe feature to a free checkbox in every Linux distribution.

Era 1's defining move: Virtualization's job was never to multiply machines — it was to multiply the feeling of owning one, until that feeling cost nothing.

🪓 1997–2013: The VPS — When "Your Own Server" Got Sliced

Before VPS, hosting a dynamic website meant one of two extremes. Buy a 1U dedicated box from a colo provider for hundreds of dollars a month and drive to the data center. Or rent a slot on a shared host — a single Linux machine sliced into hundreds of chroot'd FTP accounts, where one neighbor's runaway PHP script could drag your site to a halt.

GoDaddy, founded by Bob Parsons in 1997, was the archetype: cheap, ubiquitous, and structurally incapable of giving you root, a kernel module, or a long-running process (GoDaddy — Wikipedia). The "noisy neighbor" problem — one tenant exhausting CPU, memory, or I/O for everyone on the box — was as old as shared hosting itself.

Virtuozzo and OpenVZ — the container ancestor

The fix came from an unlikely place: a small team near the Moscow Institute of Physics and Technology. SWsoft, founded in 1997 and headquartered in Herndon, Virginia, with R&D in Moscow, started building OS-level virtualization in February 2000 after engineer Alexander Tormasov pitched founder Serguei Beloussov on namespaces, file-system sharing, and resource isolation — the conceptual primitives we now call containers.

In January 2002, SWsoft shipped Virtuozzo for Linux, the first commercially available OS-level virtualization product (Virtuozzo — Wikipedia). On October 4, 2005, SWsoft open-sourced the core under GPL as OpenVZ (OpenVZ history). The sub-$5/month VPS plan exists because OpenVZ let one physical host carry hundreds of isolated Linux environments at near-zero overhead.

Linode, Slicehost, and the retail VPS

DigitalOcean's $5 SSD Droplet in 2013 effectively reset the price floor for the entire industry (DigitalOcean — Wikipedia).

EC2 — the enterprise VPS that became the cloud

The enterprise version of the same idea was already running. On August 25, 2006, Amazon opened the public beta of EC2 — the m1.small instance, on Xen — under Andy Jassy, who had pitched the idea with Jeff Bezos in 2003 (Happy 15th Birthday Amazon EC2; Vogels in ACM Queue). EC2 was VPS for Fortune 500s — billed by the hour, API-provisioned, and ultimately the template every modern hyperscaler copied.

Era 2's defining move: The server stopped being a thing you owned and became a thing you rented by the slice — an API call away, billed by the hour, indistinguishable in practice from infrastructure you used to have to physically touch.

📦 2007–2021: Containers, Serverless, and the Shrinking Compute Unit

If virtualization's first act sliced a physical machine into many machines, the second act sliced the machine into processes, then into functions, then into requests. Each generation traded ownership for density and proximity.

The kernel primitives (2006–2008)

In 2006, Google engineers Paul Menage and Rohit Seth began work on a feature originally called "process containers." It was renamed "control groups" in late 2007 to avoid collision with the kernel's other uses of "container," and merged into Linux 2.6.24 in January 2008 (cgroups — Wikipedia). Cgroups handled resource accounting; namespaces, added incrementally over the same period, handled isolation of PIDs, mounts, networks, and users. Together they were the substrate.

LXC arrived in August 2008, maintained by IBM's Daniel Lezcano and Serge Hallyn, and became the first usable Linux container runtime stitched on top of those primitives (Oracle: Brief History of Linux Containers). It worked, but it was a sysadmin's tool.

Docker (2013) — packaging, not kernel tech

On March 15, 2013, Solomon Hykes gave a five-minute lightning talk at PyCon and open-sourced Docker, then an internal tool at his PaaS company dotCloud (renamed Docker Inc. later that year) (Docker — Wikipedia; Snyk: 10 years of Docker). Docker did not invent containers; it invented an image format, a registry, and a one-line docker run ergonomics layer that made cgroups + namespaces consumable by application developers. That was the unlock.

Two years later, at DockerCon on June 22, 2015, Docker donated its runtime (runC) and image spec to form the Open Container Initiative under the Linux Foundation, with AWS, Google, Microsoft, IBM, Red Hat, and CoreOS as founding members (OCI founding announcement).

Kubernetes (2014) and the orchestration war

The first commit to Kubernetes landed on June 6, 2014; it was announced at DockerCon four days later in a keynote by Google's Eric Brewer, an open-source distillation of Google's internal Borg cluster manager (Kubernetes 10-year retrospective). Joe Beda, Brendan Burns, and Craig McLuckie fought internal battles at Google to ship it open source.

In July 2015, Google donated Kubernetes 1.0 to the newly formed Cloud Native Computing Foundation (CNCF announcement).

Kubernetes beat Docker Swarm and Mesos because it was governed by a neutral foundation, had managed offerings on every major cloud (EKS, GKE, AKS), and grew an ecosystem — Helm, Istio, Prometheus, Argo — that Swarm never developed.

Serverless gets a name (Nov 13, 2014)

At AWS re:Invent's Day 2 keynote, Werner Vogels announced AWS Lambda: code that runs in response to events with no server to provision (Vogels). The unit of compute had shrunk from a VM to a function, billed in 100ms increments.

Firecracker (2018) — the under-told microVM pivot

On November 26, 2018, AWS open-sourced Firecracker — a Rust-based virtual machine monitor purpose-built for serverless and container workloads. Boot time under 125 ms, memory overhead under 5 MiB per instance, no PCI, no USB, no graphics — just enough hardware emulation to run a Linux guest. Firecracker is now the substrate that runs AWS Lambda, Fargate, fly.io, and most agent-VM startups (AWS Firecracker announcement).

The runtime moves to the edge (2017–2021)

On September 29, 2017, Cloudflare announced Workers — JavaScript at 200+ edge locations, running not in containers but in V8 isolates, the same sandbox that powers Chrome tabs (Cloudflare Workers). An isolate spins up in under a millisecond.

Fly.io — founded by Kurt Mackey, Thomas Ptacek, and others — began building region-aware deployments on top of Firecracker, splitting the difference between container density and VM isolation (Fly.io Architecture).

StackBlitz announced WebContainers in May 2021 — a WebAssembly-based micro-OS that runs Node.js entirely inside the browser tab, with no server at all (StackBlitz).

The unit of compute kept shrinking, then pushed itself toward the request
1967  ───  Time-slice of a mainframe          (CP-40)
1999  ───  A whole VM you SSH into             (VMware Workstation)
2006  ───  A VM you rent by the hour           (EC2)
2013  ───  A process with its own filesystem   (Docker)
2014  ───  A function with no server           (Lambda)
2017  ───  A function at the edge of the world (Cloudflare Workers)
2018  ───  A microVM with VM isolation         (Firecracker)
2021  ───  A Node.js runtime in your browser   (WebContainers)
2024  ───  A sandbox an LLM drives             (Claude Computer Use)
2026  ───  A workspace agents inhabit          (Taskade Genesis)

Era 3's defining move: The unit of compute kept shrinking and pushed itself toward the edge of the request, until "the server" stopped being a place the developer owned and became a moment the platform conjured on demand.

🤖 2023–2026: The Agent VM — Virtualization for AI

If the prior eras each answered the question "what is the smallest unit of machine we can rent?" — a server, a VM, a container, a function — the agentic era reframed the question entirely. The unit is no longer a slice of hardware. It is an environment that an LLM can operate inside on your behalf.

The coding sub-era (2024)

The coding world arrived first. Cognition unveiled Devin on March 12, 2024, marketing it as the "first AI software engineer," operating inside a sandboxed environment with a shell, code editor, and browser, and posting 13.86% end-to-end resolution on SWE-bench against a prior SOTA of 1.96% (Cognition). The financial response was the real signal: a $21M Series A at a $350M valuation from Founders Fund in March, then a $175M round at a $2B valuation one month later, ultimately a $400M round at a $10.2B valuation in September 2025 (TechCrunch).

Replit Agent followed with the inverse pitch — the agent lived inside a dev environment users already had, taking an idea to a deployed app inside the browser. StackBlitz shipped Bolt.new on October 4, 2024, fusing Claude 3.5 Sonnet with its WebContainers in-browser runtime; it went from $0 to $4M ARR in 30 days and to $40M ARR six months later (PostHog).

The two GUI-as-API moves (Oct 2024 – Jan 2025)

The first canonical move came on October 22, 2024, when Anthropic shipped "computer use" alongside an upgraded Claude 3.5 Sonnet. The framing in the launch post was deliberate: developers could direct Claude to "use computers the way people do — by looking at a screen, moving a cursor, clicking buttons, and typing text" (Anthropic). Anthropic was placing a bet against the structured-API future — instead of waiting for every SaaS vendor to expose a clean tool surface, the agent would simply drive the GUI a human would.

Three months later, OpenAI launched Operator as a research preview for U.S. ChatGPT Pro subscribers at $200/month, with the agent driving a remote browser hosted by OpenAI rather than the user's local machine (TechCrunch).

The two launches bracketed the design space:

Both were saying the same thing: the GUI is the API now.

The agent-VM infrastructure layer (2024–2026)

That growth was only possible because a quiet infrastructure layer had been forming underneath.

Within eighteen months a recognizable category — the agent VM — had a competitive landscape, a price curve, and Fortune 100 customers.

Why agents needed their own sandbox

The story has a dark side. AI agents execute model-generated code and act on a real desktop. A prompt injection can become a real command. Within days of Claude Computer Use launching, security researcher Johann Rehberger demonstrated that a carefully crafted email could direct the agent to download an attacker-controlled binary. The agent had no way to tell the difference between "user instruction" and "attacker instruction"; both were just text on the screen.

The industry response was infrastructural, not algorithmic:

Why microVMs replaced containers for agent workloads
Container (Docker, K8s)           microVM (Firecracker, Kata)
┌──────────────────────┐           ┌──────────────────────┐
│  Application         │           │  Application         │
│  + agent's tools     │           │  + agent's tools     │
├──────────────────────┤           ├──────────────────────┤
│  Container runtime   │           │  Guest kernel        │  ◄── per-tenant kernel
├──────────────────────┤           ├──────────────────────┤
│  Host kernel  ◄── shared!         │  microVM monitor     │
└──────────────────────┘           ├──────────────────────┤
                                    │  Host kernel         │
                                    └──────────────────────┘
Fast (ms boot)                      Almost as fast (~125 ms)
Shared kernel = larger blast        Per-tenant kernel = tiny
radius if an agent escapes.         blast radius. Required for
                                    untrusted AI code execution.

The cultural framing — Comet and the browser-as-OS

The cultural framing landed last and loudest. Perplexity launched Comet in July 2025, initially gated to its $200/month Max tier, and pushed it free in October (TechCrunch). Aravind Srinivas's pitch was not "a better browser" — it was that the browser is now the operating system, "a thought partner and assistant for every aspect of your digital life."

The phrasing was new; the architectural premise was not. ChromeOS had shipped on the Cr-48 in December 2010 on exactly the same bet. What ChromeOS lacked was an operator. The Browser Company saw the same gap the other way: Arc launched in 2023, but in October 2024 Josh Miller announced Arc 2.0 was on hold and the company was pivoting to an LLM-native browser, Dia. Both companies had been right about the OS and wrong about the timing — they were waiting for the operator that Anthropic and OpenAI shipped in late 2024.

Era 4's defining move: The machine stopped being the unit of rental and became the workspace the agent inhabits. Compute is now sold by the session, the screen, and the task — not by the core.

📊 The Pattern Across All Five Eras

Pull the through-line into a single view and the shape becomes inescapable.

At each step the operator moves closer to intent, the unit of rental shrinks, and the user's claim on the underlying machine grows more abstract.

The fifth row is where this essay lands.

🧬 The Sixth Wave: The Virtual Workspace Computer

Here is the thesis, stated plainly:

The next thing to get virtualized is not the machine, the process, the runtime, or the desktop. It is the workspace — the place where humans and agents actually do knowledge work together. And the agent is its native operator.

We are calling this layer the Virtual Workspace Computer, or VWC — a deliberate echo of VPS (the virtual server) and VFS (the virtual file system). The naming is not accidental. Each prior wave inherited and re-used the vocabulary of the wave before it; the sixth wave borrows "workspace" — and promotes it. (We unpack this thesis at full length in Your Workspace Is a Computer.)

Why "workspace" is the right unit

Look at where knowledge work actually lives in 2026. Not in files. Not in folders. Not in apps. It lives in workspaces — bounded environments with their own membership, their own data, their own automation, their own surface. Slack workspaces. Notion workspaces. Linear workspaces. Figma teams. GitHub orgs. Each of them is, structurally, a tenant-isolated programmable environment that a small group of humans inhabits.

What every one of those products lacks is the four things that turn a workspace into a computer:

1. Persistent shared memory that an agent can read and write.
2. A native compute layer — agents that live inside the workspace, not bolted on as a plugin.
3. Programmable I/O — automation pipelines that let the workspace act on the world.
4. A generated interface — a surface the workspace can shape for the people inside it.

Bolt one of those layers on and you have a feature. Build all four into the same fabric and you have a computer.

What a Virtual Workspace Computer actually is

A VWC is a tenant-isolated, persistent, programmable, multi-agent compute environment. Its layers map cleanly onto the operating-system primitives every prior wave inherited:

That stack is the actual payoff. You do not ship terminology — you ship a vocabulary that composes. Once the VWC has a filesystem, processes, jobs, cycles, hostname, and accounts, every feature you ship slots into the metaphor instead of fighting it.

That is the HyperCard trick from forty years ago: card / stack / button / field were five words that explained an entire computing model. Bill Atkinson put programming in non-programmers' hands by hiding code behind a stack metaphor. Taskade Genesis puts programming in non-programmers' hands by hiding code behind a prompt. The metaphor moved from "stack of cards" to "conversation," but the mission is identical — and this time, the apps deploy live and run forever. (We tell the full HyperCard story in History of HyperCard.)

Why the sixth wave is happening now and not five years ago

Three preconditions had to converge.

1. A capable operator. An LLM that can plan, execute multi-step tool use, recover from failure, and stay coherent across long sessions. Claude 3.5 Sonnet (June 2024) was the first model that arguably cleared this bar at consumer price points. GPT-5.x and Claude 4.x extended it.

2. An isolation substrate. Sandboxed, tenant-safe runtimes that can hold model-generated code, data, and side-effects. Firecracker microVMs, V8 isolates, WebContainers, and the agent-VM startups (E2B, Modal, Daytona, Northflank) collectively crossed this threshold by mid-2025.

3. A protocol for the operator to reach across the boundary. The Model Context Protocol — proposed by Anthropic in November 2024 and adopted broadly in 2025 — is the equivalent of POSIX for agent-shaped compute. It standardizes how an agent accesses files, tools, and memory across heterogeneous environments.

When you have an operator, an isolation substrate, and a protocol, you have an operating system. The mainframe had it in 1967. The PC had it in 1984. The browser-OS almost had it in 2010 and missed by an operator. The VWC has it in 2026.

🏗️ How Taskade Genesis Is the Native VWC

Most workspaces in 2026 are documents you read together. Taskade Genesis is a workspace you boot. From a single prompt, Genesis composes the four VWC layers and ships them live.

Each of those is the same primitive — a workspace that boots into a living app — composed differently. Compare that to the prior eras:

• A 1999 VMware Workstation gave you a guest OS. You still had to install the CRM.
• A 2006 EC2 m1.small gave you root. You still had to deploy the CRM.
• A 2013 Docker container gave you a deployable artifact. You still had to write the CRM.
• A 2018 Lambda gave you a function. You still had to glue the CRM together.
• A 2024 Claude Computer Use gave you an agent that could use Salesforce. You still had to pay for Salesforce.

A 2026 VWC gives you a workspace that is the CRM. The unit of rental finally matches the unit of work.

⚔️ How the Workspace Computer Beats Every Adjacent Category

The VWC frame absorbs four adjacent categories without conflict. None of them are wrong — they're earlier-wave tools, exactly the way a VM isn't wrong for someone who needs a server.

Key differentiator: Workspace DNA. Memory (Projects) feeds Intelligence (Agents), Intelligence triggers Execution (Automations), Execution creates Memory. The self-reinforcing loop is what makes a workspace a computer and not a document.

🔭 What This Means for Builders and Users

If you are building a SaaS app today, you are building a workspace whether you intended to or not. Your users will, within the next twenty-four months, expect three things from it:

• An agent that lives inside it — not a chatbot bolted to the corner, but a process with read/write access to the workspace's full state.
• Programmable side-effects — the workspace must be able to do things in the world: send the email, create the issue, post the message, charge the card.
• Composable interface — the workspace must be able to render itself into surfaces that fit the work, not the other way around.

For users, the shift is the same one that happened when typewriters became word processors, when word processors became Google Docs, when Google Docs became Notion. Each step removed friction between the intent and the artifact. The VWC removes the last friction: the act of operating the tool itself.

You will stop opening apps and start booting workspaces. You will stop installing integrations and start hiring agents that already know how to use them. You will stop writing in documents and start instructing your workspace to produce them. You will stop being the operator and start being the principal.

You don't open a Virtual Workspace Computer. You boot it. Then you tell it what you need.

🧭 The Receipt — Every Source

Era 1 — Mainframe / Hypervisor

• CP/CMS — Wikipedia
• IBM CP-40 — Wikipedia
• Robert Creasy — Wikipedia
• Creasy, "The Origin of the VM/370 Time-Sharing System" (IBM J. R&D, 1981)
• Popek & Goldberg, CACM 17:7, 1974
• Robin & Irvine, USENIX Sec, 2000
• Bugnion, Devine, Rosenblum, "Disco" SOSP '97
• VMware — Wikipedia · ESXi history
• Barham et al., "Xen and the Art of Virtualization" SOSP '03
• Intel "Vanderpool" press release (Jan 20 2005)
• KVM — Wikipedia · Ten years of KVM — LWN

Era 2 — VPS

• Virtuozzo — Wikipedia · OpenVZ history
• Linode — Wikipedia · Akamai acquires Linode (Feb 2022)
• DigitalOcean — Wikipedia · Vultr — Wikipedia · Hetzner — Wikipedia
• Happy 15th Birthday EC2 · Werner Vogels in ACM Queue

Era 3 — Containers + Serverless

• cgroups — Wikipedia · Oracle: Brief History of Linux Containers
• Docker — Wikipedia · Snyk: 10 years of Docker
• OCI announcement (Jun 2015)
• 10 Years of Kubernetes · CNCF announcement (Jun 2015)
• Werner Vogels: AWS Lambda (Nov 2014)
• Firecracker — AWS announcement
• Cloudflare Workers (Sep 2017) · Fly.io Architecture
• StackBlitz WebContainers (May 2021)

Era 4 — Agentic / Sandboxed Compute

• Anthropic: Claude 3.5 + computer use (Oct 2024) · Simon Willison on computer use
• TechCrunch: OpenAI Operator launch
• Cognition: Introducing Devin · TechCrunch: Cognition $400M at $10.2B
• Replit Agent · PostHog: Bolt.new 0→$40M
• Insight: E2B Series A · Modal Series B
• PR Newswire: Daytona $24M Series A · Northflank Sandboxes
• TechCrunch: Perplexity Comet (Jul 2025)
• ChromeOS — Wikipedia · Arc browser — Wikipedia

Era 5 — Workspace Computer (related reading)

• Your Workspace Is a Computer — the manifesto
• History of HyperCard — the 1987 ancestor
• History of Real-Time Collaboration — how cursors got plural
• History of Workflow Automation — the I/O layer's lineage

🚀 Boot the Sixth Wave

The arc of virtualization has been remarkably consistent for sixty-two years. Every wave shrank the unit of rental, moved the operator closer to intent, and cheapened the feeling of owning your own machine until that feeling cost nothing. The mainframe gave us the illusion of a private computer on shared steel. The VPS gave us the illusion of a private server on a shared kernel. The container gave us the illusion of a private process on a shared host. Serverless gave us the illusion of a private function on a shared edge. The agent VM gave us the illusion of a private desktop an LLM could drive.

The Virtual Workspace Computer gives us the illusion of a private team of intelligent collaborators, working inside a shared fabric, on the work we asked them to do.

The hypervisor abstracted hardware. The container abstracted the OS. The serverless function abstracted the runtime. The agent sandbox abstracted the desktop. The workspace computer abstracts work itself.

It is not a metaphor. It is the next layer.

Spin up your first Virtual Workspace Computer → — it takes a prompt.

Frequently Asked Questions