Situation Analysis
Up until the emergence of large language models (LLMs), software was complex to design, develop, maintain, deploy, and eventually use. Usage was a draconian experience, rife with inflexibility at every turn.
That problem has always been a user interface and interaction (UI/UX) problem, persisting from the command-line era through the WIMP-based GUI era. Those usage complexities shaped every aspect of software use, especially value capture and the resulting business models.
LLMs are now the new apex of software’s UI/UX stack, and that complexity is finally eroding rapidly.
This shift can be examined through McLuhan’s tetrad, using LLM-mediated software interaction as the artifact under examination. The tetrad asks four related questions: What does the artifact enhance? What does it retrieve that had previously been displaced? What does it obsolesce? And what does it reverse into when pushed to an extreme?
Applied on that basis, the tetrad breaks down as follows.
Enhances — The use of open standards for software architecture that is loosely coupled, rather than proprietary alternatives tightly coupled to specific applications and thus compounding technical debt. It is becoming easier to mesh (rather than mash) information across sources (internal and/or external). Technology debates and rebuttals are no longer challenged by the degrees to which information can be presented in forms that juxtapose opposing arguments for objective analysis [1][2].
Retrieves — The previously stalled practice of interoperable, standards-based software architecture, displaced by the rise of application monoliths hardwired to specific DBMS platforms behind GUIs. For instance, ODBC, JDBC, and .NET usage is much easier for the systems-of-record interaction layer [6]. Likewise, hyperlinks and RDF create highly accessible and navigable data, information, and knowledge access via entity-relationship layering informed by relationship semantics expressed in shared ontologies.
Reverses — When pushed to an extreme, though, the natural-language interface can reverse its promise of simplicity into bias-laden opacity and dependency. Proprietary AI agents trained on biased data, information, and knowledge may recreate the lock-in and diminished user control of the GUI-era application silo, as adherence to a never-trust, always-verify doctrine diminishes.
Obsolesces — GUIs as the apex of software interaction and as a moat-building mechanism for value capture tied to particular business models, as demonstrated by cloud SaaS and apps served from app stores [7]. Nice-looking forms and graphs no longer obscure siloed entrapment and inevitably compounding technical debt.
The implications, protocol by protocol, are as follows [8].
| Protocol | Purpose | Agentic Era Possibilities | Agentic Skills Implications |
|---|---|---|---|
| TLS | Secure Data Transmission using PKI | Secure substrate for protocol data transmissions using PKI | Encrypted communications |
| OAuth | Delegated Authorization using Access Tokens | Agent obtains scoped access to HTTP resources without holding resource-owner passwords | Native client registration, authorization-code exchange, and bearer-token use |
| OpenID Connect (OIDC) | Identity Authentication layered on OAuth | Agent authenticates as a Relying Party (or talks to an Identity Provider) using ID Tokens, including credential-blind login | Native OIDC discovery, login, and ID Token verification |
| SMTP | Email Delivery | Email sending as an Agent feature | Email sending |
| S/MIME | Digitally Signed and/or Encrypted Email Messages | Digitally signed and/or encrypted email as an Agent skill | Sending and processing digitally signed and/or encrypted emails |
| IMAP4 | Email Inbox Access | Filesystem interaction with main inboxes | Email interaction using the familiar filesystem UI/UX patterns |
| HTTP | Document Access | Naming documents and accessing their content using URLs | Native document browsing and viewing capability |
| OpenAPI | HTTP API Description and Discovery | Agent discovers and invokes HTTP operations from a machine-readable service description | Native OpenAPI document lookup and operation invocation |
| Model Context Protocol (MCP) | LLM Application to Tool and Data Connection | Agent connects to MCP servers exposing tools, resources, and prompts without a custom integration per surface | Native MCP client/server session and tool-call handling |
| Agent2Agent (A2A) | Agent-to-Agent Communication and Interoperability | Agent discovers peer Agent Cards, delegates tasks, and shares results across frameworks | Native A2A Agent Card lookup, task send/subscribe, and skill invocation |
| WebDAV | Filesystem (Files and Folders) | Performing create, read, update (via replacement using PUT), and delete operations on files (documents) and folders (collections) | Native filesystem management capability |
| CalDAV | Calendar Management | Performing create, read, update (via replacement using PUT), and delete operations on calendars | Native calendar management scoped to iCalendar documents |
| CardDAV | Contact Management | Performing create, read, update (via replacement using PUT), and delete operations on contacts and address books | Native contact management scoped to vCard documents |
| Linked Data Protocol (LDP) | Filesystem (Files and Folders/Containers) | Performing create, read, update (using SPARQL), and delete operations on files and folders (containers) | Native filesystem management scoped to RDF documents |
| ActivityPub | Specialized Inbox and Outbox interactions | Filesystem interaction with main fediverse inboxes | Native social media inbox management |
| SPARQL (includes Graph & Update) | Data Access & Manipulation | Performing create, read, update (using SPARQL), and delete operations on triples and named graphs (documents) hosted by SPARQL servers | Native knowledge graph and Semantic Web querying |
| ODBC | Read-Write DBMS Interactions for ‘C’/C++ Apps | Performing create, read, update (using SQL), and delete operations on DBMS tables. | Native administration and interaction with ODBC DSNs and their associated drivers for various DBMS platforms — especially legacy systems of records databases |
| JDBC | Ditto, but for Java Apps | Performing create, read, update (using SQL), and delete operations on DBMS tables. | Native administration and interaction with JDBC URLs and drivers for various DBMS platforms — especially legacy systems of records databases |
| Agentic Commerce Protocol (ACP) | Checkout and order completion against an offer catalog | Agent-driven checkout, cart, and order flows for documents and other products published as offers | Native checkout and order completion as an Agent skill |
| Machine Payment Protocol (MPP) | Payment settlement for HTTP 402-protected resources | Completing 402 payment flows that land on Stripe, with receipt verification en route to document access | Native 402 payment and receipt handling as an Agent skill |
| x402 | Blockchain payment settlement for HTTP 402-protected resources | Completing 402 payment flows that land as USDC in a wallet (EIP-3009 exact, via a facilitator), with receipt verification en route to document access | Native x402 buy-and-settle against DAV, SPARQL, OPAL, and other protected endpoints |
In Practice
Our Virtuoso platform implements all the protocols listed above. Initially, the significance of this implementation was not fully understood, especially given the known complexity associated with implementing open standards. Today, however, a local or remote Virtuoso instance provides an extremely powerful and cost-effective layer that uniquely addresses semantics and context while remaining true to the loose-coupling doctrine. Every example in the Related section below is a live demonstration of these capabilities, enabling individuals and organizations alike to take full advantage of the reimagination of software taking shape in this new age of AI Agents, Harnesses, and Skills.
Our OPAL (OpenLink AI Layer) platform adds a natural-language interaction layer for using and managing Virtuoso, while also providing a powerful solution for creating and deploying Agents, Harnesses, Skills, and Tools that are loosely coupled with data spaces (databases, knowledge bases, filesystems, and APIs).
Finally, our long-established ODBC and JDBC data access drivers provide Agents, Harnesses, Skills, and Tools with secure, high-performance connectivity to systems-of-record databases, including Oracle, DB2, SQL Server, Sybase, Informix, Ingres, Progress (legacy and OpenEdge), MySQL, and PostgreSQL, as well as databases accessible through third-party ODBC and JDBC drivers.
Conclusion
The artifact is LLM-mediated software interaction. What it enhances and retrieves is already on the table: loosely coupled open standards, hyperlinks and RDF as the naming and relationship layer, and the same protocols that GUIs used to hide — now usable as agent skills rather than as vendor-specific integration projects.
What it obsolesces is the GUI as the apex of interaction and as the moat. What it reverses into, when pushed to an extreme, is a new silo: a proprietary agent that cannot be verified, trained on identifiers that cannot be looked up. That is the GUI-era trap in conversational clothing.
The work, then, is not to celebrate the new interface. It is to keep the retrieved architecture — names that resolve, protocols that interoperate, a never-trust, always-verify doctrine — so that meshing information across sources remains possible. Otherwise the complexity does not erode. It merely changes costume.
Related
- The Agent Engineering Stack Nobody Shows You
- Why the Triple Is the Wrong Grain — An RDF Rebuttal
- LPG Graph Technology Narrative (represented by Neo4j) vs RDF-based Graph Technology Narrative (represented by Virtuoso)
- ONE GRAPH TO RULE THEM ALL!
- Inhabiting Babel, A Manifesto for Responsible Meaning Engineering
- I didn’t expect to actually use this (Grok Bot)
- Conceptual Data Virtualization for SQL and RDF Using Open Standards
- Software Losing Its Head
- Building the Open Agentic Economy - Validated Against x402