LinkedIn Pulse · June 4, 2026 · Jaya Gupta

If China Built the Super-App,
the US May Build the Super-Agent

From graph consolidation to graph federation — an architectural blueprint for the agent operating space, extended with Kingsley Idehen's six-component framework.

Overview

The Core Thesis

Jaya Gupta argues that China's defining internet product was the super-app — WeChat unified personal and business context into a single surface. The US internet evolved in the opposite direction: privacy, procurement, payments, antitrust, and enterprise trust split the graph apart. But those structural barriers — the fragmentation that prevented a US super-app — are also the features that will produce something different: the super-agent.

The super-agent is not a platform that owns everything. It is an interface layer that operates across fragmented systems — calendars, messages, payments, health data, work identity — without consolidating them. The shift is from owning the graph to operating across it. Capability determines what an agent can do; permission determines where it can go.

Article

Five Sections

1. AI Has a Usage Problem Disguised as a Revenue Problem

Consumer AI creates enormous surplus but hasn't monetized well. Enterprise AI captures value because it attaches to budgets, workflows, and measurable outcomes. Consumers create usage; enterprises create budgets. Underneath that economic split is an institutional one.

2. The Rarest Companies Are Bilingual in Trust

The rarest tech companies are intimate enough for consumers and governable enough for institutions. Microsoft, Google, and Apple exemplify this; Meta does not. Privacy turned one possible graph into many companies — the US preserved boundaries that made total platform control harder.

3. The American Super-Agent

An American super-app faces structural barriers (mobile gatekeepers, fragmented payments, antitrust, privacy rules). But those barriers are features reflecting American democracy. The super-agent emerges as an interface layer that unlocks access across fragmented systems rather than consolidating them.

4. Access Is the Moat

Agents become more useful with visibility into calendars, messages, photos, location, purchases, health data. Different companies accumulate different currencies of permission: Apple (personal context), Microsoft (organizational governance), Google (breadth), Palantir (institutional efficacy).

5. The Next Platform Is the Interface Allowed to Act

OpenAI starts with consumer habit; Anthropic starts with institutional trust. Both converge on the same destination. The next platform is not the company that owns everything — it is the interface allowed to act across everything. Capability determines what an agent can do; permission determines where it can go.

Comparison

Super-App vs Super-Agent

DimensionSuper-App (China)Super-Agent (US)
ArchitectureSingle platform consolidating personal + business graphs into one operating layerInterface layer operating across fragmented systems without consolidating them
Graph modelGraph consolidation — all data flows through one surfaceGraph federation — data stays in place, agent operates across it
IdentityPlatform-owned identity (WeChat ID)Federated identity via HTTP IRIs + WebID — user controls the identifier
Trust modelPlatform IS the trust intermediaryBilingual trust — intimate for consumers, governable for institutions
PaymentIntegrated into platform (WeChat Pay)Fragmented — banks, cards, MPP, Stripe, ACP — agent mediates across them
PermissionPlatform grants or denies accessACLs on resources — authorization decoupled from any single platform
PrivacyPlatform observes everythingPrivacy split the graph — different institutions hold different contexts
Key riskTotal platform control, surveillanceFragmentation makes cross-context action harder; determinism gap
Framework

The Agent Operating Space — Six Loosely Coupled Components

Kingsley Idehen's comment extended the super-agent thesis into an architectural blueprint. The Agent Operating Space is not a new platform to own — it is a set of interoperability contracts any agent, skill, or data space can participate in.

1 Identity

Who the agent is and on whose behalf it acts. WebID provides a dereferenceable HTTP IRI for every agent and user. The identity is not platform-owned — it resolves on the Web.

2 Identification

Unambiguous naming across systems using HTTP-based identifiers as super keys. Every entity has a globally unique, dereferenceable IRI.

3 Authentication

Verifying identity claims. mTLS with PKCS#12 certificate bundles cryptographically binds the agent's WebID to its actions. Decoupled from any single platform's identity provider.

4 Authorization

What the agent is permitted to do. Expressed as WebID-ACL on WebDAV resources and SPARQL graph permissions. Authorization at the data layer.

5 Semantic Layer

Graph-based knowledge representation providing shared meaning, RDFS/OWL inference, and entity resolution across heterogeneous data sources. This is the determinism layer.

6 Systems of Record, Engagement, Analytics, Action

The data spaces the agent operates across: databases, knowledge bases, file systems, APIs. Virtualized through a DBMS layer — data stays in place. RDF Views, SPARQL-FED, MCP tools.

Analysis

Currencies of Permission

Gupta identifies companies accumulating different permission currencies. The comment thread adds the architectural layer that makes permission interoperable.

CompanyPermission CurrencySuper-Agent Position
ApplePersonal context — device, health, calendar, messagesMost intimate consumer data surface
MicrosoftOrganizational governance — work identity, email, documentsEnterprise trust + consumer reach
GoogleBreadth — search, email, maps, photos, AndroidHardest trust challenge, widest surface
PalantirInstitutional efficacy — government, defense, intelDeepest institutional integration
OpenAIConsumer habit — ChatGPT as default interfaceDistribution play: become the default
AnthropicInstitutional trust — safety, enterprise, governmentPermission play: safety as strategy
OpenLink / VirtuosoInteroperability contracts — open standardsThe substrate any agent can use: HTTP IRIs + WebID + mTLS + SPARQL + RDF + MCP
Discussion

