🕒 7 min read
The web we use today isn’t just a place to look up information or share photos. It’s becoming a space where software agents, autonomous programs, can negotiate, collaborate, and even solve problems on their own. This shift from a static, human-centric web to a dynamic, agent-driven one didn’t happen overnight. It’s the result of decades of trial, error, and technological evolution, starting with a bold vision that never quite took off.
From Vision to Reality: The Long Road to the Web of Agents
The Birth of the Semantic Web (2001)
In 2001, Tim Berners-Lee, the inventor of the World Wide Web, proposed a radical idea: a “Semantic Web” where machines could understand meaning as easily as humans do. The goal was to transform the web from a collection of documents into a network of data that could be interpreted and acted upon by software. To make this possible, three core technologies were introduced: RDF, OWL, and shared ontologies.
RDF, or the Resource Description Framework, was a way to represent facts as simple triples: subject-predicate-object. For example, “Apple is a company” becomes “Apple (subject), is a (predicate), company (object).” This structure allowed machines to parse information in a way that could be logically processed. OWL, the Web Ontology Language, built on this by adding formal rules for defining relationships between concepts. Shared ontologies were the glue that held everything together, agreements on what terms meant so different systems could communicate.
The dream was that these tools would let autonomous agents perform tasks like scheduling medical appointments by reasoning over distributed data. But despite the promise, the Semantic Web never took off.
Why the Semantic Web Struggled
The Semantic Web’s vision was elegant, but in practice, it faced major hurdles. One problem was economic misalignment: creating and maintaining semantic annotations was expensive and time-consuming. Unlike today’s API economy, where companies profit from data sharing, there was no clear business model to incentivize the widespread adoption of formal ontologies.
Another issue was technical brittleness. Logic-based inference, which relied on strict rules, struggled with the messy, contradictory, and incomplete data of the real world. Systems could fail if a single piece of information was missing or incorrect. And perhaps most critically, the Semantic Web’s success depended on agents that could reason flexibly, but no one had built that kind of intelligence yet. As the paper notes, “The primary bottleneck was not the network, but the nodes”, the agents themselves lacked the general-purpose reasoning needed to make the Semantic Web work.
The Parallel Challenge: Multi-Agent Systems (MAS)
While the Semantic Web was struggling, another approach was taking shape: Multi-Agent Systems (MAS). These systems aimed to create autonomous agents that could communicate and collaborate using standards like FIPA (Foundation for Intelligent Physical Agents). FIPA developed a communication protocol called ACL (Agent Communication Language), which used concepts from speech-act theory to define how agents should interact.
But MAS faced its own set of problems. The FIPA standards were complex and difficult to integrate with the open, stateless architecture of the web. Agents in MAS systems often required rich, stateful dialogues, which clashed with the web’s design. Also, semantic interoperability, the ability for agents to understand each other’s meaning, remained elusive. Without a shared framework for meaning, agents couldn’t reliably cooperate. And despite years of development, MAS never achieved a “killer application” that would drive widespread adoption.
The Paradigm Shift: LLMs as the Missing Piece
The breakthrough came with the rise of Large Language Models (LLMs). Unlike the rigid, logic-based systems of the Semantic Web and MAS, LLMs brought a new kind of intelligence: general-purpose reasoning and adaptability. These models could interpret natural language, reason about goals, and even dynamically invoke APIs without relying on formal ontologies.
This shift changed the locus of intelligence. In the early 2000s, meaning was encoded in external data (RDF/OWL). In the 2000s, intelligence was built into platform infrastructure (FIPA’s directory and coordination tools). But now, in the 2020s, semantic understanding is embedded within the agent itself, the LLM. This eliminated the need for expensive, pre-existing semantic scaffolding. Agents could now interpret natural-language descriptions, reason about complex tasks, and interact with APIs documented in plain language, without needing to agree on formal ontologies beforehand.
Modern Protocols: Simplicity Over Complexity
The lessons from the Semantic Web and MAS didn’t disappear, they shaped the next generation of standards. Today’s protocols, like the Model Context Protocol (MCP) and Agent-to-Agent (A2A), take a different approach. Instead of relying on complex, formal frameworks, they use lightweight, RPC-style interactions over HTTP and JSON. These protocols decouple intelligence from formal semantic frameworks, making it easier for agents to communicate.
A2A, for example, proposes using standardized metadata files (like agent.json) placed at well-known URLs for decentralized discovery. This replaces the centralized Directory Facilitator of FIPA with a more web-native approach. As the paper explains, “pragmatic simplicity and alignment with existing web standards are paramount.” These new protocols are designed to be scalable, flexible, and compatible with the tools developers already use.
Knowledge Graphs and RAG: The Legacy of the Semantic Web
Though the original vision of the Semantic Web didn’t fully materialize, its legacy lives on in knowledge graphs and Retrieval-Augmented Generation (RAG). Formal ontologies may have faltered at scale, but structured knowledge remains a critical tool. Today, systems like Google’s Knowledge Graph (built from Wikipedia, Wikidata, and Schema.org) and Facebook’s Open Graph use similar principles to organize information.
RAG takes this a step further by letting LLMs access external knowledge bases dynamically. Instead of relying on static ontologies, agents can now retrieve information from the web in real time, reducing hallucinations and enabling up-to-date, domain-specific knowledge. This hybrid approach, combining structured data with the flexibility of LLMs, has become a cornerstone of modern agent systems.
Agents as Complement, Not Replacement
Modern agents aren’t replacing structured data; they’re working with it. LLM-powered agents use knowledge graphs for grounding and context, natural language to interpret unstructured content, and plain-language API documentation to interact with services. They also use RAG to supplement their reasoning, ensuring they have access to the latest information without requiring global agreement on formal ontologies.
This hybrid model is more scalable and practical than the rigid systems of the past. It doesn’t force everyone to agree on a single semantic framework, it lets agents adapt to different contexts and collaborate without needing perfect alignment. As the paper notes, “agents and structured data are symbiotic, not competitive.”
The Four Generations of Agents
To understand where we are now, it’s helpful to look back at the evolution of agents through four generations:
1. Agents 1.0 (1990s): Static, single-purpose bots with fixed logic. These were early examples of automation, like simple chatbots or rule-based systems that couldn’t learn or adapt.
2. Agents 2.0 (2000s): Social agents using FIPA-ACL and platforms like JADE. These agents could communicate and collaborate but were still limited by the technical and economic challenges of the time.
3. Agents 3.0 (2000s-2010s): Semantic Web agents that reasoned over RDF/OWL. These agents had more flexibility but still struggled with scalability and real-world data.
4. Agents 4.0 (2020s): LLM-powered agents that dynamically interpret natural language and invoke APIs. These agents combine the reasoning power of LLMs with the scalability of modern protocols, making them the foundation of the Web of Agents.
The vision of a global digital ecosystem populated by autonomous software agents is now within reach. These agents can discover one another, communicate, and collaborate to perform complex tasks on behalf of users.
The Next Frontier: Trust and Governance
While the technical infrastructure for the Web of Agents is in place, the next challenge is trust and governance. New protocols are essential, but they’re not enough on their own. Issues like decentralized identity, economic models, security, and governance need to be addressed. How will agents be incentivized to act fairly? How will users ensure their data is protected? How will disputes be resolved when agents collaborate?
These are complex, socio-technical challenges that require input from technologists, policymakers, and users. But the good news is that the technical groundwork is already there. The next step is building systems that are not only smart but also trustworthy, scalable, and economically viable.
The Semantic Web may be dead, but its legacy lives on in the Web of Agents. What’s clear is that the future of the web isn’t just about information, it’s about autonomous, intelligent systems that can work together to solve real-world problems.
Sources, References & Attribution
This blog post summarizes and explains ideas reported in the cited source. It is an independent explanatory commentary and does not reproduce the original work’s text, figures, or tables. All rights remain with the respective authors or publishers. Readers should consult the original for full detail.
Primary Source: From Semantic Web and MAS to Agentic AI: A Unified Narrative of the Web of Agents (2025)
Read the original: Original source
