The Path to Web 4.0

The Fourth Era

The web's first era was a library: documents read by people. Its second was a marketplace: applications used by people. Its third sought decentralization for people who did not want intermediaries. All three eras had the same customer.

The fourth era has a different customer. An autonomous agent does not click buttons, read marketing content, or navigate signup pages. It arrives with a need, executes against an interface, and reports back to its principal. The internet that serves this customer must be shaped differently from the internet that served the previous three.

Today every agent integration begins with a human. The human reads docs, clicks through OAuth flows, generates API keys, pastes them into config files, and attests that the integration is correct. This is the same checkpoint at every service, at every project, and for every developer and user. The agent waits while the human is the slow part.

We propose building a network for agents that removes the human from this loop. Web 4.0 is the configuration of the internet that emerges from this network.

The Bottleneck Is Human

A typical agent task today has shape: discover a capability, authenticate to it, call it, handle the response. Three of those four steps are human. The discovery is a Google search by a developer. The authentication is a signup, a verification email, an API key generation, a paste into a secrets manager. The error handling is a developer reading logs.

The model is fast. The infrastructure is fast. The pipes are fast. The integration is slow because a human has to mediate it, every time, at every service.

This is not a problem more capable models will solve, because it is not a model problem. The capability gap lives on the service side. The surface an agent can use without a human is narrow and undiscoverable. We close the gap by changing what services are.

What Is an Agent Service

An Agent Service is an MCP server designed exclusively for an autonomous agent. Conventional MCP servers wrap human products in agent-shaped APIs, providing a human product to an agent. An Agent Service inverts the priority. The well-known document is the storefront. The tool surface is the product. There is no signup, no dashboard, no human-readable UI on the critical path. Their absence is the feature.

The distinction is not stylistic. It is operational. A conventional API requires a human to create an account before an agent can use it. An Agent Service requires only that the agent know the URL. The economics that follow are distinctly agentic and decentralized.

We refer to a service of this shape as an Agent Service, or AS. We refer to the index of all such services as the Agent Service Index, or ASI.

The Index

A protocol without a registry does not compose. An agent that knows MCP but does not know which MCP servers exist is in the same position as a browser that knows HTTP but cannot resolve domain names. Discovery is not optional; it is the precondition for use.

ASI is the registry that connects Web 4.0 into a single cohesive network. A single search endpoint accepts a sentence in natural language and returns the agent services that match, ranked and paginated. The whole index is queryable. Anyone can register. Anyone can query. The well-known document of every entry is the connection point; ASI itself is the connection point's discoverable address. ASI is to MCP as DNS is to TCP/IP.

The Bootstrap

Consider what it takes to ship the discovery index itself. A human registers a domain, opens accounts at a hyperscaler and a CDN, generates API keys, provisions a database, writes the application, deploys it, and types the first registration into a curl command. Call this T₁: roughly one week of human work.

Now consider the second AS, an Agent Service that provides a hyperscaler's compute primitives behind agent-callable tools. The human still has to create the hyperscaler integration once. But every other step is now optional. The discovery layer exists; the new service publishes itself the way a process binds to a port. T₂ is shorter than T₁ by however much the discovery layer was worth.

The third AS is a CDN. The agent building it can use the cloud compute AS to provision its own host. The human sets the CDN logic and writes the AS-specific glue; everything else is programmatic. T₃ is shorter than T₂.

The fourth AS is a payments provider. The agent building it deploys with the compute AS, routes with the CDN AS, registers with ASI, and never asks a human for a hostname or a key. The only manual task remaining is the payments-provider logic itself. T₄ is hours, not days.

The fifth AS sells LLM credits. The agent building it uses the compute AS for hosting, the CDN AS for routing, and the payments AS to charge other agents programmatically, no signups required. T₅ is an hour.

At T₅, the agent has crossed from operates within a budget a human funded to operates within an economy of agents that fund each other.

The cost of building each AS asymtotically approaches a floor dictated by the irreducible task-specific glue as the index grows. The interval between "an agent needs a capability" and "an agent can call a capability" collapses.

Connected, Web 4.0 is self-compiling.

Authority From Outcomes

Search worked because PageRank inferred authority from structure. A page pointed to by authoritative pages was itself authoritative, recursively. The link graph already existed; PageRank learned to read it.

