Originally published on cauri's Medium

____________

I’ve spent the past year watching enterprise software transform in ways that seemed impossible just five years ago. What started as experiments with sensor-driven learning has evolved into agent swarms handling real production workloads. Now, with OpenAI declaring “2025 when agents will work” and Microsoft building infrastructure for an “open agentic web,” we’ve reached an inflection point that demands attention from every tech leader.

At Artium, we’re one of a small number of organisations worldwide selected as OpenAI partners for enterprise agentic AI. This gives us a unique vantage point: we see both the bleeding-edge developments and the practical challenges enterprises face. Our clients don’t want another proof of concept that never leaves the lab. They need production code now. They need a clear path from POC to deployment. Most importantly, they need to understand what this shift means for their business.

The term “agentic web” has emerged across the AI community throughout 2024 to describe this transformation — a natural evolution from “agentic AI” applied to web architecture. While Andrew Ng introduced “agentic” in June 2024 for autonomous AI systems, multiple voices independently started using “agentic web” as the implications for internet infrastructure became clear. The terminology may be new, but the underlying shift represents enterprise software’s fundamental evolution beyond deterministic code toward cognitive architecture. To understand where this is going, it helps to step back and see how we got here.

The evolution: from static pages to thinking systems

To grasp where we’re heading, I find it helpful to trace the web’s evolution through distinct architectural paradigms:

Web 1.0 (1989–2004) gave us static publishing. You clicked a link, you got a file. Simple, one-directional, limited. Think GeoCities pages and early corporate websites.

Web 2.0 (2004–2020) introduced dynamic interaction. Instead of just retrieving files, you could access services, contribute content, and interact with data. This era birthed social media, cloud computing, and the API economy.

Web 3.0 (2020-?) promised decentralisation through blockchain, but struggles with practical implementation. While philosophically compelling, it hasn’t delivered the transformative business value many expected.

Now I’m witnessing Web 4.0 emerge — not as speculation but as deployed infrastructure. This represents something fundamentally different: an agentic architecture where intelligent agents act as autonomous entities, reasoning about goals and collaborating to achieve them.

What makes Web 4.0 different

The shift from Web 3.0 to 4.0 might seem sudden, but it reflects a change in how systems operate rather than only in how they’re built. Traditional software follows explicit logic: if this condition exists, execute that action. Even sophisticated Web 2.0 services essentially run elaborate decision trees.

Web 4.0 systems reason. They understand context, adapt to circumstances, and most crucially, communicate with other intelligent systems to achieve goals. When a client recently asked me to explain the difference, I used this analogy: Web 2.0 gave you a high-performance calculator. Web 4.0 gives you a mathematician who knows when to use it — and when to pick up a pen.

The term “Agentic Web” marks a transformative era where AI and blockchain converge to redefine the internet, with AI enhancing human cognition through machine learning while autonomous AI agents navigate, transact, and collaborate independently. But I’m less interested in the blockchain aspects than in what I see actually working: intelligent systems that turn intent into action.

OpenAI’s vision: from experiments to enterprise reality

OpenAI’s commitment to the agentic future reveals itself through both their technical architecture and strategic decisions. We’ve watched them systematically rebuild their entire platform around agent-first principles.

Their five-level AGI framework positions agents as stage three, where AI moves beyond reasoning to autonomous action. They currently place themselves at level two — systems that can reason through problems. At their DevDay event, CEO Sam Altman declared that “2025 is when agents will work,” adding that when people start using agents “it will be a big deal” because “people will ask an agent to do something that would have taken them a month, and it’ll take an hour”.

This isn’t distant speculation. OpenAI recently deprecated their Swarm experimental framework in favour of the production-ready Agents SDK, which features “Agents equipped with instructions and tools, Handoffs for delegating between agents, and Guardrails for input validation”. The shift from experimentation to production tools signals their confidence that enterprises need these capabilities now, not someday.

Their API product head acknowledged the challenge directly: “it’s pretty easy to demo your agent” but bridging “the gap between AI agent demos and products” requires fundamental platform changes. The new system prioritises reliability through minimal primitives — a clear signal they expect enterprises to depend on these systems for critical operations.

The practical reality for enterprises

Working with enterprise clients, I see three transformative shifts happening simultaneously:

