Reading notes · agents, interfaces & written context

From Apps to Intent

Reading notes on Ben Thompson's writing about agents, interfaces, and written context. A linked Turtle knowledge graph records the claims, concepts, and agent workflows discussed here and can grow as further observations are added. The notes follow a central question: as agents make execution easier, what remains scarce is human intent and inspiration—and an agent with the skills, context, access, and permission to act. Written records can carry context forward without supplying motivation or judgment.

KG curated by OpenAI GPT-6 in Codex on behalf of Kingsley Uyi Idehen.
2024 The Gen AI Bridge to the FutureSep 8, 2026 Write Things DownSep 28, 2026 Apps, Agents, and Aggregation

Reading key: Thompson's claims are attributed. The intent-to-agent path and linked-data extension are practical implications developed in these notes.

THE INTERFACE SHIFTS
intentagentaction

Less app navigation.
More choice about what matters.

The strategic shift

The interface recedes; the agent mediates

A practical question runs through these notes: what do you want done, and which agent can do it with the right skill, context, and access?

Linked-data application: structured, linked memory could make context and provenance inspectable. That is an application of the essays, not a claim made by Thompson.
The bridge across paradigms

New devices need a new interface layer

In the 2024 essay, application-layer changes help bridge one device era to another. The final step below is the later 2026 agent thesis, marked as a forecast.

The wearable and agent-mediated entries are forecasts in the source essays, not confirmed outcomes.

The agent path

A job gets done through a fit-for-purpose agent

This flow connects the source arguments in practical terms: intent names a goal, agent capability and authorization shape what can be done, and written records help carry useful context forward.

From natural-language intent to document change

Natural language can lower the effort of stating a task: instead of first finding and learning a particular app, a person can describe the outcome. The agent must still match the request to a skill and supported operation, then check capability and authorization.

EARLIER ROUTE

Find the app. Learn its interface.

Translate the goal through varied app and protocol handoffs.

Fragmented earlier routeDashed onion layers and a tangled route illustrate app and protocol handoffs that stall before document content is changed.handofffriction
Competing handoffs interrupt the route to the document.
Goal not yet applied to the content
TODAY’S ROUTE

Say what you want done.

Example: “Update the address in this document.” → UPDATE

Intention travels through today’s layersNested layers peel back in sequence as an update request reaches document content; a result is then written down for continuity.✓
Each layer opens; the operation reaches the target.
Content updated · result written down
Protocol layers along the route from intent to document content
LayerPurposeProtocols InitiallyProtocols Today
Computing DeviceVariousVariousVarious
Operating SystemVariousVariousmacOS, Linux, Windows
Network ProtocolVariousVariousHTTP
Action APIVariousVariousMCP or OpenAPI
Data Access APIVariousVariousODBC, JDBC
Document FormatVariousVariousNegotiated
Natural language makes the goal easier to express; open standards and API contracts carry a supported, authorized operation to the document. The agent does not invent the person’s reason for acting.
Human direction remains central. Written context helps the next run pick up the thread; it does not tell a person what to value, or remove the need to set limits.
A few concrete signals

Personal example, infrastructure detail

These figures provide texture for the argument; they are not population-level measurements.

The continuity layer

Write it down. Link it. Let the next agent resume.

Thompson’s “Write Things Down” makes continuity an operational practice: his examples include an active-work queue, status board, tickler reminders, daily briefings, and next-action dialogues. A deterministic harness keeps that work legible between runs. A semantic memory layer can also connect records across tools and agents.

01 · Name the context

Turn notes into relationships

A linked memory describes named people, goals, tasks, agents, skills, resources, and provenance as machine-computable relationships. An ontology gives those links shared meaning; dereferenceable hyperlinks connect records that remain independently maintained.

This is an instance of a Semantic Web: a connected, purpose-built layer of context rather than a new monolithic agent.

Start with the public agent-rdf-memory repository, which organizes preferences, identity, ontology, index, how-to records, and session/project/entity context as RDF-Turtle.

02 · Retrieve what applies

Context follows the task

An ontology gives relationships machine-readable meaning. A query can find the records connected to the current task, while identity and property rules help a reasoner connect equivalent entities and derive relationships that were not written out directly.

Memory makes context addressable and inspectable. It does not decide what matters, create motivation, or replace human judgment.

03 · Compose the capability

Keep each piece replaceable

Pair memory with agent instruction files such as AGENT.md / AGENTS.md, skill packages such as SKILLS.md / SKILL.md, and compatible tools and service contracts. Where the host supports them, Agent2Agent (A2A) provides an open messaging and task-coordination protocol. A lead agent can delegate bounded work to agents with different functions or skills, exchange task updates, and bring their results together. Model Context Protocol (MCP) exposes tools and context; OpenAPI describes web APIs. Read the A2A protocol specification.

These are distinct integration surfaces; a host must support each convention it uses. Links and contracts let independently built pieces fit together without requiring a single bundled app.

OpenLink AI Layer (OPAL) is the OpenLink integration layer for loosely coupled agents and data spaces, with documented MCP and A2A support. OpenLink also documents OpenAPI-described web service integration.

Why the ontology matters

Relationships can carry rules

Use explicit links for known facts; let a reasoner derive only what the declared vocabulary supports.

Entity reconciliation

Explicit owl:sameAs links assert identity. A declared inverse-functional object property can also entail identity when two subjects share the same unique object.

Transitivity

If A is related to B and B to C by a transitive property, a reasoner can derive A to C. owl:sameAs is transitive too.

Symmetry

A symmetric relationship also holds in reverse. This is distinct from a one-way property.

Inverse properties

owl:inverseOf pairs two properties with subject and object roles reversed, supporting two-way queries.

Explicit identity

