Your Workspace Is a Computer: The Sixth Wave of Virtualization (2026)

import IFrame from '@/components/ui/IFrame';

TL;DR: Five waves of virtualization went from mainframe (1964) to agent VMs (2024). The sixth — naming itself here — is the workspace as the unit of compute. We coin Virtual Workspace Computer to describe a tenant-isolated, persistent, multi-agent environment where Memory, Intelligence, and Execution feed each other continuously. Taskade is its native form factor. See it live →

Cold open

Every era of compute has been a fight over the same question: who, or what, gets to operate the machine on your behalf?

The mainframe era answered: a batch operator in a white coat. The PC era answered: you. The cloud answered: a devops team. Serverless answered: the framework. The agentic era — which began in earnest in October 2024 — is answering: an LLM with tools.

Each answer moved the operator one layer closer to intent and one layer further from the metal. Each answer also redrew where the boundary of "your machine" lived: a tape drive, a desktop, a rented VM, a function, a request, a session.

The boundary moved one more time in the last eighteen months, and almost nobody has named it yet. It moved to the workspace.

This post is the history of how it got there, told through five prior waves of virtualization — and a sixth that is happening right now.

Era 1 (1964–2007): Mainframe time-sharing to hypervisors

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. The story arcs across forty years, dies once, and comes back twice.

The Cambridge origin (1964–1972)

In February 1964, IBM established the Cambridge Scientific Center in Massachusetts. Within a year, project leader Robert Creasy and Les Comeau began designing CP-40 — the first system that gave each user not just a time-slice of CPU but a complete virtual System/360 of their own. CP-40/CMS entered production in January 1967 (CP/CMS; IBM CP-40). The design was ported to the System/360-67 as CP-67, and a third generation became VM/370, announced by IBM in 1972 (Robert Creasy).

Creasy's own 1981 retrospective in the IBM Journal of Research and Development lays out the intellectual origin: time-sharing systems like CTSS and Multics shared one operating system among users; CP/CMS shared the hardware, and let each user run whatever OS they wanted (Creasy, 1981). This is the original move: virtualization as a way to multiply expensive hardware among users who each get a full machine.

Popek and Goldberg formalize it (1974)

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; Wikipedia summary). 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 — every instruction that could expose or alter machine state must trap to the supervisor. This becomes the doctrinal test the next thirty years measures every CPU against.

The dark age (1980s–early 1990s)

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 Robin and Irvine identified seventeen sensitive-but-unprivileged x86 instructions, formally proving the architecture was not classically virtualizable (Robin & Irvine, 2000). For two decades, virtualization on commodity hardware was considered impossible.

VMware revives it on impossible hardware (1998–2001)

The revival began as a research detour. 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 the FLASH multiprocessor (SOSP '97). In 1998, Rosenblum, his wife Diane Greene, Bugnion, Devine, and Edward Wang founded VMware (VMware).

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. In March 2001, VMware shipped ESX Server 1.0 — a bare-metal hypervisor with no host OS — and the data-center consolidation era began (History of ESXi).

Xen and the open-source alternative (2003)

At the University of Cambridge Computer Laboratory, Ian Pratt, Keir Fraser, and colleagues took a different route. Their SOSP 2003 paper "Xen and the Art of Virtualization" introduced paravirtualization: instead of fooling the guest OS, modify it — replace sensitive instructions with explicit hypercalls into the VMM (Barham et al., 2003). The performance was excellent, the code was open source, and it became the substrate Amazon EC2 launched on three years later.

Hardware closes the gap (2005–2006)

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 May 2005, the first AMD-V silicon shipped May 23, 2006 (x86 virtualization). The seventeen problem instructions could now trap in hardware. Binary translation was no longer required. Popek-Goldberg, retroactively, was satisfied.

KVM dissolves the product (2007)

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; Ten years of KVM). 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.

Era 2 (1997–2013): The VPS — when "your own server" got sliced