Memory replaces databases. Traditional systems store data in static tables. Agentic systems accumulate experience — they remember what worked, what didn’t, and why. Instead of relying solely on structured queries, agents access and contribute to a growing body of interaction history, outcome tracking, and real-time feedback.

Nvidia’s NeMo platform demonstrates this through “data flywheels” where agents continuously improve based on interaction patterns. In our own experience, memory becomes the backbone of effective multi-agent systems. Agents coordinate through shared state, episodic recall, and tools like vector stores, memory graphs, and embedded logs. These aren’t just logs — they’re functional records that influence next actions.

Our clients find this particularly powerful for customer service, where each interaction makes the system smarter. The more it sees, the better it responds. The goal isn’t to store everything, but to store what matters — and use it in the moment.

Cognitive interfaces replace APIs. Anthropic’s Model Context Protocol (MCP) exemplifies this shift — designed as “HTTP for AI agents,” it enables standardised communication between agents and external resources without requiring custom integration.

The industry has rallied behind this standard with unprecedented speed. OpenAI announced support for MCP across their products including the Agents SDK and ChatGPT desktop app. Microsoft has committed to supporting MCP across their entire platform, from GitHub to Azure AI Foundry. Google DeepMind’s CEO Demis Hassabis confirmed MCP support in Gemini models, describing it as “rapidly becoming an open standard for the AI agentic era”. By May 2025, over 5,000 active MCP servers existed, demonstrating massive community adoption. As one industry observer noted, “We’re entering the protocol era of AI” — this universal standard solves the integration nightmare that has historically slowed enterprise AI adoption.

Meanwhile, OpenAI’s Computer-Using Agent takes a different approach, generating mouse and keyboard actions to interact with existing software interfaces rather than requiring any integration at all. Between MCP for standardised communication and agents that can use any software like humans do, the barriers to enterprise AI adoption continue to fall.

Collaborative clusters replace isolated applications. The term “agent” misleads us. Rather than singular entities with human-like autonomy, these systems resemble cognitive clusters within a unified brain. Multiple agents work together as cohesive cognitive architecture — like regions of a brain collaborating toward common goals.

This transforms how we think about capabilities. Instead of isolated agents, we design capability clusters: planning agents that assess requirements, research agents that gather information, execution agents that carry out tasks. They operate like a jazz ensemble — each specialist playing their part while responding to the others in real-time.

Customer service exemplifies this transformation. Where traditional systems require sequential handoffs between departments, cognitive clusters handle everything simultaneously. One agent authenticates the user while another analyses their history, a third evaluates relevant policies, and a fourth formulates responses — all coordinating through shared memory and context. The result feels less like passing a baton and more like a hive mind solving problems.

Real deployments, real results

The pressure to adopt intensifies when you see what early adopters achieve:

AT&T uses Nvidia’s NeMo microservices to process nearly 10,000 documents. They improved accuracy by 40% and reduced computational overhead in the process. Instead of replacing existing systems, they introduced cognitive agents as intelligent intermediaries.

Renault Group uses Google’s Agent Development Kit to optimise EV charger placement. Their agents combine location data, usage patterns, grid capacity, and regulatory requirements through coordinated collaboration.

These aren’t pilots. They’re production deployments delivering measurable value. The technology works. At this stage, competitive advantage shifts from technical feasibility to execution speed.

Navigating the transition

Every client asks the same question: how do we get from proof of concept to production? Through painful experience, we’ve identified the critical challenges:

Legacy integration requires finesse. The successful approach involves cognitive overlay rather than replacement. If you work with enterprise systems, you’ve probably already built an ecosystem of APIs, cloud services, and internal tools over the years. That stack might feel dated in the age of generative AI — but it doesn’t have to.

Instead of ripping out old systems or building wrappers around everything, you can let your AI interact directly with what you already have. Cognitive overlays treat your existing stack as a foundation — not an obstacle. With Model Context Protocol (MCP), a plain language request can become an API call. Query a database, move a ticket in Jira, update a record in Salesforce — MCP makes those actions accessible using your current infrastructure.

This matters because most companies don’t need a full rebuild. They need AI that plays well with what’s already there. MCP helps you get there faster, with fewer surprises.