Comments

The super-agent needs an operating space that comprises the following loosely coupled components:

1. Identity — who the agent is, acting on whose behalf.
2. Identification — unambiguous naming using HTTP-based identifiers as super keys.
3. Authentication — verifying identity claims (mTLS, WebID).
4. Authorization — what actions are permitted (ACLs, graph-level permissions).
5. Semantic Layer — a graph-based knowledge representation providing shared meaning, inference, and entity resolution.
6. Systems of Record, Engagement, Analytics, and Action — the data spaces the agent operates across.

These components are loosely coupled — each can evolve independently. This is what distinguishes operating across the graph from owning it.

Shared references: Virtuoso · URIBurner · OpenLink Software · RDF 1.1 · SPARQL 1.1 · WebID

Permission gets the agent in the door, but defensibility after acting is a separate, still-open problem. Earning trust to act and remaining defensible after acting are two different problems.
Without a governed layer that resolves the same answer the same way every time, you've just given a confident system faster access to be wrong. Capability + permission are necessary but insufficient without determinism. The semantic layer — shared ontologies, explicit inference rules, and entity resolution — provides that determinism.
If one agent becomes the primary interface, what happens to the underlying tools? Slack, Teams, Notion — do they become mere data stores? What true value do they provide besides their historical value or nice-for-human-UX, which is now being replaced with nice-for-agent?
Another banger.
FAQ

Frequently Asked Questions

A super-app (WeChat) consolidates personal and business graphs into a single platform. A super-agent operates across fragmented systems without consolidating them — it reads from and acts across existing data spaces through interoperability contracts rather than platform ownership.
Per Kingsley Idehen's framework: (1) Identity — who the agent is; (2) Identification — HTTP IRIs as super keys; (3) Authentication — mTLS + WebID; (4) Authorization — ACLs on resources; (5) Semantic Layer — RDF + ontologies + inference; (6) Systems of Record — virtualized data spaces. All six are loosely coupled.
Privacy, procurement, payments, antitrust, and enterprise trust split the graph. Apple controlled the device, Google search, Microsoft work identity, banks payments. Privacy was the deepest reason — it shaped incentives and prevented total platform consolidation.
Companies intimate enough for consumers and governable enough for institutions. Microsoft, Google, and Apple exemplify this; Meta does not — it lacks the institutional governance layer.
Capability + permission without determinism amplifies errors (Dennis Juarez's pushback). A governed semantic layer — shared ontologies, inference rules, entity resolution — provides the repeatable, verifiable outputs that raw LLM generation lacks.
Virtuoso implements all six components in production: HTTP IRIs for identity/identification, mTLS+WebID for authentication, WebID-ACL for authorization, RDF+SPARQL+inference for the semantic layer, and ODBC/JDBC virtualization + SPARQL-FED + MCP tools for systems of record. It's interoperability contracts any agent can use.
Glossary

Key Concepts

Super-Agent Thesis
The US will produce an interface layer operating across fragmented systems rather than a single platform consolidating them. The shift is from owning the graph to operating across it.
Super-App (China Model)
WeChat unified personal and business context into a single surface. Extraordinary for convenience; revealed the power and danger of graph consolidation.
Bilingual in Trust
Companies intimate enough for consumers and governable enough for institutions. The US split the graph; the most strategic companies operate across both sides.
Access Is the Moat
Agents become more useful and defensible as they gain permission to act across calendars, messages, location, purchases, health data.
Permission Strategy
Anthropic's safety as a trust-building strategy for institutions; OpenAI's consumer distribution as a bid to become the default interface.
Agent Operating Space
Six loosely coupled components (Identity, Identification, Authentication, Authorization, Semantic Layer, Systems of Record) implemented through open standards.
Graph Consolidation
Social, financial, and business activity converging into dominant platform surfaces — behavior becomes more legible and controllable.
Determinism in Agent Systems
A governed semantic layer provides repeatable, verifiable outputs that raw LLM generation lacks. Capability + permission without determinism amplifies errors.
Guide

How to Build an Agent Operating Space

1

Establish identity and identification using HTTP-based identifiers

Assign every entity a dereferenceable HTTP IRI. Use WebID for agent and user identity. Link identities across platforms via owl:sameAs.

2

Implement authentication with mTLS and PKCS#12 certificates

Use mutual TLS with PKCS#12 bundles. The certificate carries the agent's WebID, cryptographically binding identity to actions.

3

Define authorization as ACLs on resources

Express authorization as WebID-ACL on WebDAV resources and SPARQL graph permissions. Authorization at the data layer.

4

Deploy a semantic layer with shared ontologies and inference

Use RDF + SPARQL + RDFS/OWL. Adopt shared ontologies (schema.org, DBpedia). The semantic layer provides the determinism that raw LLM outputs lack.

5

Virtualize data spaces rather than consolidating them

Use a virtual DBMS that compiles graph queries to SQL for in-place execution. RDF Views map relational schemas to RDF without copying data.

6

Expose all capabilities as MCP tools for AI agent consumption

Wrap identity, auth, semantic, and data layers as MCP tools. The Agent Operating Space is interoperability contracts any agent can participate in.

Workbench

Explore Knowledge Graph using SPARQL

SELECT queries use text/x-html+tr. DESCRIBE and CONSTRUCT use text/x-html-nice-turtle.

Explore Knowledge Graph using SPARQL ↗