Before VPS, hosting a dynamic website meant one of two extremes. You could buy a 1U dedicated box from a colo provider for hundreds of dollars a month, drive to the data center, and rack it yourself. Or you could rent a slot on a shared host — a single Linux machine running cPanel, 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 and the largest ICANN-accredited registrar by April 2005, was the archetype: cheap, ubiquitous, and structurally incapable of giving you root, a kernel module, or a long-running process (GoDaddy). The "noisy neighbor" problem — one tenant exhausting CPU, memory, or I/O for everyone on the box — was as old as shared hosting itself (Liquid Web).

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; SWsoft). On October 4, 2005, SWsoft open-sourced the core under GPL as OpenVZ (OpenVZ history). OpenVZ is the part most people forget: it predates Docker by eight years and is what early VPS providers actually meant when they sold you "a server." The sub-$5/month VPS plan exists because OpenVZ let one physical host carry hundreds of isolated Linux environments at near-zero overhead (OpenVZ).

Parallels Desktop and the laptop hypervisor

SWsoft renamed itself Parallels in 2007 and, on June 15, 2006, shipped a sibling product that brought hypervisors to laptops: Parallels Desktop for Mac, the first mainstream virtualization product for the new Intel Macs, letting users run Windows XP in a window on OS X (Parallels Desktop). Virtuozzo was spun back out as a standalone company in December 2015.

Linode, Slicehost, and the retail VPS

The retail face of all this was Linode. Christopher Aker founded it on June 16, 2003, from a two-bedroom apartment in Nashville, writing the backend, billing, and control panel himself over seven months. Linode initially ran on User Mode Linux, migrated to Xen in March 2008, and moved to KVM in mid-2015 (Linode). On February 15, 2022, Akamai announced its acquisition of Linode for approximately $900 million (TechCrunch; Akamai release) — closing nearly two decades of independent operation.

Slicehost arrived on June 1, 2006, founded in St. Louis by college friends Jason Seats and Matt Tanase. The pitch was literal: buy a server, slice it into Xen VMs, sell the slices. They built the core in three months, never advertised, and hit roughly 15,000 customers across 170 countries by year two. Rackspace acquired Slicehost on October 22, 2008 (Rackspace; Mixergy / Tanase).

DigitalOcean and the price collapse

DigitalOcean was incorporated on June 24, 2011, by brothers Ben and Moisey Uretsky with Mitch Wainer, Jeff Carr, and Alec Hartman. In 2013, it became one of the first providers to ship SSD-backed VPS instances — "Droplets" — at $5/month, a number that effectively reset the floor for the entire industry. DigitalOcean went public on the NYSE on March 24, 2021, at $47/share, raising roughly $775M (DigitalOcean).

Around the same arc: Vultr, founded in 2014 by David Aninowsky, scaled to $125M+ ARR without raising equity until a 2024 round at a $3.5B valuation (Vultr). In Europe, Hetzner — a German dedicated-server shop since 1997 — launched Hetzner Cloud in 2017 and reset European pricing again (Hetzner). Scaleway, the cloud arm of France's Iliad Group, launched its modern VPS product in 2015.

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. CTO Werner Vogels has framed it as the inevitable consequence of Amazon's "two-pizza teams" exposing every internal capability as a service (AWS; Happy 15th Birthday EC2; ACM Queue / Vogels). 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.

Era 3 (2007–2021): The shrinking compute unit — containers and serverless

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 story begins not at a startup but inside the Linux kernel.

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). 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 (LXC; 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; 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, CoreOS and others as founding members (OCI 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; The New Stack / Beda, Burns, McLuckie). 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 (Northflank: Swarm vs K8s).

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; AWS re:Invent 2014 recap). The unit of compute had shrunk from a VM to a function, billed in 100ms increments.

The runtime moves to the edge (2017)

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. Kenton Varda's design eliminated cold starts almost entirely; an isolate spins up in under a millisecond (Cloudflare Workers).

ZEIT, founded by Guillermo Rauch in 2015, released Next.js in October 2016 and rebranded to Vercel in April 2020, shaping serverless around the frontend deploy (Vercel).

The next runtimes (2021–)

Two paths emerged. WebAssembly + WASI — pushed by Fermyon (Spin), Cosmonic (wasmCloud, accepted into the CNCF in 2021), and Wasmer (1.0 in January 2021) — promised sub-millisecond cold starts in a language-agnostic sandbox (Fermyon: Wasm, WASI, Wagi).