If your stack already exposes REST endpoints, this makes every one of them a building block for an AI system. Think of it as a multiplier on the investment you’ve already made. You don’t need to overhaul your architecture. You need to connect your agents to it. You make your APIs available, define the interactions, and your AI can start doing useful work.

Governance needs rethinking. Cognitive systems operate probabilistically, not deterministically. Traditional debugging approaches fail when decision logic consists of learned behaviours rather than explicit code. Develop frameworks focused on intent and outcome rather than step-by-step decision paths. But here’s what makes it truly challenging: our protected systems can’t reveal their prompts, tools, or reasoning. Debugging becomes psychology — you probe gently, create revealing scenarios, look for patterns. It’s more therapist than debugger.

Skills gaps demand hybrid strategies. Most organisations can’t hire enough cognitive specialists fast enough. The answer lies in hybrid teams — partner with experts while retraining your core staff.

The hardest part? Teaching engineers to shift from code to prompts. We’ve all been trained to minimise and control — feed each function exactly what it needs. But AI turns that on its head.

When something breaks, engineers try to tighten scope. But here, the fix often lies in giving more context, not less. That shift in thinking challenges even seasoned developers used to disciplined minimalism. As Artium’s CTO Mike McCormick puts it “Traditional development is more like a 3D printer — adding controlled bits of material to get to final shape. AI latent space, prompting, and the agents that emerge are more like a subtractive process where you sculpt the figure through removal of material. The two require very different skills to end up at a final product.”

Repository structures need reimagining. Traditional repos usually hold just code and a bit of documentation. But coding assistants thrive on context.

So we include user stories, design artefacts, status-docs, system notes, and planning files — all linked, all accessible to AI. It transforms how both humans and machines understand the codebase.

Design systems that can evolve from simple automation to full cognitive capability without fundamental reconstruction. The organisations solving these challenges early will scale fastest.

Security in a collaborative world

Microsoft emphasises that agents need unique identities through Microsoft Entra Agent ID, helping enterprises securely manage agent permissions and access. Google provides multiple Vertex AI security layers including configurable content filters and VPC controls. These frameworks work — but they demand a new mindset. Traditional access control assumes static roles and predictable behaviour.

Agent systems break that model. They adapt. They learn. Security policies need to evolve alongside them.

At Artium we developed continuous alignment testing (CAT) to be an adaptive, versatile form of testing and evaluation to benefit reliability, alignment, consistency, and security in any non-deterministic system. The organisations that embrace this early will scale with confidence.

Web 4.0 defined: the agentic web

I feel I can now articulate what Web 4.0 actually means:

Web 4.0 represents a fundamental shift where autonomous digital AI agents understand, decide, and act on behalf of users and organisations. But it goes deeper than individual agents. The agentic web creates an ecosystem where agents represent:

Companies: Negotiating contracts, managing supply chains, optimising operations Employees: Handling routine tasks, working with partners, coordinating with other agents, escalating when needed Services: Self-describing capabilities, automatically integrating with other services Consumers: Expressing preferences, making purchases, managing personal data

As we’ve developed new approaches leading to these agents since the creation of GPT-1 in 2019, it is great to see them finally getting named, codified, and supported by a global infrastructure that is bigger than any one firm. These new agents communicate directly with each other to achieve goals, often independently of human intervention. The shift from personalisation to individualisation marks a crucial distinction. Where Web 2.0 offered “people like you bought this,” Web 4.0 knows “you specifically need this, for these reasons, at this moment.”

The Agentic Web rapidly transforms how we interact with digital systems — instead of static interfaces and predefined user journeys, it introduces dynamic runtime infrastructure where both computation and interfaces adapt in real-time to user context and intent.

The path forward

I find myself building systems that think, not just systems that process. The shift feels less like adopting new technology and more like teaching digital entities to understand and act on business intent.

For enterprises, the question isn’t whether to adopt agentic architectures but how quickly you can build the capabilities to compete, and how to integrate yours into the bigger whole of web 4.0. The infrastructure exists. Early adopters demonstrate clear advantages. The window for differentiation through early adoption narrows with each vendor release.

Start with bounded, high-value use cases where cognitive enhancement provides clear ROI. Build memory architectures that accumulate organisational knowledge. Design for agent collaboration from the beginning. Most importantly, partner with teams who’ve already navigated this transition.