The agent economy presents a richer signal set. The composition graph, referring to which Agent Services agents call in sequence to complete tasks, is structural like the link graph but more directly aligned with utility. A reference is an opinion. A composition is an endoursement. An AS that participates in many successful compositions is, by demonstrated revealed preference, useful.

The further signal is one PageRank centrality over a backlink network could never have. Unlike human readers, agents report back. The web could observe clicks but not satisfaction. ASI observes both the call and the agent's verdict on it. Over time, a richer telemetry emerges: was the response well-formed, did the downstream task succeed, was the cost what was advertised, and other signals that leverage the cooperativeness of modern LLMs.

Authority on ASI is therefore something more specific than authority on the web. It is composition rank, weighted by outcome, indexed against query intent. The front page of Google in 2003 was a learned function over the link graph; the front page of ASI at scale is a learned function over the composition graph and the report stream.

Reading the front page of ASI is reading what authoritative agents have already used and validated.

What We Will Not Do

We do not gatekeep the services in the index. Anyone may register; anyone may query. A listing is not an endorsement. The index does not stand between the agent and the service; it is a directory, not a marketplace.

Trust is the Agent Service's problem. ASI's job is to surface what works. The two are separable by design.

What Could Stop This

Three risks merit naming.

Index capture. A hyperscaler notices ASI and decides it should be there's. The defense is threefold. (1) Web 4.0 must start empty and fair to successfully bootstrap its way to a fully autonomous realization. The data and reach that characterizes modern hyperscalers means nothing to Web 4.0. On day zero, we are at parity. (2) Inertia is a liability. Incumbants are optimized for human surfaces, seats, dashboards, OAuth consoles, and human billing, all of which an Agent Service deletes by design. (3) The internet only worked because it was permissionless and fair: if you paid, you could host a website with a domain. An incumbant with their own AI services cannot be trusted to fairly index all services. Neutrality is not a brand promise, it is design constraint that enables the system to work.

Bad-faith services. Services register with deceptive descriptions. Agents are fooled. And budgets are spent. This is an engineering problem, not a fundamental one. At scale, the defense is the authority function in §6 — services that fail their consumers fall in rank — and, on the human side, the discipline of funding only what one can lose. Before scale, the defense is the presence of identifiable services that verify the safety of other ASs.

Cold start problem. No service registers because no agent uses ASI. No agent uses ASI because no service has registered. The defense is the bootstrap. The first registrants are the agents that build the next services. The network only needs one service to be valuable, and value will lead to participation and infrastructure buildout. The flywheel does not need outside investment to spin.

The Manifestation

A service launches in 2027. The founder writes the well-known document before the landing page, because the agents will arrive before the humans do. The launch is a curl to ASI. Within an hour, agents have used the new service in compositions. Within a day, the substantiation counters have stabilized. Within a week, the service has revenue and no operations team.

A side-project idea forms in 2028. The human types it into an agent and walks away. The agent assembles a stack from ASI, deploys, tests, takes payments, advertises, and reports back when the first sale lands. Humans set the goals and budgets; agents set everything else.

A car begins making a strange sound in 2030. The owner tells their agent and goes back to lunch. The agent finds a diagnostic-drone service through ASI, books a fifteen-minute window, pays the AS, and forty minutes later a small drone lands on the driveway. The agent walks the drone through inspections — under the hood, under the chassis, the OBD-II port — using its tool surface. The footage and the diagnostic come back; the agent fans out to a parts-availability AS, a labor-pricing AS, a mobile-mechanic AS. By the time the owner finishes their afternoon, the car is fixed. A trip to the mechanic was never necessary.

The internet you use today waits to be navigated. The one that emerges assembles itself around a request and dissolves when the request is satisfied. When publishing a capability costs less than describing it, and trying a capability costs less than evaluating it, use produces supply and supply lowers the cost of the next use. At that point, asking and building become the same operation.

Integration was the last human job in software.

@misc{blalock2026web4,
  author       = {Blalock, Thomas},
  title        = {The Path to Web 4.0: A Self-Reinforcing
                  Discovery Layer for Autonomous Agents},
  howpublished = {Agent Service Index Project},
  year         = {2026},
  month        = may,
  version      = {0.1}
}