Three essays by Ben Thompson — a paradigm bridge, a trusted bucket, and the end of apps — read through the one substrate that makes each of them concrete: a knowledge graph in Virtuoso.
Ben Thompson's trilogy is one move in three costumes: offload cognition to an external system.
The Gen AI Bridge locates it in the application layer; Write Things Down locates it in a trusted bucket that empties working memory; Apps, Agents, and Aggregation locates it in the agent that knows you. This meshup restates all three on a Semantic Web — writing things down becomes asserting RDF triples, the bucket becomes a named graph, getting things done becomes a SPARQL query, and aggregation without lock-in becomes a Platinum Layer of dereferenceable hyperlinks.
Ben Thompson keeps describing the same act — moving thought out of a limited mind and into an external system that can act on it — and keeps giving it a different costume.
The Gen AI Bridge (2024) calls it the application layer: the terminal bridged batch mainframes to interactive computing, the app bridged the PC to the smartphone, and generative AI is today's bridge to whatever comes next. Write Things Down (2026) calls it a trusted bucket: David Allen's insight that the mind is a focusing tool, not a storage place, and that an overflowing RAM is cured by emptying it somewhere you will review. Apps, Agents, and Aggregation (2026) calls it the agent: not only will we stop programming computers, we will stop using them — AI will, and whoever owns the one agent you talk to aggregates the value.
What none of the three essays identifies is the machine-computable substrate that makes these ideas work at scale: a Knowledge Graph.
This collection brings together the three essays, their key ideas and claims, the entities and concepts they reference, and the relationships connecting them, represented as machine-computable data in a Knowledge Graph.
Its practical purpose is simple: turn what would otherwise remain documents for humans to read into context that humans, applications, and AI Agents can query, connect, reuse, and act upon.
Instead of repeatedly rereading three essays to find an idea, trace a relationship, or recover a useful fact, the collection makes that knowledge directly accessible through natural language and standard query languages. It also preserves provenance, so answers can be traced back to their sources.
Running on a Semantic Web powered by Virtuoso, it turns Ben's ideas into something machines can act on:
The result is more than a collection of documents. It is a reusable context layer that turns what the essays say into knowledge that can be found, connected, verified, and put to work.
The meshup's source documents, ordered from the foundational paradigm essay to the two 2026 pieces that extend it.
Computing history is usually told through its bottom two layers — device and input — which evolve in parallel. Ben Thompson's insight is that the top layer, the application, is what carries one paradigm into the next: the terminal bridged batch to interactive, the app bridged PC to phone. The defining trait of the next paradigm, wearables, is the absence of direct mechanical input — speech, gesture, and thought. That is why generative AI, delivered through today's apps, is the bridge: the product overhang from today's models is what will build the application layer of the next paradigm.
No, Apple didn't have the App Store, but the iPhone was extraordinarily useful on day one, because it was an Internet Communicator.
David Allen's RAM metaphor is the essay's engine: the conscious mind is a focusing tool, not a storage place, and most of us walk around with our RAM bursting at the seams. Ben's confession is the heart of it — he could never run OmniFocus himself, so he hired an assistant to be his Inbox and task manager, letting him empty his RAM and write. Then the definition that makes this essay the load-bearing one for the whole meshup: Ben defines AGI as AI that learns continuously, rejecting Jensen Huang's "AGI has arrived" for GPT-6 Astra. The coda is Bostrom's warning — what we humans wish for is the danger — landing on the line this collection builds toward.
I have a perfectly organized OmniFocus installation that I never actually open myself, because someone else is my Inbox and task manager.
Writing things down is unbelievably powerful; its power will always pale in comparison to getting things done.
Opening with Steve Jobs' 2007 "three revolutionary products" reveal — an iPod, a phone, an Internet communicator that were one device — Ben Thompson runs the same move on 2026: messaging, natural interfaces, and the death of pre-built UI are not three predictions but one reality. Messaging was mobile's killer app, and the fight to be the agent users talk to is aggregation's next act: models are substitutable, but agents improve with the context and access you give them, so most people will keep only one — and the winners will be Meta and Microsoft, who already have the distribution.
These are not three separate predictions: this is reality, right now, in 2026.
Four color-coded roles fuse the three sources with a Virtuoso-backed substrate. The reframing preserves every insight while upgrading the substrate from prose and walled apps to triples and dereferenceable hyperlinks.
The application layer is the bridge between paradigms. The meshup's substrate is itself that bridge: SQL + RDF Views + SPARQL carry relational data into a Semantic Web, so data — not a screen — becomes the application layer.
The trusted bucket is the representation layer. On a Semantic Web, writing things down means asserting subject-predicate-object triples into a named graph — each thought a queryable fact, not an inert paragraph.
Aggregation is routing: whoever owns the interface captures the value. A Platinum Layer of dereferenceable hyperlinks routes attention and context to your own graph — aggregation without the walled app.
Settlement is action: "getting things done" is the query the agent runs against the graph. The system settles into an outcome — a SPARQL result, not another note — closing the loop Ben Thompson insists on.
A note in prose becomes a fact: a named subject, a predicate, an object — each with its own hyperlink.
A Virtuoso quad store holds more than RAM, never forgets, and answers SQL and SPARQL from one engine.
Dated, provenance-bearing triples accumulate without retraining a model — Ben Thompson's own AGI bar.
SPARQL is the formula the agent runs to turn "written down" into "done".
Dereferenceable hyperlinks aggregate context and identity portably — your graph as the interface, not a walled app.
No system replaces doing. The graph amplifies action; it does not substitute for it.
The Write Things Down essay's "hired assistant" and "trusted bucket" exist today as a loosely coupled memory and context layer — machine-computable entity relationships, informed by an ontology, built on the connectivity of hyperlinks.
Instead of holding everything in a context window, the agent writes things down as RDF triples and reads them back with SPARQL. Each piece of memory is a machine-computable entity relationship — not a paragraph:
core.ttl — long-term identity and core facts;preferences.ttl — the queryable behavioral contract (standing instructions as schema:HowToStep);sessions/ — episodic memory, one file per day;entities/ and howto/ — semantic entities and procedural knowledge.Because every entity is addressed by a dereferenceable hyperlink and typed by an ontology, the memory layer is loosely coupled: it is a swappable piece of the puzzle, not a walled silo.
OPAL is the runtime that composes those loosely coupled pieces into any agent: AGENT.md bootstraps behavior, SKILLS.md declares reusable capabilities, A2A (Agent2Agent) delegates across agents, MCP (Model Context Protocol) exposes tools and context, and OpenAPI-compliant specs make any service callable — all over a Virtuoso-backed Semantic Web.
McLuhan's insight, restated for a Semantic Web: as open-standards adoption broadened, the medium became so frictionless that its smoothness is the message. Watch an intention — fundamentally a CRUD operation — travel through the standards stack to the document it acts on, in one unbroken hop.
A job gets done through a fit-for-purpose agent: intent names a goal, agent capability and authorization shape what can be done, and written records help carry useful context forward.
Six load-bearing concepts from the three essays, each shown twice — as the source frames it, and as a Virtuoso-backed substrate reframes it. The insight is identical; the substrate is upgraded.
| Aspect | Stratechery framing | Semantic Web reframing |
|---|---|---|
| Offloading cognition | Write things down into a trusted bucket, or hire an assistant to run your OmniFocus inbox for you. | Assert subject-predicate-object triples into a named graph — a note becomes a queryable fact with its own IRI. |
| Continuous learning | AGI is "AI that learns continuously" — which today's frozen large language models do not do. | A knowledge graph that keeps accepting dated, provenance-bearing triples learns continuously, without retraining a model. |
| Paradigm bridge | The application layer of one paradigm is the bridge to the next — generative AI is today's bridge. | SQL + RDF Views + SPARQL bridge the relational silo to a Semantic Web, so data itself becomes the application layer. |
| Interface | Pre-built UI is dead; agents and computer use replace the screen-by-screen app. | The graph is the interface: a query replaces a screen, and a dereferenceable hyperlink is the affordance. |
| Aggregation moat | Own the agent users talk to; win with distribution and accumulated personal context. | Own your graph's dereferenceable hyperlinks — a Platinum Layer that aggregates context without a walled app. |
| From system to action | No matter how many systems you build, you still have to act — writing pales next to getting things done. | Getting things done is the query the agent runs: SPARQL turns "written down" into an action the graph can drive. |
| Memory substrate | Hire an assistant to run your OmniFocus, or trust a human to be your Inbox and task manager. | agent-rdf-memory: an RDF knowledge graph the agent queries with SPARQL — a loosely coupled memory layer that plugs into any agent. |
Seven steps that turn Ben Thompson's "write things down" into a live Semantic Web practice — from naming things with hyperlinks to acting on the graph.
Before writing anything down, give each person, project, concept, and thing a stable IRI — a dereferenceable hyperlink. This is the move Tim Berners-Lee proved for documents and that RDF extends to everything else; the IRI is the name a query will later use to find the note.
Capture each thought as subject-predicate-object: who did what to whom, what relates to what. A prose paragraph becomes several triples, each independently queryable — writing things down with the shape a machine can reason over.
Load the triples into a named graph in a Virtuoso quad store — David Allen's trusted bucket made concrete: an external store that outlives your context window, indexed for SQL and SPARQL, traceable to who asserted each fact.
Keep appending dated, provenance-bearing triples instead of retraining a model. A knowledge graph that accumulates with dateCreated and dateModified satisfies Ben Thompson's definition of AGI — it learns continuously, and every change is auditable.
Issue SPARQL queries to retrieve, join, and filter what you wrote down. This is the assistant you never have to open: a query selects the next action, surfaces a relationship, or answers a question.
Serve your graph as Linked Data so every entity resolves to its description. Stable hyperlinks aggregate context and identity without a walled app — your own interface, portable across agents.
No matter how many systems you build, you still have to act. The graph amplifies getting things done, but the coda of Write Things Down holds: writing things down will always pale in comparison to doing the things.
All three describe the same move — offloading cognition to an external system. The Gen AI Bridge locates it in the application layer, Write Things Down locates it in a trusted bucket that empties working memory, and Apps, Agents, and Aggregation locates it in an agent that knows you.
That Ben Thompson's trilogy is best realized on a Semantic Web substrate: writing things down becomes asserting RDF triples, the trusted bucket becomes a named graph in a Virtuoso quad store, "AI that learns continuously" becomes a knowledge graph that accumulates provenance, "getting things done" becomes a SPARQL query, and aggregation without lock-in becomes a Platinum Layer of dereferenceable hyperlinks.
Prose notes are searchable but not queryable: a computer cannot tell you which entities a note relates, or join two notes the way you would. An RDF triple makes each thing a named subject, each relationship a predicate, and each value an object — so an agent can retrieve, filter, and combine them with SPARQL exactly as you would reason over them yourself.
Virtuoso is a converged quad store and relational database in one engine. A text file holds statements; Virtuoso indexes them, answers SQL and SPARQL over the same data, supports named graphs for provenance, applies RDFS/OWL inference, and serves them as Linked Data over HTTP — turning "written down" into "retrievable, joinable, and resolvable".
Ben Thompson defines AGI as "AI that learns continuously." Jensen Huang declared GPT-6 Astra to be AGI, but a large language model is frozen after training — it does not keep learning — so by Ben's definition it does not qualify. The meshup observes that a continuously updated knowledge graph satisfies the definition without needing a new model.
Aggregation Theory holds that whoever owns the interface between suppliers and consumers captures the value. Applied to agents, the interface is the assistant you talk to: agents get better the more context they have about you, so most people will keep only one — and the winners will be Meta and Microsoft, who already have distribution to nearly every person and employee.
The Platinum Layer is Kingsley Idehen's extension of the medallion architecture: using dereferenceable hyperlinks as stable, standardized identifiers. If your graph is addressed by hyperlinks you control, your agent, context, and relationships are portable — you aggregate attention and context through identifiers rather than being locked into one vendor's walled app.
Ben Thompson argues we will not program computers, and eventually we will not even use them directly — AI will. Fixed, write-once-run-everywhere interfaces give way to natural language and computer use, where an agent drives the software on your behalf. The meshup's version: the graph is the interface, and a query replaces the screen.
Ben Thompson hired an assistant to run his OmniFocus so he never had to open it. The meshup's assistant is an agent that issues a SPARQL query against your knowledge graph: the query is the formula that selects the next action from everything you wrote down, closing the loop from "written down" to "done".
Ben Thompson shows that each computing paradigm — mainframe, PC, smartphone — hands off to the next through its application layer: the terminal bridged batch to interactive, the app bridged PC to phone. Generative AI matters because it is today's bridge: delivered through current apps while the product overhang from today's models builds the application layer of the next paradigm.
Not a product bake-off — a conceptual reframing. The comparison table restates six of Ben Thompson's concepts in the language of RDF, SPARQL, and Virtuoso, to show the insight is preserved while the substrate is upgraded from prose and walled apps to triples and dereferenceable hyperlinks.
Use the Knowledge Graph Explorer below to browse entities and relationships, and the SPARQL Workbench to run live queries against the graph's named graph in URIBurner. Every visible entity — people, concepts, FAQ answers, and comparison dimensions — is a dereferenceable hyperlink resolved through URIBurner.
agent-rdf-memory is an RDF-based memory and context harness — the public GitHub project at github.com/OpenLinkSoftware/ai-agent-skills/tree/main/agent-rdf-memory. It stores identity, a queryable behavioral contract, episodic sessions, and semantic entities as RDF triples addressed by hyperlinks, informed by an ontology. That is David Allen's trusted bucket — and Ben Thompson's hired assistant — made machine-computable: the agent writes things down as triples and reads them back with SPARQL instead of holding everything in a context window.
OPAL — the OpenLink AI Layer — is OpenLink Software's agent framework for composing loosely coupled pieces into any agent. AGENT.md bootstraps behavior, SKILLS.md declares reusable capabilities, A2A lets agents delegate to one another, MCP exposes tools and context, and OpenAPI-compliant specs make any service callable. Because each piece is a swappable contract over a Virtuoso-backed Semantic Web, a memory layer like agent-rdf-memory plugs in without lock-in.
Ben Thompson's signature framework: whoever owns the interface between suppliers and consumers aggregates demand and captures value — next applied to the fight to be the one agent users talk to.
The framework Ben Thompson used to rebut Mark Zuckerberg's "apps vs. people" dichotomy: users hire products to do specific jobs.
Ben Thompson's claim that the application layer of one computing paradigm provides the bridge to the next.
Generative AI as a bridge technology — valuable now as chatbots and copilots, while today's product overhang builds the next paradigm's application layer.
Moving incomplete thoughts out of working memory into a trusted external system — the human act this meshup maps onto asserting RDF triples.
David Allen's term for an external store you know you will review — in this meshup, a named graph in Virtuoso.
A set of RDF triples identified by its own IRI — the unit of provenance in a quad store.
A database that stores RDF quads (subject, predicate, object, graph) so multiple named graphs coexist — the engine Virtuoso provides alongside its relational tables.
Kingsley Idehen's extension to the medallion architecture: dereferenceable hyperlinks as stable identifiers, turning a knowledge graph into a Semantic Web aggregation surface.
A network of entities and relationships expressed as structured, machine-readable statements.
The Resource Description Framework — a W3C entity-description model in which every statement is a subject-predicate-object triple.
The W3C query language for RDF graphs — the formula an agent runs to read a knowledge graph back.
Tim Berners-Lee's project to name anything of interest with a hyperlink, giving machines the entity-description layer the Web gave documents.
Artificial general intelligence — which Ben Thompson defines as "AI that learns continuously".
David Allen's productivity methodology: capture every open loop into a trusted system so the mind can focus.
A Uniform Resource Identifier — the dereferenceable hyperlink that names a thing, and the atomic unit of this meshup's aggregation-without-lock-in.
Composing independent, swappable pieces through open contracts instead of a monolith — the design principle that lets a memory layer, a skill, a model, and a tool plug into any agent.
Durable, queryable memory for an AI agent — identity, preferences, episodic sessions, and entities stored as RDF and retrieved by SPARQL instead of held only in a context window.
A protocol for one agent to delegate tasks to another across boundaries — a loose-coupling connector in the agentic stack.
A project-level instruction file that bootstraps an agent's operating rules — the entry point through which an RDF memory protocol and a skill contract are injected.
A capability contract that declares what a skill does and when to invoke it — a reusable, loosely coupled unit of agent capability.
A machine-readable contract for HTTP APIs — the spec that makes a service discoverable and callable by any compliant agent or tool.
An open protocol for exposing tools, resources, and prompts to AI agent clients — the de facto standard for AI-to-tool communication.
A formal vocabulary of classes and relationships that gives a knowledge graph its meaning — the shared schema that keeps machine-computable relationships consistent across agents.
Publishing structured data so it can be interlinked across the Web via dereferenceable hyperlinks — the connectivity this meshup's memory layer is built on.
A named goal — the “what” a job is for; underneath, every intent is fundamentally a CRUD operation on content in a document.
Create, Read, Update, Delete — the four operations every intention ultimately reduces to when it reaches a document.
What a fit-for-purpose agent can do — skills and tools declared via SKILLS.md and exposed through MCP.
Who may do what — identity (WebID) plus per-resource access control (WebACL) gate every CRUD operation.
Durable context carried forward — what gets written down as RDF triples so the next hop has the useful context it needs.
A decentralized identity mechanism: a dereferenceable profile document that makes a person or agent its own authority.
Web Access Control — per-resource authorization (read, write, append, control) for resources on the Web.
Hypertext Transfer Protocol — the application protocol of the Web; the wire over which hyperlinks, RDF, and SPARQL travel.
text/x-html+tr; DESCRIBE/CONSTRUCT use text/x-html-nice-turtle.
Queries are scoped to the DAV-uploaded named graph https://linkeddata.uriburner.com/DAV/demos/daas/apps-agents-aggregation-bridge-notes-meshup-deepseek_v4pro-1.ttl. Every SELECT projects an IRI-valued variable (e.g. ?claimIri) alongside its label so results stay clickable.
PREFIX schema: <http://schema.org/>
SELECT ?articleIri ?article ?authorIri ?author ?date
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/apps-agents-aggregation-bridge-notes-meshup-deepseek_v4pro-1.ttl> {
?articleIri a schema:NewsArticle ; schema:name ?article ; schema:datePublished ?date ; schema:author ?authorIri .
?authorIri schema:name ?author .
}
}
ORDER BY ?date
PREFIX schema: <http://schema.org/>
SELECT ?claimIri ?claim ?authorIri ?author
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/apps-agents-aggregation-bridge-notes-meshup-deepseek_v4pro-1.ttl> {
?claimIri a schema:Claim ; schema:name ?claim ; schema:author ?authorIri .
?authorIri schema:name ?author .
}
}
ORDER BY ?author ?claim