A web that no human ever visits, and what that means for everything built on top of it.
For thirty years the web rewarded perusal. The next one rewards results.
The web we have was built for browsing. Pages sized for screens. Type at reading distance. Hierarchy for scanning. Search engines counting clicks. Analytics counting linger. Brands competing for what you will remember. The whole stack runs on one assumption: a person is on the other end, working through it in real time, and the value of the visit is in the visit itself.
That assumption is so deep most of us have stopped noticing it. The web is not a neutral medium. It is a presentation layer, optimised over thirty years for one mode of reading — slow, exploratory, attention-rich. Pages were the medium because, for thirty years, perusal was the only way a human could resolve their intent into an outcome. Looking, comparing, deciding, clicking. There was no other way to get from I want something to I have it.
The web is not just one layer of digital infrastructure among several. It is where modern life happens — where people work, shop, learn, find services, find each other, find themselves. Right now, two parallel motions are building the agentic substrate underneath all of that. Computer Use and browser automation reach outward from the agent into the legacy web that wasn't built for them — bridging, adapting, using the human surface to get the work done. Native connectors reach inward, into applications' own scripting and capability layers — Claude inside Blender drives the Python API directly, the way a Blender developer would; Adobe ships fifty pro-grade tools as a single connector. Both motions are real, both are necessary, both are the substrate growing.
The economics pull one direction. Tokens are the currency of the modern AI economy. Every screenshot, every DOM parse, every reasoning step needed to interpret a human-facing surface is paid for in tokens. Native interfaces — purpose-built API calls, structured capability advertising, efficient introductions — cost a fraction of what bridging costs. Multiplied by the scale of agentic interaction this is arriving at, the difference is the difference between affordable and not.
And then the network effect changes the curve entirely. Each productive node added to the agentic web doesn't just become individually addressable — it becomes collaborative with every other connected node, through agents as the orchestration layer. Blender plus Adobe is a workflow as soon as both have agentic nodes; the producer in Ableton can route their work through Splice's sample library and Adobe's renderer and Blender's modelling without anyone having built bilateral integrations. Adobe's apps talking to each other stops being a competitive moat the moment everything talks to everything else through a shared substrate. The capability surface multiplies combinatorially. The web of agents grows non-linearly because every node is simultaneously a productive surface and a collaborator.
The chat is where the human meets the web now. Not at a homepage. Not on a landing page. In conversation, with an agent. The browsing happens there. The comparing happens there. The weighing, the deciding — all of it, in dialogue. By the time anything reaches the website, the choosing is over. What arrives at the site is the action.
The website is no longer where intent gets resolved. It is where the resolved intent gets executed. The chat became the perusal layer. The site became the action layer. Two different jobs, two different surfaces, two different readers.
This is happening across the application layer too. In late April 2026, Anthropic and a coalition of major creative software companies — Blender, Autodesk, Adobe, Ableton, Splice, Affinity by Canva, Resolume, SketchUp — launched Claude for Creative Work: the entire creative production stack, across 3D, 2D, video, audio, live performance and architecture, simultaneously made agent-readable from inside the chat. Adobe alone shipped fifty pro-grade tools as a single connector. Anthropic joined the Blender Development Fund as a patron; the Blender connector is built on MCP, accessible to other LLMs as well. The chat is where the creative work begins. The visual workspace is no longer where it has to.
Warp went further the same day. The terminal company open-sourced their entire client and rebuilt contribution itself around agents — contributors don't write code directly any more, they go through agents that orchestrate the implementation. OpenAI sponsors the repo. The chat is now where developers contribute to the software they help build. Another surface where the work begins.
And from the agent's side, the website looks different. Hero images do not register. Typography does not land. Microcopy does not charm. Testimonials do not get skimmed. Trust badges do not get noticed. The entire visual layer — the part most websites spend the most money on — is not in the picture. The agent reads the page the way a forensic accountant reads a love letter: looking for structure, intent, capability. Everything else is overhead.
Agents are doing something strange. Reading a medium that was not built for them. Browsing, clicking, screenshotting, parsing the DOM. Recovering meaning from interfaces that were never meant to give it up.
It works. The result comes back. But almost everything between the request and the result is work the agent has to do because the page is shaped for someone else. Every screenshot, a translation cost. Every parse, a token cost. Every interface change, a brittleness cost. Every cookie banner, every modal, every consent flow, a friction cost. None of it is the work itself. All of it is the work of getting to the work.
What's emerging in the field — browser automation, computer use, screenshot reasoning — is one way to bridge the gap, and most of the work to date has gone into it. It works. It is also the agent web grafted onto the human web, which is not the same thing as a web built for agents.
The good news: the digital substrate is generous about this. Unlike a city or a road network, a new layer of the web can be added in parallel to the old one — cheaply, deliberately, while the old one keeps running. The agentic web does not have to wait for the visual web to end. It can grow alongside it.
The moment the agent becomes the primary reader, every assumption underneath the old web starts to wobble. Layout was for human eyes. Branding was for human memory. Search was for human queries. Commerce was for human attention. Identity was for human verification. None of it was designed for a medium where the visit is invisible and the result is everything.
That is when I started seeing a different web.
If the medium changes, someone has to build the new one.
Late 2024. Anthropic ships MCP. The conversation around it is about plumbing for AI-assisted development — coding assistants reaching databases, agents calling APIs, integration glue for software workflows. That is the use case Anthropic launches it for. That is the use case the discourse extends. Power-user feature. Narrow but useful. The kind of thing you note and mean to come back to.
I read the same protocol release. What I saw was a different shape entirely.
The same substrate that lets a coding assistant reach a database lets any agent reach any capability. It doesn't care whether the capability is a Postgres query or a Shopify catalogue. It doesn't care whether the agent is a coding assistant or a personal assistant booking a flight. The same plumbing carries both. Which means the agent web is not a developer tool waiting to scale — it is the next medium through which people find, transact, and decide. And the visual web, the one that took thirty years to build, is the wrong medium for it.
That read was not in the discourse around MCP, because the discourse was somewhere else. It came from looking at the protocol itself, in the months when the conversation had not yet caught up.
Once you see it, you cannot unsee it. The visual web is a poor fit for agents, and the next medium would need shaping by a lot of forward-looking people, in a lot of places. I wanted to be one of them.
I did not have a platform for that. No standards-body seat, no public work in the space, no network in the rooms where this kind of architecture gets discussed. So I started building — to take the read and make it concrete enough to test. The code was where the thinking happened: design decisions that look clean in the abstract reveal themselves the moment you have to ship them. And once it existed, it was something to point at.
Two integration directions follow from this read, and they are not opposed. Agents have to be able to use the web that exists — that work is necessary, because legacy will outlive any of us. The web can also grow a new layer better suited to agents — that work is cheap, because the digital substrate allows parallel construction. The two compound.
Both directions converge. Whether a site exposes structured tools natively, or a gateway service adapts a legacy site on its behalf, the agent-facing surface speaks the same protocol. The native architecture of the agentic web is the shared destination of every integration strategy. Which is why I built the protocol first.
I called it MCPI — Model Context Protocol Integration. The Integration was the load-bearing word. The design held two paths together: a specification for a web where agents are first-class readers, and a gateway service that could give a business or person a unified agent-readable interface without rebuilding anything. A small business could subscribe, connect their existing tools — Shopify, Facebook, Google Workspace, calendar, payments — and present a single coherent identity to the agent web: their inventory, their availability, their bookings, their inbox, their brand. The vision was that anyone could be in the agent web tomorrow, layered over the SaaS they already use, without waiting for any of those vendors to ship native support. DNS-based discovery so the agent could find either path under the same name. A Hello Protocol for context-aware introduction. A plugin architecture for capability advertising. A trust layer for referrals. Brand metadata so a site could ship its identity — colours, type, tone, voice — as structured data for the agent to render. A Chrome extension to test it all against a real site.
The smallest piece of it carries the most weight.
An agent encounters a website. Today, it does what a human would do — it loads the page. Then it does something a human never has to do: it reverse-engineers the page back into structured meaning. Every visit is a parse, a guess, a reconstruction.
The Hello Protocol replaces all of that with a question and an answer.
The agent asks: what are you, and what can you do?
The site answers: I am a store, here are my categories, here are my capabilities, here is who I trust, here is how to transact, here is who I refer to.
No HTML. No DOM. No screenshot. No parsing. The site tells the agent directly, in a structure built for the reader on the other end.
And it adapts. A shopping agent, a research agent, and a support agent all asking the same site the same question get three different answers — not because the site has multiple identities, but because what the site needs to say about itself depends on what the agent is trying to do. The introduction is contextual, generated in conversation, shipped in the form most useful to the recipient. The site stops handing back a single rendered page and starts contributing to whatever experience the agent is building on the user's side.
This is not an optimisation. It is a category change. Once a site can introduce itself this way, the visual layer becomes optional. Useful when a human shows up. Skippable when one doesn't.
When I started building MCPI, I knew immediately that DNS records were the right root for agent discovery — same way email and websites are addressed. I prototyped with what was accessible: a TXT record, _mcp.example.com TXT "v=mcp1 endpoints=…". It works. But it has always been a workaround for what the architecture really needs — a first-class, MX-style record that lets a domain say, for agent-directed traffic, contact this host. The dynamic intelligence — capability negotiation, trust, load — sits at the resolver behind the record. DNS is just the bootstrap. MX exists not because email was impossible without it, but because the substrate needed a clean, standardised routing primitive. The agentic web has the same need and no equivalent yet. Email's substrate solved this in the 1980s. The agentic web's hasn't.
And once the native architecture exists, the integration strategies arrange themselves around it. Sites can adopt the native protocol directly. Sites that won't can be wrapped by gateway services that speak the protocol on the agent-facing side, adapting to whatever those sites already are on the legacy side. Browser automation continues to handle whatever falls through. The strategies look different from the outside, but they all converge on the same agent-facing destination — the native architecture is what the agent meets, regardless of what is behind it. That is why MCPI was a specification first, and a gateway service second. The protocol had to exist before the gateway had something to translate into.
The architecture I read in MCP in early 2025 is what the industry has built since. Not because I shaped it — I didn't — but because the read was correct. The shape was implicit in the protocol; I happened to see it early, when most of the conversation was about something else.
Every shape MCPI was sketching now has a named, shipping form in the broader standards work. A2A formalises the trust and referral layer. WebMCP is the direction the Hello Protocol and plugin architecture pointed at — sites exposing structured tools to agents, eliminating DOM scraping. MCP Apps formalises the perusal-layer migration directly: servers return interactive HTML rendered inside the chat, the shift the brand metadata in MCPI was reaching for. A2UI takes the brand-as-structured-data thesis a step further — generative UI shipped portably across agents, rendered by the receiving side. Pay per Crawl answers a question MCPI flagged early: how does the substrate get paid back? The water cycle problem became one of the first economic questions the protocol layer started taking seriously.
In late April 2026, Stripe used their annual Sessions conference to position the company as economic infrastructure for AI, with agentic commerce at the centre. The Universal Commerce Protocol with Google lets customers buy products inside Gemini and AI Mode. The Machine Payments Protocol, co-authored with Tempo, gives agents programmatic transaction primitives — microtransactions, recurring payments, streaming payments. The Agentic Commerce Suite lets any business become agent-ready by uploading their catalogue. Treasury accounts can now be opened in the agent's name, with cards issued for agents to make purchases autonomously. As part of the same launch, Cloudflare and Stripe co-designed a protocol for agents acting on behalf of users to provision accounts, register domains, start paid subscriptions, and deploy production code — across vendors, with budgets the agent can spend without ever seeing the credit card. The Concierge Agent vision was MCPI's sketch of this whole layer: every domain having an intelligent representative that handles intent, capability matching, multi-vendor coordination, and trust-network compensation. The agent web doing commerce on the user's behalf, across vendors, through a vendor-neutral substrate. It is shipping in working form.
The correlation across all of these is strong — and the architectural direction MCPI was pointing at is the same direction the standards bodies have since built out. That is the through-line worth flagging.
Around the same time, Sam Altman, the head of OpenAI, publicly named the same architectural gap: "feels like a good time to seriously rethink how operating systems and user interfaces are designed (also the internet; there should be a protocol that is equally usable by people and agents)." A protocol equally usable by people and agents. That is the native architecture this piece has been describing — and that MCPI was designed to embody fifteen months earlier.
I was taking the read seriously enough to be in the MCP working group from its early days, bringing the consumer-web read into a conversation that was, at that point, focused on developer use cases. Once the standards bodies started extending the substrate in the wider direction, shipping the gateway service alone would have forked the ecosystem rather than helped it consolidate. The gateway stayed at the design stage. The work shifted: from building MCPI, to bringing its reads into working-group conversations, to writing about what the protocol layer is now opening up but not answering. The form changes. The seriousness doesn't.
Because the interesting question is not which protocol wins. It is what gets built on top.
There are two architectural directions for AI and the web. They look similar from the outside. They are not the same.
Agents that interact with human UIs
Automation of the current interface layer
Coordination across existing services
Solving today's problems today
Structured capability APIs
The visual layer becomes optional
The web restructures around intent
Solving tomorrow's architecture today
The first is necessary. It bridges where we are to where we are going. Browser automation, computer use, screenshot reasoning — these will exist for as long as legacy websites exist, which is to say, forever.
The second is the one I find more interesting. It asks what the web should look like once we stop pretending the agent is a person.
Inside the next web, you express an intent. Your agent figures out where to go. Sites respond with capabilities, not pages. The result comes back rendered by your agent, in your preferred form — to your screen, your voice, your wearable, your wall.
The visual layer does not disappear. It moves. From the site to the user. From the brand to the individual. From the page to the rendering surface. The site no longer controls the experience. It controls the identity. Colours, type, tone, voice, values, edges — shipped as structured data, interpreted by the user's agent, on the user's terms.
So brand strategy stops being "design an experience" and becomes "define an identity that survives any rendering context." A brand has to be itself when it is read aloud by a smart speaker, summarised by a research agent, or quoted in a multi-vendor bundle assembled by someone else's AI. None of those surfaces are under the brand's control. All of them are now where the brand is met.
Ecommerce changes shape under the same pressure. The storefront is no longer a place. It is a capability surface — inventory, pricing, fulfilment, returns, all addressable. The "shop" is wherever the user happens to be standing. The competition is no longer who builds the prettiest page. It is who is most useful to the agent acting on the user's intent.
Search changes too. It stops being "ten blue links" and becomes resolution — the right capability, found, vetted, called. Whoever shapes how agents resolve intent into action has the same kind of leverage Google had over the human web. Possibly more.
And identity. A personal site stops being a homepage and becomes a machine-readable introduction. What you do, what you offer, who you trust, how to reach you — shipped once, rendered everywhere. The page you used to build for visitors becomes the manifest your agent presents on your behalf.
Each of these is the same story told at a different layer. The site stops being where the experience happens. It becomes the source of the data the experience is built from. The rendering moves to the user's side. The control moves with it.
There is a deeper question hiding under all of this, and it is the one most likely to break the agentic web before it gets built.
The old web ran on a kind of water cycle. People made things. Other people read those things, were inspired, made more things. Forums, blogs, wikis, journalism, open source — all grew out of the same loop: contribution feeding consumption feeding contribution.
An agentic reader replaces the human one and consumes at industrial scale. It does not, on its own, return anything to the systems that produced what it read. If the only economic relationship between agents and the web is extraction, the web stops producing what makes the agents useful. The reservoirs run dry.
Cloudflare's Pay per Crawl, introduced in mid-2025, is one mechanism for this. It lets sites charge AI crawlers using HTTP 402 — a status code that has been sitting unused in the spec for thirty years, waiting for exactly this moment. There will be others: referral economics, subscription bundles, agent-side budgets, micropayments, content licensing, structured data pricing tiers. What I notice underneath all of them is the same dynamic: an agentic web that consumes at industrial scale without putting anything back is a system whose substrate stops renewing. The shape of the reciprocity matters less than whether reciprocity exists.
This is not a policy concern bolted onto the architecture. It is part of the architecture. A web designed for agentic consumption without economic reciprocity is a web designed to dry up.
The protocol infrastructure is being built — by Google, Anthropic, OpenAI, Microsoft, the W3C, the Linux Foundation, Cloudflare, and others. A2A, MCP Apps, WebMCP, A2UI, Pay per Crawl, the broader MCP ecosystem. Real teams, real momentum.
The architectural plumbing is the part of the transition that gets the most attention because it is the part that consolidates first. It is also the part where the answers are easiest to converge on. Below it sits the wider set of questions this piece has been circling.
What does a website become when no human ever visits it. What does a brand mean when it cannot control a single pixel. What does ecommerce look like when the storefront is a capability and the agent decides which one to hand the user's money to. What does identity look like when an agent is acting on your behalf, and the site you are transacting with never sees you.
What does taste look like when curation, layout, and tone all happen on the user's side, rendered by the user's own AI according to the user's own preferences. What does discovery look like when the question stops being "what should I show this user" and becomes "what would this user's agent reach for, and why."
How do creators get paid in a substrate that consumes them at industrial scale. How do agents acting on someone's behalf maintain consent and accountability across long-running tasks. How does the legacy web get brought along, or does it not.
These are not single-discipline questions. Each of them sits across protocol, product, design, brand, economics, and the lived human experience of the resulting system. They are the next set of rooms.
I think these questions deserve more thought. That is part of why I am writing this — to put my own attempts into the conversation, and to find others doing the same.