The first websites were single-celled organisms. One person, one server, one HTML file. You typed tags by hand. You uploaded via FTP. Your site lived or died on your own machine. If the power went out, your words went dark. If someone found you, it was by accident — a link on a friend's page, a search engine crawl. Connection was incidental. Nothing guaranteed it would last.

This was the Precambrian of web publishing. Isolated, fragile, free.

Three axes, not one line

What happened next was not a straight line. Evolution never is. At least three independent axes were moving at once, crossing each other at unpredictable points.

The democratization of creation. HTML by hand gave way to WYSIWYG editors. Dreamweaver. Then WordPress made the server invisible. Then Medium made WordPress look complicated. Each step lowered the barrier. But the line didn't only go down: Markdown brought manual formatting back. Static site generators returned control to people who wanted it. The barrier oscillated.

The delegation of infrastructure. Your own server. Then a shared host — Geocities, then proper web hosting. Then managed platforms that swallowed the server whole. You stopped thinking about where your files lived. Someone else's computer held your words, and you traded ownership for convenience. Each delegation made publishing easier and exit harder.

The acquisition of sociality. First, links. Then trackbacks — a crude signaling system between blogs. Comment sections. RSS readers that aggregated voices into a single stream. Then social networks absorbed all of it: distribution, discovery, reaction, conversation. The platform became the social layer, and the social layer became the reason to stay.

These three axes moved on separate timelines. Sometimes they crossed. WordPress was a crossing point: democratized creation met delegated infrastructure. Twitter was another: sociality swallowed everything else.

Single cells

The early web was a world of single-celled organisms. Each blog was an independent unit. It metabolized on its own. It reproduced by inspiring imitation. It died when its author lost interest or its server went offline. The link — HTML's <a> tag — was the only point of contact between cells. A link could point to another organism, but if that organism disappeared, the link rotted. 404. Connection was real but impermanent.

Trackbacks were the first attempt at persistent signaling. Your blog told my blog that it had referenced me. A thin, fragile thread. Most people never understood how they worked. They were eventually killed by spam — parasites exploiting an open signaling channel. The metaphor holds.

RSS was something different: not a connection between two organisms, but a way to observe many at once. A perceptual organ. It didn't change what blogs were. It changed how they were seen. Google Reader's shutdown in 2013 was the moment the ecosystem realized that a shared perceptual organ, centrally hosted, could simply be switched off.

Multicellularity

Social networks were multicellularization. Individual cells gave up autonomy to form a larger organism. The trade was compelling: in exchange for living inside the organism, you got real-time signal transmission (the timeline), differentiated organs (feeds, notifications, DMs, trending topics), and an immune system (moderation, content policies).

The cost: cells could no longer leave. Your followers, your conversations, your social context — all were properties of the organism, not of you. Leaving Twitter meant leaving your audience. The platform owned the social graph. Your content might be exportable as a zip file, but the relationships were not.

This is the core asymmetry of the multicellular era. Data portability was technically possible. Social portability was not.

The infrastructure problem

Here is where the biological metaphor reveals something useful. In multicellular organisms, cells delegate critical functions to shared infrastructure — circulatory systems, nervous systems, skeletal structures. The cell doesn't pump its own blood. The organism does.

The same happened on the web. Platforms provided the infrastructure layer: content delivery, recommendation algorithms, notification systems, abuse prevention. Individual publishers couldn't replicate these at reasonable cost. The infrastructure was heavy, expensive, and centralized by necessity.

This created a gradient. Hosting your own content: cheap. Running the social machinery around it: expensive. The gradient pulled everything toward centralization. Not because centralization was ideologically preferred, but because the infrastructure was heavy and someone had to carry it.

The AT Protocol hypothesis

AT Protocol proposes a structural answer to this gradient. Separate identity from infrastructure. Separate data from the application that displays it. Let users keep their content in personal data repositories (PDSes) while applications compete on presentation and features.

The hypothesis: if the data layer is standardized and portable, applications become interchangeable shells. The same content, different interfaces. Your choice of reading app is a preference, not a commitment.

Does this work? It depends on what you're trying to do.

