Enterprise AI today feels strangely familiar: The infrastructure is powerful. The capabilities are real. The demonstrations are impressive. Models can write, summarize, reason, code, search, retrieve, translate, classify, plan, and increasingly act. The raw machinery is there.
And yet, inside companies, the same pattern keeps repeating: pilots everywhere, transformation nowhere near the promise. The first article in this series argued that large language models were never built to run a company because companies operate through memory, context, feedback, constraints, state, incentives, and dependencies — not through isolated sequences of text. The second argued that enterprise AI must move from answers to outcomes, from prompts to constraints, and from copilots to systems of action. The third argued that when enterprise AI finally works, it will not look like a better chatbot. It will look like intelligence embedded into the organization itself.
The next question is obvious: If all of that is true, where are we in the historical cycle?
My answer is simple: Enterprise AI is in 1991. It has TCP/IP. But it does not yet have the web.
The internet worked before the web
The analogy matters because it prevents us from confusing infrastructure with industrialization.
In 1991, the internet already worked. TCP/IP moved packets. Email connected people across institutions. FTP moved files. Telnet enabled remote access. Universities, research labs, and technically sophisticated organizations could use the network. But for a normal company, the internet was still not a business environment in the modern sense. It was powerful, but not yet consumable.
Then the World Wide Web added a thin but decisive layer: URLs, HTTP, HTML, servers, and browsers. CERN’s history of the web explains that by Christmas 1990, Tim Berners-Lee had already defined the basic concepts of HTML, HTTP, and URLs, and written the first browser/editor and server software. In 1991, CERN released the WWW software more broadly and announced it on internet newsgroups, allowing the idea to spread beyond its original context.
That layer did not invent networking. It made networking legible, usable, and buildable for the rest of the world.
That is exactly the distinction that enterprise AI is missing today.
Models are not the web
Large language models are extraordinary infrastructure. They are probably one of the most important technological substrates of our time. But infrastructure is not the same as an application layer.
A company using LLMs today often resembles a bookstore trying to sell online before the web existed. The network is there. Packets move. Servers exist. But every transaction would require custom machinery: custom protocols, custom interfaces, custom logic, custom deployment, custom integration . . . custom everything.
That is not commerce. That is engineering.
This is why the current enterprise AI market still depends so heavily on pilots, bespoke deployments, forward-deployed engineers, and consulting-heavy implementations. The problem is not that the underlying intelligence is fake. It is that the layer that makes it consumable by ordinary organizations is still immature.
A model can generate an answer. But a company needs a system that knows where that answer fits, what data it can use, what constraints apply, who has permission to act, what process is being affected, what outcome matters, and how the system learns from what happens next.
That is not a prompt. That is a missing layer.
The missing layer has specific properties
This is the important part. The gap is not vague. It is identifiable.
Enterprise AI does not simply need “more AI.” It needs the equivalent of the web layer: a structured application layer that turns raw intelligence into something organizations can use repeatedly, safely, and at scale.
That layer has to provide at least seven things:
- Persistent context: The system cannot behave as if every interaction begins from zero.
- Business semantics: It must understand customers, products, policies, workflows, roles, and constraints in company-specific terms.
- Process state: It must know where work is, what has happened, what is pending, and what depends on what.
- Permission and governance models: It must operate inside organizational boundaries, not around them.
- Feedback loops: It must learn from outcomes, not merely generate outputs.
- Interoperability: It must connect to systems of record, tools, data, and workflows without bespoke reconstruction every time.
- Repeatability: It must be deployable as architecture, not as artisanal consulting.
This is why Anthropic’s recent emphasis on context engineering is so revealing. Its engineering team explicitly describes context as a critical but finite resource for agents, and argues that the challenge is now to curate and manage the information that surrounds the model — not merely write better prompts.
That is the direction of travel: The model is no longer the whole product. The environment around the model becomes the product.
The second analogy: Pre-ERP enterprise software
The web analogy explains the missing application layer. But there is a second analogy that is just as useful: Enterprise AI is also in the pre-industrial phase of enterprise software.
Before ERP systems became standardized platforms, corporate software was often a patchwork of custom implementations, integrations, internal systems, and consulting projects. SAP’s history shows the long arc from specialized business software toward enterprise application platforms, with SAP eventually becoming the market leader in enterprise application software.
That evolution mattered because it did not merely digitize individual functions. It industrialized a way of representing the company: finance, inventory, procurement, manufacturing, HR, logistics, and reporting became standardized enough to create repeatable implementations and a partner ecosystem. The same happened later in CRM and SaaS. Salesforce’s own history shows how AppExchange became a marketplace for independent software vendors and applications, turning Salesforce from a product into a platform ecosystem.
That is the difference between a category that depends on custom projects and a category that scales.
Today, enterprise AI is still too often stuck in the custom-project phase. Each company needs its processes mapped, its data cleaned, its permissions understood, its workflows reconstructed, its constraints encoded, and its outcomes defined. That work is necessary. But when it has to be done manually in every deployment, it proves the platform layer has not yet arrived.
Why the next winners may not be the model providers
This is where the analogy becomes strategically uncomfortable: In the web transition, the critical question was not who owned the cables. It was who defined the layer that made the network usable. In enterprise software, the critical question was not who owned the database or the server hardware. It was who defined the system of business representation and built the ecosystem around it.
The same may be true in AI: The winners of the next phase may not be the companies with the largest models or the biggest clusters. Those companies will matter enormously, just as telecom providers, server vendors, and infrastructure companies mattered enormously. But the category-defining power may belong to whoever builds the missing application layer: the layer that allows enterprise intelligence to become persistent, governed, contextual, process-aware, and repeatable.
That is why the current obsession with model performance, context windows, and benchmark scores is both understandable and incomplete. Better models are necessary, but they are not sufficient. As McKinsey’s 2025 research on AI adoption notes: Companies seeing the most value are not just deploying tools; they are redesigning workflows and embedding AI into processes.
Deloitte reaches a similar conclusion in its work on agentic AI: Many organizations are hitting a wall because they are trying to automate processes designed for humans instead of reimagining how the work should actually be done.
In other words, the bottleneck is moving up the stack.
Industrialization always looks obvious in retrospect
The strange thing about these transitions is that they are difficult to see while they are happening and are obvious afterward.
Before the web, the internet looked like a domain for specialists. After the web, it became a business environment. Before ERP and SaaS platforms matured, enterprise software looked like custom automation. Afterward, it became repeatable architecture. Before cloud platforms matured, infrastructure looked like procurement and systems administration. Afterward, it became programmable capacity.
Enterprise AI is now approaching the same kind of threshold. The current phase still looks artisanal: pilots, prototypes, integrations, forward-deployed engineers, consulting-heavy engagements, custom workflow mapping. That is normal. Every powerful technology goes through a phase in which experts have to carry it across the gap manually.
But that phase is not the destination. The destination is the layer that makes the expert intervention less central.
This is why the next 5 years matter
The web did not turn the internet into a commercial civilization overnight. ERP did not standardize the enterprise overnight. Salesforce did not create a platform ecosystem in a single release. These transitions take years. But the decisive moment is usually the same: Someone defines the missing layer well enough that everyone else can build on it.
That is where enterprise AI is now.
We have the models. We have the infrastructure. We have the early agents. We have the consulting wave. We have the pilots. We have the frustration. We have the proof that isolated tools are not enough. We have the emerging recognition that context, workflows, constraints, memory, and outcomes matter more than prompts.
What we do not yet have is the equivalent of the browser, the URL, the ERP layer, the AppExchange — the standard application layer that makes enterprise AI consumable by ordinary companies.
And until that appears, the industry will remain trapped in a paradox: extraordinary intelligence delivered through extraordinary effort.
Where’s the web for enterprise AI?
That is the question.
Not “which model is best?”
Not “which chatbot is most impressive?”
Not “which copilot has the slickest interface?”
The real question is who will define the layer that turns intelligence into enterprise infrastructure?
Because once that layer appears, the current debate will look very different. Forward-deployed engineers will not disappear, but they will become less central. Custom deployments will not vanish, but they will stop being the dominant pattern. Pilots will not go away, but the path from pilot to production will become far shorter. Artificial intelligence will stop being something companies experiment with and become something companies are built on.
That is the industrial era of enterprise AI. And it has not arrived yet. But if history is any guide, once the missing layer appears, it will feel as if it was obvious all along.