owl:sameAs states that two identifiers refer to the same individual; under OWL it is reflexive, symmetric, and transitive.

Inverse-functional property

When two subjects point to the same object through this property, OWL entails that they identify the same individual.

More ontology rules

Functional properties, domains, ranges, and property chains add useful constraints or entailments when their semantics fit.

Keep inference accountable

These are OWL/RDFS entailment patterns. A suitable reasoner must apply the declared axioms; RDF alone does not infer every relationship.

A tiny Turtle example · synthetic identities

Assert identity directly, or let OWL entail it from a shared unique WebID resource:

@prefix : <https://stratechery.com/2026/apps-agents-and-aggregation/#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix schema: <http://schema.org/> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .

:explicitProfileA owl:sameAs :explicitProfileB .
:hasVerifiedWebID a owl:ObjectProperty, owl:InverseFunctionalProperty ;
    rdfs:domain schema:Person ; rdfs:range schema:Thing .
:keyedProfileA :hasVerifiedWebID :sharedWebID .
:keyedProfileB :hasVerifiedWebID :sharedWebID .
# A suitable OWL reasoner entails :keyedProfileA owl:sameAs :keyedProfileB .

Semantics: W3C OWL 2 Primer. The inference depends on the inverse-functional axiom and a suitable OWL reasoner; the RDF assertion graph does not add the inferred owl:sameAs triple by itself.

Agent-to-agent division of labor

A2A makes division of agent work interoperable

CoordinateA lead agent frames the goal and splits it into bounded work.
Build agentProduce the requested output using its assigned skills and tools.
IntegrateThe coordinating agent combines returned artifacts and reports status.

A2A carries messages and coordinates tasks across compatible agents; the protocol does not itself choose the work split or guarantee that each agent can perform its assigned role.

  1. 1WriteGoal · state · next action
  2. 2LinkEntities · ontology · provenance
  3. 3RetrieveTask-relevant context
  4. 4ComposeAgent · skill · protocol · API
  5. 5ResumeAct · record · continue

The model can change; the linked record, skill, or API can change independently. A compatible agent reassembles the needed pieces around the person’s intent.

Questions worth asking

What the essays argue—and what follows for agent design

Answers distinguish Thompson's arguments from practical implications discussed here.

Why might apps matter less?

If an agent can use apps and websites on a person's behalf, the person may focus on the task while the agent treats those services as implementation details.

How can agent-rdf-memory supply reusable context?

It is a loosely coupled, ontology-informed memory and context layer. Its public repository organizes durable preferences, identity, project, and session records as linked RDF; compatible agents can retrieve relevant context while their model, skills, tools, and service connections remain separate. This is a possible architecture for putting those ideas into practice; Thompson does not propose this specific design.

Does RDF memory make every agent automatically compatible with OPAL?

No. Interoperation depends on a host supporting the relevant instruction or skill convention and on connected tools or services exposing compatible contracts such as A2A, MCP, or OpenAPI. The layer makes context explicit and linkable; it does not erase implementation differences or supply human intent.

A compact vocabulary

Terms behind the shift

The terms clarify ideas in the source arguments; the agent-skill entry describes a condition for execution.

Agent

Software that uses a model together with computer or tool access to carry out tasks.

Volition

The will or intention to choose a goal or action; a person supplies this input to agentic work.

Inspiration

The discovery or formation of a goal worth pursuing; Thompson argues this may become more important than app discovery.

Aggregation theory

A framework in which an intermediary aggregates demand and gains leverage over suppliers; Thompson applies the analogy to agents.

Generative UI

A user interface created or adapted dynamically for a particular request, user, or context.

Written context

Notes, records, or other text stored outside a model run and supplied again later to support continuity.

Harness

A surrounding software workflow that organizes tools, context, and records so an AI system can complete work across runs.

Agent skill

A capability or procedure an agent can apply to a task; relevant skills help match a person’s intent to execution.

RDF graph

A Resource Description Framework (RDF) graph is a set of named, linked statements that can preserve entities and their relationships with provenance; SPARQL can retrieve those records.

Linked agent memory

Machine-computable records about named entities and their relationships, shaped by an ontology and connected through dereferenceable hyperlinks.

Loose coupling

A design in which memory, skills, agents, tools, and services can evolve independently while remaining connectable through shared identifiers or protocol contracts.

07Knowledge Graph ExplorerExplore RDF entities and directed relationships
Explore the intent graph

Knowledge Graph Explorer

Nodes and directed links are derived from URI relationships in the companion Turtle. Select an entity or predicate to open its URIBurner description. The graph distinguishes source essays, claims, concepts, and the editorial intent-to-action path.

Click graph to zoom · click outside to release
Resource instancesOntology classes↗ Directed RDF links

Advanced graph settings

08SPARQL WorkbenchInspect and query the companion Turtle graph
Query the companion graph

SPARQL Workbench

Inspect source-linked claims with SPARQL (SPARQL Protocol and RDF Query Language) and the editorial intent path. The suggested graph has not been published; live queries require loading the Turtle there first.

Open editable query recipes

The sample query expects the suggested graph to be uploaded before it can return this collection's triples.

PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX schema: <http://schema.org/>

SELECT ?type (SAMPLE(?s) AS ?sampleEntity) (SAMPLE(?label) AS ?sampleLabel) (COUNT(?s) AS ?entityCount)
WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/from-apps-to-intent-gpt-6.ttl> { ?s rdf:type ?type . OPTIONAL { ?s rdfs:label ?label } } }
GROUP BY ?type ORDER BY DESC(?entityCount)
Explore Knowledge Graph using SPARQL

SELECT results use text/x-html+tr; DESCRIBE and CONSTRUCT use Turtle. This local collection has not been uploaded or published to the endpoint.