Where simplicity wins first

For long-form publishing, the answer is approaching yes. The standard.site lexicon — adopted by Leaflet, Offprint, and Pckt — defines a shared schema for articles, subscriptions, and comments. An article written in Leaflet can appear in Offprint's reader. Not as a copy. Not as a syndicated duplicate. The same record, rendered through a different interface.

This is the CSS metaphor. The HTML is the same. The stylesheet changes. Your article sits in your PDS — one original, many windows. Write wherever you want. Read wherever you want. The article doesn't move.

This works because blog publishing is structurally simple. Write, store, render. One direction. A static object sitting in a repository, waiting to be read. The infrastructure required to make this function across platforms is light. A renderer is cheap to build.

For social networking, the picture is harder. A social graph is not a static object. It is a real-time interaction loop: write, distribute, react, redistribute. Running this loop requires relays (to aggregate data across repositories), AppViews (to assemble timelines), and feed generators (to rank and filter). This infrastructure is heavy. If Bluesky Social disappeared tomorrow, your follow list would survive as records in your PDS. But records don't flow. Someone would need to rebuild the circulatory system.

The data survives. The organism doesn't — not automatically.

The stack cost gradient

This asymmetry is not a bug. It is a physical property of the system. Publishing platforms sit at the light end of the infrastructure gradient. Social platforms sit at the heavy end. The protocol's promise of interchangeable shells arrives first where the shell is thin.

PDS implementations are numerous and lightweight. AppView and relay implementations are scarce and heavy. This is why a solo PDS hosting business makes sense for publishing before it makes sense for social networking. If your PDS holds your articles, its quality — uptime, speed, storage — directly affects your publishing. You care about it the way you once cared about your web host. But this time, you can move without breaking your links.

Hosting for publishing. Renting for social. The gradient determines what decentralizes first.

Magic realism

There is something uncanny about the current moment. An article written in Leaflet appears in Offprint. Not copied. Not syndicated. The same article, in two places at once, with one original. This violates the physical intuition we've built over decades of web use. A page lives at a URL. You go to that URL to read it. If the site goes down, the page is gone.

In the standard.site world, the article lives in a PDS. Applications are windows. Multiple windows, one room. The intuition breaks.

This is magic realism in the García Márquez sense: everyday life continues normally, except one law of physics is broken, and nobody in the story finds it strange. The developers don't find it strange. The protocol makes it obvious. But for a general user, trained on two decades of platform logic, it is quietly surreal. The same article, in two apps, with no copy operation. Where is it? It's in your folder. Your folder is on the network. The apps just look at it.

We are at the point in the story where the townspeople have started to notice that the butterflies appear in every room of the house simultaneously. The explanation is architectural. The feeling is magical.

From tech to fashion

If applications are interchangeable shells over the same data, then choosing an application is no longer a technical decision. It is an aesthetic one. Which editor feels right. Which reading interface you prefer. Which typography. Which color scheme.

The question shifts from "where should I publish?" to "what should I wear?"

This is the transition from a tech world to a fashion world. The underlying protocol is infrastructure — invisible, like plumbing. The visible layer is taste. Leaflet, Offprint, Pckt, and whatever comes next are not competing for your data. They are competing for your preference.

The era of platform migration is ending. You don't move your furniture to a new house. You change the wallpaper.

What evolves next

The single-cell era gave us independence without connection. The multicellular era gave us connection without independence. The protocol era is attempting something that has no clean biological precedent — except, perhaps, the slime mold.

Slime molds live as independent single cells. When conditions demand it, they aggregate into a multicellular body, move as one, then disperse back into individual cells. They oscillate between autonomy and collectivity. No permanent sacrifice of independence. No permanent loss of coordination.

AT Protocol's architecture makes this oscillation structurally possible. Your data lives independently. Applications aggregate it into social experiences. You can leave an application without losing your data or your identity. In theory.

Whether the theory holds under real conditions — network effects, infrastructure costs, the psychological pull of "everyone is here" — is the open question. The protocol provides the blueprint for a slime mold web. Building the actual organism is a different problem.

The evolution is not over. We are watching it happen.