And in May 2021, alongside Google I/O, StackBlitz announced WebContainers: a WebAssembly-based micro-OS that runs Node.js entirely inside the browser tab, with no server at all (StackBlitz). The runtime had finally arrived at the user.

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.

Era 4 (2023–2026): The agentic / sandboxed-compute era

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 substrate changed less than the operator did.

The two opening 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. It launched as a public beta on the Anthropic API, Bedrock, and Vertex AI, scoring 14.9% on OSWorld in the screenshot-only setting — ahead of the next-best system at 7.8%, and nowhere near a human (Simon Willison).

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: Anthropic gave you a model that could drive your computer; OpenAI gave you a hosted computer the model already lived inside. Both were saying the same thing — the GUI is the API now.

The coding sub-era (2024)

The coding world had arrived a year earlier. 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, and ultimately a $400M round at a $10.2B valuation in September 2025 (TechCrunch; Maginative).

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 (Replit). 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; DevClass).

The agent-VM infrastructure layer (2024–2026)

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

E2B, founded in 2023, sold the obvious primitive: Firecracker-based microVM sandboxes-as-a-service that any agent could spin up to run untrusted, model-generated code. It raised an $11.5M seed led by Decibel in October 2024, then a $21M Series A from Insight Partners in July 2025, citing 88% of the Fortune 100 as signups (Vestbee; Insight).

Modal Labs, founded by ex-Spotify infra lead Erik Bernhardsson in January 2021 with a Rust-based container runtime and a serverless GPU scheduler, was originally pitched at data teams — but became a default substrate for agent and inference workloads, hitting a $1.1B valuation on an $87M Series B led by Lux in September 2025 (Modal; Latent Space).

Daytona raised $24M Series A in February 2026 with the explicit pitch of replacing "cloud infrastructure built for humans with one built for agents," and Northflank repositioned its container platform around microVM/gVisor/Kata-isolated sandboxes processing over two million isolated workloads monthly (PR Newswire; Northflank Sandboxes).

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

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" (X / @AravSrinivas; CNBC).

The phrasing was new; the architectural premise was not. ChromeOS had shipped on the Cr-48 in December 2010 and on retail Samsung and Acer Chromebooks in June 2011, on the bet that the browser was already the OS (ChromeOS; Chromebook). 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 (Arc). 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. What it sets up next is the virtualization of the SaaS layer itself.

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 unanswered fifth row is the point of this essay.

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 VM borrowed "machine," the VPS borrowed "server," the container borrowed "image," the serverless function borrowed "endpoint," the agentic sandbox borrowed "computer." The sixth wave borrows "workspace" — and promotes it.

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. In Taskade's case, it has the following layers — which map cleanly onto the operating-system primitives every prior wave inherited. This is the same architecture behind every app in the Taskade Community Gallery and every app built at /create:

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. The discipline is the same.

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. The frontier models from Anthropic, OpenAI, and Google that emerged in 2024–2025 were the first to clear this bar at consumer price points.

2. An isolation substrate. Sandboxed, tenant-safe runtimes that can hold model-generated code, data, and side-effects without compromising the platform. 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.

What this means for builders

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.

The VWC frame is one way to organize that. There are others. The point is that "build a SaaS app" and "build a workspace computer" are converging into the same job, and the products that recognize it first will define the vocabulary the rest of the industry inherits.

If you are curious what this looks like in practice: the /create entry point is where you start a Genesis app from a prompt. The AI Agents v2 page covers the agent capability layer. The automations overview covers the Execution layer. And /learn/genesis/faq is the fastest reference if you are evaluating the platform for a specific use case.

What this means for users

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.

Every Genesis app in the Community Gallery is a small proof of this shift. Teams that have published apps on Taskade did not ship a Figma mockup — they shipped a running workspace with agents and automations wired in. The /community/creators page shows what these builders are making.

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 don't open a Virtual Workspace Computer. You boot it. Then you tell it what you need.

Try the architecture below — a Product Launch Dashboard built on exactly the VWC stack this post describes. One project, one agent, one automation — all wired together from a single prompt.