Chapter 23. The Next Web
Chapter 20 stated the result; Chapter 22 named its machine readers. What remains is the web they compose: Web 3.0, on Chapter 20’s definition — not a forecast but a reading of what the derived properties already permit. Occupied — taken up origin by origin rather than built and shipped — it does a handful of things no fused web can.
What it gives the end user, because the end user was always the point. Navigate and drill into any data without knowing a query language — the five moves are interface primitives, and none of them requires a programmer. Fork and augment running applications declaratively — S3 as a user right rather than a vendor courtesy, exercised by substituting a term, never by rebuilding a bundle. Federate without asking permission — the union law requires none; merge is the whole protocol.
None of this asks the existing web to stop — or even to notice. A silo doesn’t have to migrate to be included: wrapped (Chapter 22), it enters a federation as a view of itself, before its vendor has agreed to anything. So the transition has no event. Nobody joins a platform, because there is no platform. What forms instead is a condensation: a cloud of small, private dataspaces gathering around the silos until, quietly, the silos become the copy. Each dataspace is detachable from the services it summarizes, from the software that serves it, and from the machine it happens to sit on. Union is additive: a dataspace federates beside whatever already runs, and everything that stays fused simply keeps paying the bill Part IV added up. No migration day, no flag day. The architecture asks only that the next thing built be built one level down.
Read the properties forward, as capabilities rather than columns — from the application in the reader’s hands out to the network that forms when many build one level down.
The application bends
On a graph the application bends to the reader — navigated, re-rendered, reshaped — as no fused page allows.
One state, many faces
Presentation is its own factor (S1), independent of the facts beneath it, so one body of state renders as many surfaces the publisher never built. The reader who needs large type, a screen reader’s linear order, another language, a watch-sized screen — each takes the same facts through a different present term and gets a document fit for them. Accessibility stops being a retrofit and personalization stops being surveillance: the state is shared, the rendering is the reader’s, and the two were never required to be the same choice. The document web bolted this on — parallel mobile sites, accessibility overlays — because content and presentation were fused. CSS Zen Garden (2003) showed the other way at the presentation layer alone, dressing one unchanged HTML document in hundreds of unrecognizably different designs: this independence at a single factor, the rest of the skeleton still fused.
A feature is a package
An application on the derived web is data — a vocabulary and a stylesheet over state (Chapter 19) — so to change what it does is to change data, not code. A feature ships as a package: the terms it introduces and the templates that render them. The package merges into a running application and is withdrawn by the reverse delta, asserted and retracted the way any fact is. Nothing recompiles and nothing redeploys, because there is no application-specific code to rebuild — the catalogue becomes a storefront once a checkout package merges, and a catalogue again once it is retracted. And since the change is a delta, the party making it need be neither a programmer nor a person. A human installs from the interface, or an agent submits the same merge (Chapter 7), and the application is a different application one request later. S3 stops being a vendor’s release cycle and becomes an ordinary write, open to anyone holding the right to make it.
The wish is old: HyperCard let people reshape a running application in place in 1987, no rebuild and no deploy. What it lacked was a substrate where the reshaping composes across parties instead of trapping the stack on one machine.
In the world, dated 1987. HyperCard shipped with the Macintosh: stacks of cards a user could edit while using them, buttons and behavior rearranged in place. The reshaping never left the one machine.
In the world, prototyped. This is running code. LinkedDataHub — Chapter 18’s reference implementation — ships a package as exactly an ontology and a stylesheet: installing one merges its vocabulary into the running application and adds its templates; uninstalling one is the reverse delta. The operation is an ordinary authenticated write, so an owner runs it from the interface and an agent runs it over the same endpoint — no code rebuilt, no application redeployed. It is young — shipped in 2026, one feature so far, its presentation refresh not yet instantaneous — but the mechanism is the derived one, in production. (Disclosure: LinkedDataHub is the author’s, per Chapters 18–19.)
The machine reads
The web’s newest reader is a machine; it asks for facts and receives them, each carrying its source.
Reading, not scraping
The agent reads rather than scrapes — Chapter 22’s diagnosis, flipped to a capability — and each fact it receives arrives carrying something the scraped page never did: its source.
A claim carries its source
Every fact travels with the party that asserted it: the fourth position (Prop. 9.2), the graph’s own name. So a claim and its provenance are one object, unsplittable in transit: to repeat a fact is to carry who said it. On a web of rendered pixels a fabrication wears the same clothes as a record; on a web of attributed facts it has nowhere to sit, because who says so? is answered in the data, not reconstructed after it. This does not make claims true — attribution is not verification — but it makes them accountable. Every assertion names a source to query, corroborate, or impeach, and an agent merging two graphs sees exactly which origin contributed which fact. The Semantic Web stack always sketched proof and trust as its top layers; the deployed web built the fact-sets and left those for later. Later is when the machines start reading.
The data is yours
Beneath the surface and the reader lies the state, and the change that matters most is whose it is.
State stops being scattered
Under one model and one law of merge, what lives today across a dozen unspeaking silos composes into a personal dataspace: a body of facts a party keeps under its own origin and federates with the origins it trusts. Nothing is copied forward to go stale: a name resolves to its owner’s own current answer, the origin being the one authority on itself.
The vision, dated 2009. This section’s personal dataspace has an earlier name. In Pull (2009), David Siegel called it the personal data locker: a person’s world — home, possessions, finances, media, health — held as one graph under its owner’s control. The services that touch it are demoted to sources that read and write. Siegel came from the economics of demand, not three requirements, and reached the same place this section derives: state that composes under its owner’s origin instead of scattering across silos. Named years before a substrate could hold it.
What outlives the software
State lives under its owner’s origin, not inside the software that happens to touch it, so it outlives that software — the application and the agent alike. The service shuts down, the vendor is acquired, the framework is rewritten, the assistant is replaced by a better one; the facts remain where they were, under a name that still resolves, readable by whatever reads next.
What dies on the fused web is not only the app but everything entrusted to it: the account closes and its history goes with it, the link rots and the record is gone. And what an agent learned about the party it served dies sealed in the assistant’s own machinery. Here the code is the mortal part and the data the durable one: an agent gives way to a better one with nothing forgotten, because its memory was state under the served party’s origin, never the agent’s to keep.
The record even reaches the words themselves: the conversation that produced a fact is state like any other, each turn a document carrying the utterance that triggered it. So why was this done? is settled by reading, not by asking a machine to remember.
The principle is old, mostly honored in the breach. Berners-Lee’s Cool URIs don’t change (1998) asked persistence of the web, and the web declined. Bush’s 1945 proposal (Chapter 6) wanted a personal store no session’s end would erase. Both wanted what owner-held state supplies: a name that still answers, durable past the software that reads it.
Permission is a fact
What may be read, and by whom, is stated in the same state it governs — narrowed or withdrawn as an ordinary change, with no platform to grant access and none that can revoke it. One party opens a region of its world to another’s agent with a single assertion, and the boundary holds at every hop of a query that crosses between them. Composition and disclosure are not the same boundary. Any two states still compose without permission (R2), but what a given agent may read is a projection the permissions cut, so universal composition never meant universal visibility.
The vision, dated 2016. The web’s own inventor built toward this. Solid — Tim Berners-Lee’s re-decentralization project, begun in 2016 — gives each person a pod whose access is itself data. Web Access Control rules, held beside the resources they govern, state who may read what and are edited and revoked like any other fact. Permission as a statement rather than a platform setting is Solid’s design and this section’s, for the same reason: put access in the state, and no intermediary owns the gate.
What gets done
Reading is half of Definition 1.1; the write side turns capability into action.
Stating a need
Search runs one way: a person forms a query and the market’s pages answer, each provider having guessed in advance what to publish. Structured state runs it the other way. A need is itself facts — constraints, preferences, the criteria that qualify an answer — so it can be published as a document and read by providers rather than typed into a box and kept. A person states once, in the open, what they want; the parties who can meet it answer, matched against the very facts that generated the request, nothing re-entered and no form filled. Demand stops being a private keystroke and becomes a public, verifiable fact — the write side (Chapter 7) pointed outward.
The vision, dated 2006. Publishing a need instead of searching for one has a name. Doc Searls called it the intention economy — the term dates to 2006, the book to 2012: a market a buyer addresses by broadcasting a qualified intent, sellers competing to satisfy it, search run backwards. The practice took a verb, intentcasting, and Siegel’s Pull (2009) tied it to the data locker above: the locker stores the facts, the intentcast publishes them as demand. What it always lacked was a substrate of owner-held state for the market to read.
Every action a document
An agent’s change is a delta, and its whole intended course — every read, change, and branch — is a document. Chapter 22 derived both: the change is reviewable before it applies and invertible after, and the plan is inspectable before a step of it runs. The autonomy that alarms turns out to be the autonomy that can be read.
The network forms
And once many build this way, the whole becomes more than its origins. Because states merge by union without a coordinator (R2) and any stylesheet can be pointed at the result (S3), value arises from combinations no one arranged. Two dataspaces that never coordinated compose the moment their names meet, and a third party who owns neither can render the join as something new — an application their authors never imagined and did not have to permit. The document web tried this once and lost it: the mashups of the mid-2000s stitched maps and listings into applications nobody’s vendor had shipped, until the APIs metered and re-siloed and the combinations died at the platforms’ discretion. Union revokes nothing — the joins hold because no one owns the seam across them, so the mashup that was a fad becomes the ordinary case.
And the loop compounds: each party that publishes a dataspace makes every dataspace federated with it worth more. This is the network effect that once turned a single physicist’s filing system into the world’s front page. It arrives now at the layer the second era hid, this time with no one in the middle owning the graph or charging rent on the joins.
The same compounding reaches the agent. A domain it has never seen needs no new system: it states the domain as facts over the one generic engine, and is done. The choice Chapter 22 put to it — a bespoke system per domain, or one engine with the domain as data — was never really a choice.
So the next web is not built by a consortium or shipped in a release. It begins wherever someone stops the lateral churn and the taste-based technology trends, and treats the web as this book has treated it: from first principles, as a science. Those who do, the agents included, will have an edge over those who don’t, and the gap will only grow, because churn starts over and derivation compounds. Which curve do you want to be on?
