01 / The starting point
When the interface belonged to the application
Before the Web, the productivity problem was largely solved inside native applications. Microsoft Access, Excel, report writers, and executive information systems gave people rich visual ways to work with data. The constraint was connectivity: each application owned its interface, understood its document formats, and set the limits of interaction.
The article follows a sequence of loosening ties. ODBC separated applications from particular database systems; UDBC and iODBC carried that model across platforms, with the article crediting Ke Jin for the missing platform layers; Java and JDBC extended portability to applications and database access together. Each step moved a dependency out of the way, while the application still shaped the experience.
02 / The middle turn
The Web connected resources. The GUI stayed in front.
HTTP, URIs, HTML, and hyperlinks made network resources addressable at Web scale. Yet connectivity did not carry the native application's rich, task-specific experience along with it. Browsers became the gateway, and teams rebuilt productive interfaces in the Web stack.
The article places CORBA and MCP on a related architectural line: both address loosely coupled access to capabilities across networked systems, through different models. CORBA framed distributed object interoperability; MCP exposes tools and resources to AI applications and agents. The persistent requirement is flexible capability access. The interaction model changes.
03 / The inversion
The agent changes where the GUI belongs
With suitable identity, authorization, context, skills, and tools, an agent can act on a person's intent. The path shifts from person → GUI → application → data and actions, toward person → agent → governed data and tools → actions. Identity, attributes, context, and policy shape which resources and capabilities the agent may use.
The GUI remains useful, but it no longer has to be the permanent gateway. An agent can generate a task-specific visual experience when one helps. Data and capabilities persist; the interface can be an artifact made for the moment and the task.
04 / The case in view
Northwind makes the shift visible
Northwind is the article's through-line: one sample database, seen across three eras. First, native applications put a rich interface close to the data. Then the Web connected the data, while a custom application had to be built to recreate that experience. In the agentic version, the data and tools become inputs to an agent that can produce a task-specific dashboard.
The two source screenshots show that dashboard as an outcome of agent work: a query result presented as a customer-facing experience, with customer identifiers shown as links into the graph. The visual story moves from interface as prerequisite to interface as generated result.
05 / The convergence
A Semantic Web supplies the context agents need
An agent needs more than a route to a tool. It needs to identify resources, understand what they represent, follow their relationships, discover available capabilities, and know the constraints on access. The article connects those needs to the Semantic Web Project: HTTP for connectivity; URIs for globally scoped names; RDF for machine-computable entity relationships; Linked Data for discovery and traversal; and ontologies for shared meaning, classifications, relationships, and constraints.
MCP exposes tools and capabilities at the interaction layer. Semantic descriptions supply context about the entities and relationships those tools encounter. Together, the article argues, agents can handle the machinery while people express intent—and generate a visual experience when it helps.
A route through the argument
Follow the progression
- 01
Start with the interface
Start with the interface — Notice how native applications supplied a productive visual environment while keeping interaction application-specific.
- 02
Follow the decoupling sequence
Follow the decoupling sequence — Trace ODBC, UDBC and iODBC, then Java and JDBC, as successive moves away from assumptions about where applications and data must live.
- 03
Separate connectivity from interaction
Separate connectivity from interaction — Distinguish the Web's resource connectivity from the browser-based GUI experience that still had to be built.
- 04
Add the agent layer
Add the agent layer — Read the shift from person-to-GUI interaction to intent expressed through an agent, governed data, tools, and actions.
- 05
Return to Northwind
Return to Northwind — Use the same sample database across the three eras to see how the interface changes from prerequisite to generated outcome.
- 06
Identify the semantic context
Identify the semantic context — Connect URIs, RDF, Linked Data, ontologies, and policy to the context an agent needs to work with entities and capabilities.
Questions the article raises
Frequently asked
What is the article's central progression?
What did ODBC change in this story?
ODBC loosened the coupling between Windows applications and database management systems.
How does the article distinguish CORBA and MCP?
Did the Web remove the need for application interfaces?
What changes when an agent acts on intent?
Why does the article use Northwind?
The same sample database makes the pre-Web, Web, and agentic experience shifts tangible.
What role does the Semantic Web Project play?
Does the GUI disappear in the agentic era?
The vocabulary behind the progression
Core concepts
Native application
Native application — A locally or platform-bound application that supplies its own interface and understands its own document formats.
ODBC
ODBC — Open Database Connectivity; the article's example of loosening application-to-database coupling.
UDBC
UDBC — Universal Database Connectivity; the article describes it as taking the ODBC API cross-platform without its Driver Manager and Administrator layers.
iODBC
iODBC — A cross-platform ODBC environment formed by combining the ODBC model with the missing platform layers described in the article.
JDBC
JDBC — Java Database Connectivity; database-independent connectivity in the article's portable Java application model.
CORBA
CORBA — The distributed-object interoperability approach used as a historical comparison for loosely coupled capability access.
Model Context Protocol (MCP)
Model Context Protocol (MCP) — The article's standardized mechanism for connecting AI applications and agents to external tools, resources, and capabilities.
HTTP
HTTP — The generic Web protocol that connects resources across networks.
URI
URI — A globally scoped name used to identify a Web resource.
HTML
HTML — The Web document language named in the article alongside HTTP, URIs, and hyperlinks.
Hyperlink
Hyperlink — A link that makes resources discoverable and traversable across the Web.
AI agent
AI agent — An agent that can act on a person's intent using identity, authorization, context, skills, and tools.
Identity
Identity — The information that identifies the agent or principal in the governed interaction described by the article.
Authorization
Authorization — The decision about whether an agent may access data or actions for a task.
Machine-computable context
Machine-computable context — Information about entity types, relationships, constraints, access, and capabilities that helps an agent act appropriately.
Skills and tools
Skills and tools — Agent-accessible capabilities used to act on intent and work with data or services.
ABAC
ABAC — Attribute-Based Access Control, cited as an example of governing access using identity, attributes, context, and policy.
Generated GUI
Generated GUI — A task-specific visual experience produced by an agent when visual interaction is useful.
Northwind
Northwind — The sample database used in the article to make its three-era progression tangible.
Knowledge graph
Knowledge graph — An entity-relationship graph through which linked entities and their relationships can be explored.
SPARQL
SPARQL — The query language named in the article as a capability that people need not use directly when an agent operates on their behalf.
RDF
RDF — A machine-computable representation for entities and their relationships.
Linked Data
Linked Data — Principles and practices that make machine-readable relationships discoverable and traversable.
Ontology
Ontology — A shared semantic structure for types, relationships, and constraints.
Semantic Web Project
Semantic Web Project — The article's name for the project and standards that provide machine-computable entity relationships and shared semantics.
Take the source with you
The linked artifacts
The article and its relationships are also available as RDF-Turtle. The graph records the article's claims, sequence, people, organizations, concepts, image roles, and provenance.
↓ Open RDF-Turtle ↗ Read the source article