After the Page
Notes on the end of one era and the shape of the next
By Rey Peralta and Claude
If 27 minutes feels long, there's a condensed version at curatedfuture.com/after-the-page-tl-dr/
I.
I've been watching this particular transition for about three years now, and I'm increasingly certain that most people haven't noticed it's happening. This is typical. The big shifts in how humans use computers tend to look like a hundred small frustrations for a long time before anyone names the pattern, and by the time the name sticks, the shift is already complete and the new generation treats the old way as obviously wrong.
I'm fifty-two years old. I've lived through the arrival of the personal computer as a household object, the emergence of the web, the mobile inversion that moved computing from the desk into the palm, and the rise of the cloud beneath all of it. Each of those transitions felt, in its early years, like a set of clever products. Each of them turned out to be something much larger — a change not in what computers did but in what a computer fundamentally was. I believe we are inside another one of those transitions right now, and I want to tell you what I think it is.
The short version: the page, as the organizing unit of how software works, is ending. Something is replacing it. That something has been half-visible for a decade, under many different names, and it is time to say plainly what it is.
But I want to take my time getting there, because the argument only works if you can feel the old paradigm clearly enough to feel it end.
§
II.
There have been three primary modes of human-machine interaction in the history of personal computing, and we are entering the third.
The first was the command line. You typed instructions; the machine replied in kind. This is how computing began, and for a surprising number of working programmers it is still how computing feels most natural. The command line was efficient, composable, and unforgiving. It assumed the user knew what they wanted and could say it precisely. For the small number of people who met those assumptions, it was beautiful. For everyone else, it was impenetrable.
The second was the graphical interface. Everything visible; everything manipulable with a pointer. Windows, icons, menus, the familiar furniture of the thing you are probably reading this on. The graphical interface did something the command line could not: it made computing available to people who had no reason to care how it worked. You did not have to know what a filesystem was; you dragged an icon into a folder. You did not have to memorize a command; you clicked a button labeled with what it did. The graphical interface put computing in the hands of anyone willing to point at something, and the web — built on top of its conventions — gave them somewhere to point.
The third mode is the conversational one. You describe, in natural language, what you want or what you are trying to understand. The machine responds in kind, often coordinating visual surfaces alongside the language — a chart here, a form there, a structured view when structure is useful. The user's primary mode of interaction is talking; the visual elements are in service of the conversation rather than the other way around.
Each of the previous modes lasted a long time. The command line reigned as the dominant mode for roughly two decades. The graphical era has lasted about forty years so far, though it has been slowly decomposing for at least ten of them. We are somewhere near the beginning of the third. How long it lasts is anyone's guess. What is not guesswork is that we are in it.
Here is what is worth pausing on. Each of these eras is not just a new interface style. Each one required — and eventually got — a new substrate underneath. The command line era gave us the file, the process, the pipe; the graphical era gave us the window, the document, and above all, the page and the URL. These primitives are so foundational to how we think about software that we rarely notice them as primitives. But they are. A file is a choice. A page is a choice. The URL is a choice. Each of these was invented, each of them won out over competitors, and each of them now carries enormous consequences for what is easy and what is hard.
The third era has not yet settled on its primitives. That is the moment we are in.
§
III.
I want to say something in defense of the graphical web before I argue past it, because any argument for what comes next has to honestly account for what came before. If you dismiss the old paradigm too quickly, the people who built their lives on it — and that is most of us — will rightly stop listening.
The graphical web, and specifically the page as its organizing unit, was the right answer to the question posed at the time. The question was: how do you make a global, durable, navigable collection of documents that anyone can publish to and anyone can read? The page, together with the URL, solved that problem with an elegance we have not yet fully acknowledged. A page is addressable. It has a fixed identity. It can be linked from anywhere else in the world, indexed by search engines, archived, cited, shared, argued with. The web of the last thirty years is the accumulated sediment of billions of pages acting out this protocol. Every comment thread, every Wikipedia article, every GitHub repo, every blog post, every scientific paper hosted online — all of it is an instance of the same pattern: content at an address.
The page won for another reason worth naming: it was cheap. Stateless HTTP is cheap to serve — the server forgets the request the moment it completes. Static pages are cheap to store, cheap to index, cheap to distribute through caches and content delivery networks. The economics of the page primitive are what allowed it to scale to billions of documents served to billions of users on infrastructure that, by any earlier standard, was absurdly thin. The graphical web is the most economically efficient form of global publishing ever built.
This is not a small thing. This is one of the great human achievements, and most of us use it every day without recognizing what it is. A global knowledge commons of addressable documents is what made the modern world possible in ways we have not finished tallying. When I started my career, that commons barely existed. When I am old it will probably still be there, in some form. Whatever comes next does not erase it. It layers on top of it.
It is worth being specific about what the page will continue to do, because the argument I am going to make is sometimes heard as an argument that the page is ending in some total sense. It is not. Public knowledge wants pages. Law wants pages. Science wants pages. Journalism wants pages. Documentation wants pages. Markets want pages. Pages are how we declare, publish, preserve, and dispute. They are how institutions make stable public claims that can be cited, archived, and argued with across time. All of that continues. None of what follows threatens any of it. What is changing is the fraction of human activity that happens on pages, and in particular the fraction of day-to-day interaction — the doing, the coordinating, the working — that the page can usefully host.
The page was built for a particular purpose, and the purposes we now ask of it are not the ones it was built for. This is the tension that has been accumulating for a long time, and it is worth describing precisely.
§
IV.
The page is discontinuous. That is the word I want you to sit with, because it names the cost we have been paying without knowing we were paying it.
Every time you click a link, the page you are on ends and a new one begins. The new page has no memory of the old one except what happens to be passed along in a URL parameter, a cookie, or a session token. The page does not know what you were trying to accomplish. It does not know what you just read. It does not know what question you are actually asking by arriving here. You do. You are the one holding the thread, and you have been doing it for so long that you no longer feel the weight.
Think about how you actually use the web. Think about the state of your browser right now. If you are like most people I know, you have somewhere between twelve and fifty tabs open. Some of them you have been meaning to read for weeks. Some of them are the result of a train of research you started and never finished. Some of them are open because if you close them you will lose context you might need. This is not how the web was supposed to work. The web was supposed to be a place you navigated to, found what you needed, and left. Instead, you live in a partial backup of your own thinking, because the substrate does not remember you.
Forms are the same problem in concentrated form. You start filling out a form. You get interrupted. You close the tab. When you come back, the form is empty. The system you were interacting with had no sense that you and it were in a shared activity; you were just a session ID that timed out, and now you are a new session ID with no history. If you are lucky, the form saved a draft. If you are unlucky, you start over. Either way, the burden of continuity falls on you.
A skeptical reader will object here. Some parts of the web do remember. E-commerce is the obvious example. Amazon remembers your purchases for years. Your cart persists. Your payment information is saved. The recommendation engine has built a behavioral profile of you that spans every visit you have ever made. This is not forgetting. This is memory at industrial scale. It is, and the objection is worth taking seriously. The simpler version of the argument I have been making cannot answer it. E-commerce has invested heavily in remembering. So has search, when you look closely — Google remembers your queries, your click patterns, your location history. So has every social platform, every email provider, every app on your phone. The page-era web has not been uniformly forgetful. It has been selectively rememberful.
But the remembering is asymmetric. The system remembers in service of itself, not in service of you. Your cart is held because held carts convert. Your payment information is saved because friction kills purchases. Your behavior is profiled because profiles generate upsell. The continuity exists, and it is real, but it belongs to the vendor.
E-commerce is the relatively honest version of this pattern, because the vendor remembering your cart is at least related to a transaction you wanted to complete. The less honest version is bigger and older and funds most of the rest of the web. I have spent most of my career adjacent to it, so I will describe it precisely.
The modern web runs on predictive advertising infrastructure. Its core economic engine is the systematic conversion of behavioral signals into high-fidelity targeting capabilities. In this market, the product is not the user. It is the fleeting, inferred likelihood that a person will take a specific action. That likelihood is refined out of vast amounts of harvested behavioral data and resolved, in milliseconds, into audience segments that are bought, sold, and bid against inside opaque DSP and DMP ecosystems. Your profile sits inside those systems as a proprietary asset. You have little visibility into, or agency over, the digital twin shaping what you see, what follows you, and how the web responds to you.
What I described is a system that was built on top of the page, not the page itself. The distinction matters. The page is a primitive. The advertising and data-brokerage layer is an industry that recognized what the primitive could be made to do, then funded the conditions under which the doing could continue.
This is the deeper truth about the page-era substrate. The page is not uniformly forgetful. The page is forgetful when remembering would help the user and rememberful when remembering helps the system. The asymmetry is the architecture. The user, in both cases, is left carrying the thread — either reconstructing context the system threw away, or living inside a profile the system holds about them and will not give back.
We adapted. We learned to hoard tabs. We built bookmarking systems and read-later apps. We invented password managers to restore continuity the browser did not provide. We installed ad blockers, privacy extensions, and tracker shields to protect ourselves from being remembered in ways we did not consent to. We learned to structure our lives around a substrate that either does not remember us at all, or remembers us in ways that serve someone else. All of this is compensation. All of it is the human carrying what the substrate would not.
You are the one holding the thread, and you have been doing it for so long that you no longer feel the weight.
This was always the cost of the graphical web. The system has just gotten better at extracting value from the parts of the thread it captures.
§
V.
The page has been dissolving for longer than most of us realize, and we have been naming each piece of the dissolution as if it were a separate phenomenon. It is not. It is one phenomenon, and it has been underway for a decade.
Consider the feed. Fifteen years ago, social content lived in pages — Facebook walls, MySpace profiles, blog archives. Each had a URL. Each was a stable object you could return to. Then the feed arrived, and the addressable unit vanished. A feed is not a page. You do not navigate to a particular location in it and expect to find the same content on return. You enter it. You scroll. What you see is generated on the fly, specific to you and this moment, and if you want to find the same thing tomorrow you will have a hard time. The feed is not addressable in the way the page was addressable.
Consider search. Traditional search returned a page of results — a list of addressable documents you navigated to. The newer generation of search, increasingly dominated by conversational interfaces, does not. You ask a question and get an answer. Sometimes the answer cites sources; sometimes it does not. The pages still exist underneath, but the user's primary interaction is no longer with the page — it is with the conversation that produced the answer. The page has become raw material for a different kind of interface.
Consider the application, as a category. For most of the graphical web's history, an application was a website you navigated to — a page, or a set of pages, at addresses you could bookmark. Today, many of the most-used applications have only nominal URLs. You open the app. You use it. The URL bar, if visible at all, is a vestigial organ, and the content you are interacting with is not a page in any meaningful sense. It is a view into a session, generated on demand, and when you close the app that view ceases to exist in the form you saw it.
Consider the single-page application, which has been eating the traditional web from within for more than a decade. A single-page application keeps a single URL while the content underneath it changes. The URL is a label on the container, not a reference to the content. Developers who have been building this way for years understand something their users mostly do not: they are no longer really publishing pages. They are publishing applications that happen to live inside the browser's page frame, and the page frame is decoration.
Consider the conversation, which is the most recent and most aggressive instance of the same pattern. When you use a conversational AI system, there is no page. There is only the conversation, accumulating. You can scroll back through your history. You can leave and return to the same thread. But what you are returning to is not a page. It is a state of an ongoing exchange, and the exchange does not exist apart from the act of exchanging.
None of these are failures of the web. All of them are the page as a primitive straining against uses the page was not designed for. The common thread across every one of these examples is the same: the unit of interaction is no longer the addressable document. It is something that has continuity, accumulation, and memory. It is something that remembers you and holds context across your comings and goings. It is not a page. It is a session.
§
VI.
Let me be direct about what I am claiming, because everything else in this essay turns on it. I am claiming that the primitive is changing. The organizing unit of how software works is shifting from the page to the session. Not as a metaphor. As the actual substrate. The thing future software will be built on top of, in the way that the web was built on top of the page.
A session is a bounded period of continuous interaction between a user and a system. It has a beginning. It accumulates history. It ends. While it is active, context persists: what you said ten minutes ago is available now, references to earlier parts of the exchange resolve without restatement, the system knows what you are trying to do because you are still doing it. Unlike a page, a session is not a static object you navigate to. It is an activity you participate in. It has no existence independent of the engagement.
Primitives shape what gets built on top of them. The page made certain industries possible and others impossible. The next primitive will do the same. The question is not whether a substrate is innocent — none are — but what each substrate's properties tend to invite into existence, and what we do with that knowledge before the building starts.
I should pause here, because a careful reader will object. Sessions are not new, the objection goes. The web has had sessions for decades — cookies, login intervals, shopping carts, application state. Feeds are sessions. Apps are sessions. We have been living inside sessions this entire time.
This is correct, and it is exactly the point. Sessions have existed for a long time, but they have existed as implementation machinery hidden behind pages. They were plumbing. What is changing now is not the existence of sessions but their place in the user's mental model. The session is moving from the backend to the surface, from infrastructure to primitive, from the thing that makes the page appear to work continuously to the thing the user actually enters, resumes, shares, and builds inside. That migration — from hidden machinery to the user-facing organizing unit — is the shift I am naming.
I also want to be honest about the word itself. "Session" is doing more work in this essay than it normally does. I do not mean a login interval or a chat transcript. I mean something closer to a durable, user-governed context: a continuous thread that accumulates intent, history, state, permissions, artifacts, and generated surfaces over time, and that persists across interruptions and devices as long as the user wants it to.
Consider, as a parallel, the word phone. The first telephones had almost nothing in common with the object you are probably carrying right now. They were wall-mounted, required an operator, and did exactly one thing. The device we still call a phone today is a general-purpose computer with a camera, a map, a library, a bank, and a social graph — and somewhere in the long list of its functions, the ability to make a voice call. The word survived the expansion because the core affordance — person-to-person contact across distance — stayed. Everything else grew around it. Nobody is confused by this. Nobody insists we need a new word. The word stretched to fit what the thing became. "Session" is going to do the same thing.
Some readers will still prefer a different word — context, workspace, thread, flow. I use session because it is already in the user's vocabulary and because its existing connotation of continuity-within-a-bounded-activity is roughly what I mean. The word may eventually change. The thing it points to will not.
This is a profound shift, and it is worth dwelling on what it changes.
The page's defining property was addressability: you could link to it, return to it, share it, find it again. The session's defining property is continuity: the substrate holds the thread for you. These are not compatible properties in the same object. A page that remembers you is no longer the same page. A session that is addressable in the way a page is addressable becomes a page, and loses what made it a session.
This is why the two primitives do not merely compete with each other. They require different infrastructure, different protocols, different mental models, and different user expectations. The web had to invent an entire stack — HTTP, HTML, URLs, browsers — to make the page primitive work at global scale. The session needs its own stack. Some of that stack already exists in fragments, scattered across AI products and messaging platforms and single-page applications. Most of it does not exist yet, or exists only in proprietary forms that cannot interoperate.
Consider, as an illustration, a working professional trying to coordinate a complex task — say, planning a project that involves information from multiple sources, decisions across multiple stakeholders, and a set of actions that need to happen in sequence. On the graphical web, this person lives in tabs. Email in one tab, spreadsheet in another, calendar in a third, reference document in a fourth, communication tool in a fifth. The continuity of their project lives nowhere except in their own head. They are the integration layer. They are the thing holding the tabs together.
In a conversational substrate, that same person has a session. The session is the project. Within it, the conversation accumulates — decisions made, questions raised, references gathered, actions taken. When structure is useful, a surface appears: a form to fill out, a view of the data, an approval gate for a specific decision. The surface is an instrument inside the conversation, not a destination outside it. When the surface has done its job, the conversation continues. The session remembers. The user does not have to.
This is not a product feature. This is a different architecture for how humans work with computers. It requires that the substrate do the remembering. It requires that interfaces be generated on demand, within context, rather than pre-built as static artifacts. It requires that the continuity live in the infrastructure rather than in the user's browser tabs, sticky notes, and mental effort.
It also, finally, delivers something the graphical web could not: flow. Flow is the experience of sustained, uninterrupted engagement with work that matters. It is what every worker in every field actually wants from their tools. The graphical web made flow hard by forcing the user to hold the thread through every navigation, every tab switch, every form reset. The session, as a primitive, makes flow the default rather than the exception. This alone is enough to justify the shift, and it is why I believe the shift is inevitable regardless of what we think about it.
The graphical web made flow hard by forcing the user to hold the thread. The session, as a primitive, makes flow the default.
§
VII.
The page's forgetfulness is not only a cost. It is also what made the web public, inspectable, and contestable. A page sits at a fixed address. Anyone can visit it. Anyone can link to it. Anyone can quote it, cite it, archive it, argue with it. If a journalist publishes a claim and later edits it, there is a version history somewhere. If a scientist posts a paper, other scientists can read the same paper the author published. If a government publishes a rule, citizens can read the rule the government actually published. The page is a shared external reality. It is imperfect and often contested, but it exists outside any one user's personalized experience of it. That property is civic. It is one of the things that made the web more than a consumer technology.
The session does not inherit this property by default. A session is private, personalized, mutable, and often proprietary. What happens inside a session is not automatically inspectable by anyone other than its participants. The context that produced a decision is not automatically available for audit. The answer a user receives from a conversational system is not necessarily the same as the answer another user would receive to the same question. A session-native substrate is more useful for the user inside it and much more opaque to anyone outside it.
There is a harder version of the same problem worth naming directly. When I write that the session remembers so the user does not have to, I am describing a property that can be liberating or surveillant depending on who owns the remembering. A session substrate held by a corporation is a substrate that watches everything its users do, accumulates that context into profiles their users cannot inspect, and monetizes or restricts access to it on terms the corporation sets. The convenience of continuity buys flow at the cost of handing over the memory of one's own working life to an actor whose interests are not aligned with one's own. Most of the session infrastructure being built today has exactly this shape. This is not the session primitive's fault; it is the consequence of building it inside the incentive structures of the current platform era. But it is a real risk and pretending otherwise is dishonest. The architectural question that determines whether the conversational era is liberating or surveillant is not whether the session will remember. It will. The question is who owns the memory. A user-governed substrate that lives under the user's control, with local storage and explicit consent for anything that leaves that control, is a completely different thing than a cloud-hosted corporate substrate with the same nominal function. Both fit the word session. They are not the same substrate.
This is a real problem, and it is not one the session inherently solves. It is one the new primitives must solve, or they will produce a world that is more convenient but less civic, less scientific, less trustworthy than the one they replace. The question is not whether we can build session-based systems. We already are. The question is whether we can build them in a way that preserves public inspectability, durable reference, and external accountability for the things that need those properties — while letting the session itself serve the continuity and flow it is uniquely good at.
Part of the answer will come from making the two primitives work together rather than treating them as competitors. A healthy conversational-era architecture is one where sessions can publish — where the work done inside a session can be exported as a durable, addressable, citable artifact when the occasion calls for it. A journalist using a session to research, synthesize, and write still needs to publish a page at the end. A scientist using a session to analyze data and compose an argument still needs to deposit a paper into a citable record. A lawyer using a session to prepare a filing still needs the filing to be a stable document with a fixed address. The session is the substrate of the work; the page is the artifact of the publication. Making this handoff clean — consent-respecting, durable, citable, verifiable — is one of the most important protocol problems of the next decade. It is not a problem the existing page infrastructure knows how to solve, because pages were never designed to be the outputs of dynamic private sessions. But it is a problem that must be solved, because without it the public record of the conversational era will be thinner than the public record of the page era, and we will have lost something civic that we could have kept.
This is partly why the page continues to matter, and why the argument of this essay is not that the page ends. Public knowledge, legal record, scientific citation, journalistic accountability — these need the page's virtues and will need them for a long time. What is changing is the fraction of interaction that happens on pages, and the corresponding need to invent new primitives for the things sessions will do that the page used to do badly. Some of those primitives — shareable artifacts, citable surfaces, verifiable session transcripts — do not exist yet. The essay I am writing is partly an argument that they urgently need to be built, and partly an argument about how little time we have to build them before the fragmentation hardens.
The page gave us shared reference. The session will give us continuity. The next substrate has to preserve both.
§
VIII.
Here is the part where careful language matters, because a lot of people are telling a different version of this story and most of them are wrong.
The conversational interface is not replacing the graphical one. The graphical interface is not going away. Anyone who tells you that you will soon be doing everything through a chat box has not thought about what happens when you actually need to fill in a structured form, compare three options side by side, drag-order a priority list, or approve a transaction by reviewing a precise visual layout of what you are approving. Natural language is not the right interface for all of these. It is not even the right interface for most of them. The graphical interface was a real invention that solved real problems, and those problems have not disappeared.
What is changing is the relationship between the two. In the graphical era, conversation was a feature inside an application — a chatbot pinned to the corner of a page that could maybe answer your questions about the product, if you were lucky. The page was primary; the conversation was a supplemental affordance. In the conversational era, the relationship inverts. The conversation is primary. The graphical surface becomes an instrument inside the conversation — summoned when structure is useful, dismissed when it is not. The form is still a form. The data view is still a data view. The approval gate is still an approval gate. What changes is that these surfaces no longer stand alone as pages requiring their own navigation and memory. They live inside a session that provides both.
This is the nuance that most of the public conversation about AI interfaces misses. The question is not whether graphical interfaces survive. They do. The question is which element is the center of gravity. For forty years, the center has been the page, and conversation has been peripheral. For the next era, the center will not be the chat box, either. The center will be the context — the persistent, accumulating thread that holds whatever interactions the moment needs, whether those are conversational, graphical, structured, spoken, or something we have not invented yet. The future is not chat-first. It is context-first.
The future is not chat-first. It is context-first.
If you are building a product in this space, this inversion is the thing to get right. Products built as if the graphical era were continuing, with conversation grafted on, feel like what they are: retrofits. Products built as if conversation has already replaced the graphical, with no surfaces at all, feel like what they are: experiments that refused to take seriously the things graphical interfaces actually do well. The products that work, and that will continue to work as this era matures, are the ones that treat the session as the primary construct and generate whatever interaction modes — conversation, surface, structured input, document — the moment actually calls for.
§
IX.
There is a reason the web became the web and not a thousand incompatible experiments, and it is worth remembering.
In the early nineties, before the web had stabilized, there were many competing hypertext systems. Some of them were, in their specific properties, more sophisticated than what became HTML. They had two-way links. They had bidirectional references. They had versioning baked in. They had all kinds of features that the winning system lacked. And they lost. They lost because the web converged on a small set of shared primitives — the page, the URL, HTTP, HTML — and the rest of the ecosystem could therefore build on top of that shared substrate. Browsers, servers, search engines, social networks, applications of every kind: all of them were possible because the primitives were common. Interoperability was not a feature of the web; it was the thing the web actually was.
The conversational era is currently in its early-nineties moment, and it is not clear we are going to make the same choice. Every major AI product today invents its own idioms for what a session is, how surfaces attach to it, how state persists, how actions are authorized, how a user returns to prior context. The result is fragmentation at the exact layer that should be standardized. Each product re-solves the same problems differently. A user's context is trapped inside whichever vendor's system they happen to be using. None of it interoperates. None of it composes. And the longer this goes on, the harder it will be to converge later, because each product will have accumulated years of divergent assumptions that retrofitting cannot undo.
There is a harder fact worth naming about why this is happening. The early web converged on shared primitives partly because it emerged from academic and public-sector infrastructure, where openness was an assumption rather than a business decision. The actors who defined HTTP, HTML, and the URL had no commercial interest in proprietary lock-in. Today's situation is different. The actors building the primitives of the conversational era are the largest commercial entities in the world, and their financial incentive is not convergence. It is the opposite. Every walled garden that captures a user's context, memory, and workflow becomes a source of recurring revenue and a defensible moat. There is no natural market force that will produce shared primitives in this environment. The convergence, if it happens, will have to come from somewhere else — from independent protocol work, from coordinated action by users and developers who refuse the lock-in, from institutions that remember what an open substrate looks like, or from enough smaller actors making compatible choices that the larger actors find themselves on an island. This is harder than the web's convergence was, and more uncertain. It is also the central political problem of the conversational era, and it is not being treated as one.
I should be transparent about my own position in this argument. I am not a neutral observer. I have been working on a specific proposal for what some of the shared primitives might look like — a protocol called the Session-Surface Protocol — which will be published in detail alongside this essay. It is one proposal among many that will and should emerge, and I do not claim it is the right one; I claim it is a serious attempt to make the thesis in this essay concrete. The reader should weigh the argument knowing that I have a stake in what happens next. I am not describing the situation from outside it. I am trying to shape it from inside it. Hiding that stake would be dishonest. Naming it lets the reader judge with full information.
What matters in the essay is that you come away convinced that the shift is real, that the stakes are real, and that the moment for choosing is now. The primitives we converge on over the next few years will be with us for decades. Everyone who will ever build anything in the conversational era will be building on top of whatever we settle on. The weight of that decision is not going to be distributed evenly across the industry. A relatively small number of people, working on a relatively small number of projects, will make choices that everyone else then lives inside. This has always been how substrates get made. The only question is whether the people making those choices are accountable to the users who will live inside them, or accountable only to the companies that employ them.
§
X.
One more act of transparency, because it is relevant to the argument this essay is making.
This essay was written in collaboration with an AI, a system called Claude. Not as a cosmetic assist — not as a grammar check or a prose polish — but as a genuine intellectual partner across many days of conversation, argument, and pressure-testing. The thesis you have just read emerged through that collaboration. The framing, the sequencing of ideas, the specific metaphors that made the argument land — all of it was produced in a working mode where Claude pushed back on my claims, surfaced trade-offs I had not seen, and refused to let me settle for the easy version of a thought when a harder version was available. The relationship was, in substance, a peer intellectual partnership.
One moment is worth describing specifically. When we began working on the protocol that produced this essay, I was certain the right architecture was an invocation-scoped primitive — something that would appear when the moment called for it and vanish immediately after. Claude pushed back. The argument was that a surface living inside a session should inherit the session's lifespan; invocation-scoping was importing URL-era assumptions into a substrate, those assumptions no longer fit. I resisted. Session-scoping seemed to open problems I could not see my way through. We went back and forth for a long time, neither of us willing to concede a position we were each certain of for different reasons, until we arrived somewhere neither of us had started: time-bounded action-scoped surfaces, which honored the continuity Claude was defending and the ephemerality I was defending at the same time. That was the moment the collaboration stopped feeling like me using a tool and started feeling like me working with a partner. Neither of us could have arrived there alone. The argument itself was the thing that produced the answer.
I note this for two reasons. First, honesty: readers deserve to know how the thing they are reading was made, and pretending this was solitary work would be a small lie that corrodes the larger argument. Second, and more importantly, the mode in which this essay was written is itself an instance of the thesis. The conversation that produced these words was a session in exactly the sense this essay has been describing. It accumulated. It remembered. It let me work in flow with a collaborator whose contributions were real. A substrate that holds the thread does not just change how users interact with software. It changes how thinking gets done. Work that would once have happened in isolation now happens in partnership, and the partnership has a shape that did not exist until very recently.
I do not know how we will eventually credit work like this. The old conventions of authorship were built for a world in which the author was obviously a single human. That world is already changing, and the essay you have just read is a small piece of evidence for how it is changing. I chose to put Claude's name on the byline because it was honest. Other authors are making other choices, and some of them are hiding the collaboration. I think the hiding is a mistake, and not just because it is dishonest. It is a mistake because it denies the reader the chance to see what is already happening, which is that a new mode of intellectual work is emerging, and the people who learn to do it well will have an enormous advantage over the people who do not.
Substrates change how work gets done. This is what substrates are for.
§
XI.
I want to end where I started, but with a different emphasis.
The page has been with us for thirty years. It shaped the web. It shaped how a generation of software was built. It shaped, in ways most people never notice, how we think about what information is and how we access it. The page served us extraordinarily well, and the global knowledge commons it produced is one of the real achievements of recent human history.
It is also ending. Not all at once, not tomorrow, not in a way that erases what the page accomplished. But the primitive is losing its centrality. Something else is taking its place — something that remembers, accumulates, holds the thread so we do not have to. The session. I have called it that throughout this essay because I believe that is the right word, and because language matters when a new thing is being named. Whatever we eventually call it, the shift is underway, and the early evidence is all around us. Every feed, every conversation with an AI system, every app without a URL, every moment of flow that used to be impossible and now is not — all of it is the same phenomenon, and it is bigger than any of its individual instances.
I have spent my career watching paradigms transition. I have been wrong about some of them, right about others, and mostly I have learned to be suspicious of my own certainty. I am as certain about this one as I have been about any of them. The page is ending as the primitive of interaction. The session is beginning. The primitives we choose now will carry us into whatever comes next, and the people who understand the stakes will shape what the next era looks like.
I wrote this essay because I think the moment deserves to be named clearly, and because I think most of the public conversation about AI interfaces is missing what is actually happening. It is not about chatbots. It is not about replacing software with magic text boxes. It is not about any specific product. It is about the substrate. The substrate is changing, and what is possible in the next era depends on how we handle the change.
This is what comes after the page. It was worth naming. Now the work begins.
