@prefix : <https://stratechery.com/2026/apps-agents-and-aggregation/#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix prov: <http://www.w3.org/ns/prov#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix schema: <http://schema.org/> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

<https://openai.com/codex#this> a schema:SoftwareApplication ;
    schema:name "OpenAI Codex"@en ;
    schema:version "GPT-6"@en .

:explicitProfileA a schema:Person ;
    schema:name "Synthetic profile A"@en ;
    owl:sameAs :explicitProfileB .

:hasVerifiedWebID a owl:InverseFunctionalProperty,
        owl:ObjectProperty ;
    rdfs:label "has verified WebID"@en ;
    schema:name "has verified WebID"@en ;
    rdfs:domain schema:Person ;
    rdfs:range schema:Thing .

:keyedProfileA a schema:Person ;
    schema:name "Synthetic keyed profile A"@en ;
    :hasVerifiedWebID :sharedWebID .

:keyedProfileB a schema:Person ;
    schema:name "Synthetic keyed profile B"@en ;
    :hasVerifiedWebID :sharedWebID .

:a2a-build a schema:ListItem ;
    schema:citation <https://a2a-protocol.org/latest/> ;
    schema:description "Produce the requested output using its assigned skills and tools."@en ;
    schema:isPartOf :a2a-collaboration ;
    schema:name "Build agent"@en ;
    schema:position 3 .

:a2a-coordinate a schema:ListItem ;
    schema:citation <https://a2a-protocol.org/latest/> ;
    schema:description "A lead agent frames the goal and splits it into bounded work."@en ;
    schema:isPartOf :a2a-collaboration ;
    schema:name "Coordinate"@en ;
    schema:position 1 .

:a2a-integrate a schema:ListItem ;
    schema:citation <https://a2a-protocol.org/latest/> ;
    schema:description "The coordinating agent combines returned artifacts and reports status."@en ;
    schema:isPartOf :a2a-collaboration ;
    schema:name "Integrate"@en ;
    schema:position 5 .

:a2a-research a schema:ListItem ;
    schema:citation <https://a2a-protocol.org/latest/> ;
    schema:description "Find and check the evidence needed for the task."@en ;
    schema:isPartOf :a2a-collaboration ;
    schema:name "Research agent"@en ;
    schema:position 2 .

:a2a-review a schema:ListItem ;
    schema:citation <https://a2a-protocol.org/latest/> ;
    schema:description "Check the output against the task requirements."@en ;
    schema:isPartOf :a2a-collaboration ;
    schema:name "Review agent"@en ;
    schema:position 4 .

:claim-agent-interface-power a schema:Claim ;
    schema:about <https://stratechery.com/2026/apps-agents-and-aggregation/> ;
    schema:citation <https://stratechery.com/2026/apps-agents-and-aggregation/> ;
    schema:description "An agent that understands a person and coordinates services could become a gatekeeper between users and the apps that fulfill their requests. This is Thompson's strategic forecast."@en ;
    schema:isPartOf :argument-map ;
    schema:name "The agent interface can aggregate demand"@en .

:claim-agent-requires-capability a schema:Claim ;
    schema:about <https://stratechery.com/2026/apps-agents-and-aggregation/> ;
    schema:citation <https://stratechery.com/2026/apps-agents-and-aggregation/> ;
    schema:description "Practical implication: a request becomes actionable through an agent with the relevant skill, context, computer access, and permission to act."@en ;
    schema:isPartOf :argument-map ;
    schema:name "Intent needs a capable, authorized agent"@en .

:claim-custom-ui a schema:Claim ;
    schema:about <https://stratechery.com/2024/the-gen-ai-bridge-to-the-future/> ;
    schema:citation <https://stratechery.com/2024/the-gen-ai-bridge-to-the-future/> ;
    schema:description "The 2024 essay imagines interfaces assembled on demand around the user's current request and situation, including for future wearable devices."@en ;
    schema:isPartOf :argument-map ;
    schema:name "Generative UI can adapt the interface to the moment"@en .

:claim-execution-abundance a schema:Claim ;
    schema:about <https://stratechery.com/2026/apps-agents-and-aggregation/> ;
    schema:citation <https://stratechery.com/2026/apps-agents-and-aggregation/> ;
    schema:description "Agents with computer access can perform work across apps and websites, reducing the need for each person to learn every interface."@en ;
    schema:isPartOf :argument-map ;
    schema:name "Execution is becoming abundant"@en .

:claim-human-volition a schema:Claim ;
    schema:about <https://stratechery.com/2026/write-things-down/> ;
    schema:citation <https://stratechery.com/2026/write-things-down/> ;
    schema:description "Thompson distinguishes agents' surprising actions from independent will: people set goals, and poorly framed goals can produce unintended outcomes."@en ;
    schema:isPartOf :argument-map ;
    schema:name "Human intent remains the directing force"@en .

:claim-inspiration-scarcity a schema:Claim ;
    schema:about <https://stratechery.com/2026/apps-agents-and-aggregation/> ;
    schema:citation <https://stratechery.com/2026/apps-agents-and-aggregation/> ;
    schema:description "Thompson argues that when agents can carry out tasks, helping people decide what to do becomes a scarce and valuable capability."@en ;
    schema:isPartOf :argument-map ;
    schema:name "Inspiration becomes the bottleneck"@en .

:claim-memory-is-not-motivation a schema:Claim ;
    schema:about <https://stratechery.com/2026/write-things-down/> ;
    schema:citation <https://stratechery.com/2026/write-things-down/> ;
    schema:description "Practical implication: persistent records may help an agent pick up work, but records alone do not decide what matters or why action should be taken."@en ;
    schema:isPartOf :argument-map,
        :memory-layer ;
    schema:name "Memory is not motivation"@en .

:claim-natural-language-task-expression a schema:Claim ;
    schema:citation <https://stratechery.com/2024/the-gen-ai-bridge-to-the-future/>,
        <https://stratechery.com/2026/apps-agents-and-aggregation/> ;
    schema:description "Practical synthesis: a plain-language request lets a person express the desired outcome without first finding and learning a task-specific app interface. An agent still has to resolve the request to a supported operation and check its capability and authorization."@en ;
    schema:isPartOf :protocol-journey ;
    schema:name "Natural language can lower the effort of stating a task"@en .

:claim-written-context a schema:Claim ;
    schema:about <https://stratechery.com/2026/write-things-down/> ;
    schema:citation <https://stratechery.com/2026/write-things-down/> ;
    schema:description "Thompson describes an agent-maintained queue of active and waiting work, feedback and future ideas, a categorized status board, tickler reminders, daily briefings, next-action dialogues, and a deterministic harness. Written records let later runs resume without continuous model-weight updates."@en ;
    schema:isPartOf :argument-map,
        :memory-layer ;
    schema:name "Written context gives work continuity"@en .

:earlier-interface-journey a schema:CreativeWork ;
    schema:description "People often had to find an app, learn its interface, and carry a goal through competing handoffs before changing document content. A fragmented route adds friction between intent and action."@en ;
    schema:isPartOf :protocol-journey ;
    schema:name "Earlier route: app and interface navigation"@en ;
    schema:position 1 .

:explicitProfileB a schema:Person ;
    schema:name "Synthetic profile B"@en .

:metric-2-cores a schema:PropertyValue ;
    schema:citation <https://stratechery.com/2026/apps-agents-and-aggregation/> ;
    schema:description "The article describes a two-core virtual machine as part of the agent infrastructure provisioned by Muse."@en ;
    schema:isPartOf :metrics-panel ;
    schema:name "Per-user virtual machine"@en ;
    schema:value "Per-user virtual machine"@en .

:metric-5-minutes a schema:PropertyValue ;
    schema:citation <https://stratechery.com/2026/apps-agents-and-aggregation/> ;
    schema:description "Thompson says the conversation that produced a first version took five minutes while he was walking his dog."@en ;
    schema:isPartOf :metrics-panel ;
    schema:name "Time to create a recipe app"@en ;
    schema:value "Time to create a recipe app"@en .

:metric-689-apps a schema:PropertyValue ;
    schema:citation <https://stratechery.com/2026/apps-agents-and-aggregation/> ;
    schema:description "A personal count in the source, used to illustrate the breadth of services accumulated over time."@en ;
    schema:isPartOf :metrics-panel ;
    schema:name "Apps on Thompson's phone"@en ;
    schema:value "Apps on Thompson's phone"@en .

:metric-8-gb-plus-8-gb a schema:PropertyValue ;
    schema:citation <https://stratechery.com/2026/apps-agents-and-aggregation/> ;
    schema:description "The article gives 8 GB of RAM and 8 GB of storage for the described virtual machine."@en ;
    schema:isPartOf :metrics-panel ;
    schema:name "Memory + storage"@en ;
    schema:value "Memory + storage"@en .

:opal a schema:SoftwareApplication ;
    schema:citation <https://community.openlinksw.com/t/announcing-virtuoso-release-08-03-3335/6303>,
        <https://community.openlinksw.com/t/immediate-availability-openlink-ai-layer-opal-with-mcp-a2a-support/5032> ;
    schema:description "OpenLink AI Layer connects LLM-driven agents with databases, knowledge graphs, filesystems, and described web services through loosely coupled interfaces; OpenLink sources document MCP and A2A support and OpenAPI-described service integration."@en ;
    schema:isPartOf :memory-layer ;
    schema:name "OpenLink AI Layer (OPAL)"@en ;
    schema:url <https://opal.openlinksw.com/install/> .

:property-rdf-first a schema:PropertyValue ;
    schema:name "RDF-first retrieval"@en ;
    schema:value "Files and relationships are represented in Turtle; an ontology guides context retrieval, with hyperlinks connecting independently maintained records."@en .

:protocol-value-action-api-protocols-initially a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-action-api ;
    schema:name "Protocols Initially"@en ;
    schema:propertyID "protocols-initially" ;
    schema:value "Various"@en .

:protocol-value-action-api-protocols-today a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-action-api ;
    schema:name "Protocols Today"@en ;
    schema:propertyID "protocols-today" ;
    schema:value "MCP or OpenAPI"@en .

:protocol-value-action-api-purpose a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-action-api ;
    schema:name "Purpose"@en ;
    schema:propertyID "purpose" ;
    schema:value "Various"@en .

:protocol-value-computing-device-protocols-initially a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-computing-device ;
    schema:name "Protocols Initially"@en ;
    schema:propertyID "protocols-initially" ;
    schema:value "Various"@en .

:protocol-value-computing-device-protocols-today a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-computing-device ;
    schema:name "Protocols Today"@en ;
    schema:propertyID "protocols-today" ;
    schema:value "Various"@en .

:protocol-value-computing-device-purpose a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-computing-device ;
    schema:name "Purpose"@en ;
    schema:propertyID "purpose" ;
    schema:value "Various"@en .

:protocol-value-data-access-api-protocols-initially a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-data-access-api ;
    schema:name "Protocols Initially"@en ;
    schema:propertyID "protocols-initially" ;
    schema:value "Various"@en .

:protocol-value-data-access-api-protocols-today a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-data-access-api ;
    schema:name "Protocols Today"@en ;
    schema:propertyID "protocols-today" ;
    schema:value "ODBC, JDBC"@en .

:protocol-value-data-access-api-purpose a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-data-access-api ;
    schema:name "Purpose"@en ;
    schema:propertyID "purpose" ;
    schema:value "Various"@en .

:protocol-value-document-format-protocols-initially a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-document-format ;
    schema:name "Protocols Initially"@en ;
    schema:propertyID "protocols-initially" ;
    schema:value "Various"@en .

:protocol-value-document-format-protocols-today a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-document-format ;
    schema:name "Protocols Today"@en ;
    schema:propertyID "protocols-today" ;
    schema:value "Negotiated"@en .

:protocol-value-document-format-purpose a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-document-format ;
    schema:name "Purpose"@en ;
    schema:propertyID "purpose" ;
    schema:value "Various"@en .

:protocol-value-network-protocol-protocols-initially a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-network-protocol ;
    schema:name "Protocols Initially"@en ;
    schema:propertyID "protocols-initially" ;
    schema:value "Various"@en .

:protocol-value-network-protocol-protocols-today a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-network-protocol ;
    schema:name "Protocols Today"@en ;
    schema:propertyID "protocols-today" ;
    schema:value "HTTP"@en .

:protocol-value-network-protocol-purpose a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-network-protocol ;
    schema:name "Purpose"@en ;
    schema:propertyID "purpose" ;
    schema:value "Various"@en .

:protocol-value-operating-system-protocols-initially a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-operating-system ;
    schema:name "Protocols Initially"@en ;
    schema:propertyID "protocols-initially" ;
    schema:value "Various"@en .

:protocol-value-operating-system-protocols-today a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-operating-system ;
    schema:name "Protocols Today"@en ;
    schema:propertyID "protocols-today" ;
    schema:value "macOS, Linux, Windows"@en .

:protocol-value-operating-system-purpose a schema:PropertyValue ;
    schema:isPartOf :protocol-layer-operating-system ;
    schema:name "Purpose"@en ;
    schema:propertyID "purpose" ;
    schema:value "Various"@en .

:sparql-recipe-1 a schema:SoftwareSourceCode ;
    schema:isPartOf :sparql-workbench-data ;
    schema:name "Entity type summary"@en ;
    schema:programmingLanguage "SPARQL"@en ;
    schema:target <https://linkeddata.uriburner.com/sparql> ;
    schema:text """PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
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)"""@en .

:sparql-recipe-2 a schema:SoftwareSourceCode ;
    schema:isPartOf :sparql-workbench-data ;
    schema:name "Describe the source essay"@en ;
    schema:programmingLanguage "SPARQL"@en ;
    schema:target <https://linkeddata.uriburner.com/sparql> ;
    schema:text "DESCRIBE <https://stratechery.com/2026/apps-agents-and-aggregation/> FROM <https://linkeddata.uriburner.com/DAV/demos/daas/from-apps-to-intent-gpt-6.ttl>"@en .

:sparql-recipe-3 a schema:SoftwareSourceCode ;
    schema:isPartOf :sparql-workbench-data ;
    schema:name "Construct resource links"@en ;
    schema:programmingLanguage "SPARQL"@en ;
    schema:target <https://linkeddata.uriburner.com/sparql> ;
    schema:text """PREFIX schema: <http://schema.org/>
CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/from-apps-to-intent-gpt-6.ttl> { ?s ?p ?o . FILTER(isIRI(?o)) } } LIMIT 200"""@en .

:today-intent-journey a schema:CreativeWork ;
    schema:description "A person states a desired document change in natural language. A fit-for-purpose agent resolves the example request to an UPDATE action, checks capability and authorization, then uses today's listed protocols to reach the target. Natural language eases task expression; it does not provide volition, permission, or guaranteed execution."@en ;
    schema:isPartOf :protocol-journey ;
    schema:mentions :protocol-layer-comparison ;
    schema:name "Today: natural-language intent through interoperable layers"@en ;
    schema:position 2 .

<https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/kg-generator#this> a schema:SoftwareApplication ;
    schema:description "Generates source-grounded knowledge graphs using RDF-Turtle."@en ;
    schema:name "kg-generator skill"@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/kg-generator> .

<https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/rdf-infographic-skill#this> a schema:SoftwareApplication ;
    schema:description "Renders RDF-backed accessible HTML infographics and knowledge graph explorations."@en ;
    schema:name "rdf-infographic-skill"@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/rdf-infographic-skill> .

:a2a a schema:DefinedTerm ;
    schema:citation <https://a2a-protocol.org/latest/> ;
    schema:description "An open agent-to-agent protocol for discovering capabilities, exchanging messages, and managing collaborative tasks across independent agent systems. It can support delegation and division of labor; the participating agents and host must implement compatible capabilities."@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "Agent2Agent (A2A)"@en ;
    schema:url <https://a2a-protocol.org/latest/>,
        <https://community.openlinksw.com/t/immediate-availability-openlink-ai-layer-opal-with-mcp-a2a-support/5032> .

:agent-fit a schema:ListItem ;
    schema:description "Match the request to an agent with relevant skills and useful context."@en ;
    schema:isPartOf :agent-path ;
    schema:name "Choose an agent that fits"@en ;
    schema:position 2 .

:agent-instructions a schema:DefinedTerm ;
    schema:description "host-dependent instruction-file conventions"@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "AGENT.md / AGENTS.md"@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/blob/main/AGENTS.md> .

:capability-access a schema:ListItem ;
    schema:description "The agent needs the required computer or tools and permission for the task."@en ;
    schema:isPartOf :agent-path ;
    schema:name "Check capability and access"@en ;
    schema:position 3 .

:compose-capabilities a schema:ListItem ;
    schema:description "Connect the chosen agent to its instruction and skill files, then to compatible A2A, MCP, or OpenAPI surfaces."@en ;
    schema:isPartOf :memory-layer ;
    schema:name "Compose capabilities"@en ;
    schema:position 3 .

:editorial-rdf-extension a schema:CreativeWork ;
    schema:description "Practical implication: an RDF graph can make agent context and provenance inspectable, and SPARQL can retrieve relevant records."@en ;
    schema:isPartOf :collection ;
    schema:name "An operational extension: written context as linked data"@en .

:execute-and-record a schema:ListItem ;
    schema:description "An authorized agent performs work through tools and services, then records status and next actions for later retrieval."@en ;
    schema:isPartOf :memory-layer ;
    schema:name "Act and write down"@en ;
    schema:position 4 .

:execute-task a schema:ListItem ;
    schema:description "The agent coordinates underlying apps and services as implementation resources."@en ;
    schema:isPartOf :agent-path ;
    schema:name "Carry out the task"@en ;
    schema:position 4 .

:faq-answer-1 a schema:Answer ;
    schema:isPartOf :faq-question-1 ;
    schema:name "Answer 1"@en ;
    schema:text "Thompson's answer is volition: the human will to choose a goal. He also argues that inspiration—helping people find worthwhile things to do—may become strategically valuable."@en .

:faq-answer-10 a schema:Answer ;
    schema:isPartOf :faq-question-10 ;
    schema:name "Answer 10"@en ;
    schema:text "If an agent owns the user relationship and chooses which services to use, the agent may gain bargaining power while apps and services compete to supply it."@en .

:faq-answer-11 a schema:Answer ;
    schema:isPartOf :faq-question-11 ;
    schema:name "Answer 11"@en ;
    schema:text "No. It is a strategic forecast in the 2026 essay. Adoption, trust, distribution, permissions, and the quality of agents will affect whether it happens."@en .

:faq-answer-12 a schema:Answer ;
    schema:isPartOf :faq-question-12 ;
    schema:name "Answer 12"@en ;
    schema:text "Linked, named records could make agent context inspectable, while queries retrieve the relevant source claims and task information."@en .

:faq-answer-13 a schema:Answer ;
    schema:isPartOf :faq-question-13 ;
    schema:name "Answer 13"@en ;
    schema:text "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."@en .

:faq-answer-14 a schema:Answer ;
    schema:isPartOf :faq-question-14 ;
    schema:name "Answer 14"@en ;
    schema:text "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."@en .

:faq-answer-2 a schema:Answer ;
    schema:isPartOf :faq-question-2 ;
    schema:name "Answer 2"@en ;
    schema:text "No. Here it means the will or intention to choose an action. An agent may execute a task, while a person supplies the goal and reasons for pursuing it."@en .

:faq-answer-3 a schema:Answer ;
    schema:isPartOf :faq-question-3 ;
    schema:name "Answer 3"@en ;
    schema:text "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."@en .

:faq-answer-4 a schema:Answer ;
    schema:isPartOf :faq-question-4 ;
    schema:name "Answer 4"@en ;
    schema:text "The practical implication is that an agent needs relevant skills, context, computer or tool access, and authorization to carry out an intent safely and effectively."@en .

:faq-answer-5 a schema:Answer ;
    schema:isPartOf :faq-question-5 ;
    schema:name "Answer 5"@en ;
    schema:text "In the 2026 essay, an agent can generate a custom interface for one person and one task. Such an interface can be useful without becoming a permanent, mass-market app."@en .

:faq-answer-6 a schema:Answer ;
    schema:isPartOf :faq-question-6 ;
    schema:name "Answer 6"@en ;
    schema:text "The 2024 essay imagines AI producing only the controls needed in a particular moment, which could make small or hands-free devices more usable."@en .

:faq-answer-7 a schema:Answer ;
    schema:isPartOf :faq-question-7 ;
    schema:name "Answer 7"@en ;
    schema:text "Written task records can be revisited by later model runs. In his account, this supports continuity in agent workflows without requiring the model weights to learn continuously."@en .

:faq-answer-8 a schema:Answer ;
    schema:isPartOf :faq-question-8 ;
    schema:name "Answer 8"@en ;
    schema:text "Not by itself. Thompson describes it as a way to simulate continuity: a later run can read stored context even though the model's learned weights remain unchanged."@en .

:faq-answer-9 a schema:Answer ;
    schema:isPartOf :faq-question-9 ;
    schema:name "Answer 9"@en ;
    schema:text "Thompson emphasizes the people and organizations that choose goals, provide tools, and set guardrails. Surprising behavior can expose problems in how the task was framed or supervised."@en .

:human-intent a schema:ListItem ;
    schema:description "The person chooses what is worth doing."@en ;
    schema:isPartOf :agent-path ;
    schema:name "Human intent"@en ;
    schema:position 1 .

:link-memory-records a schema:ListItem ;
    schema:description "Give goals, tasks, agents, skills, resources, and provenance stable names and typed relationships."@en ;
    schema:isPartOf :memory-layer ;
    schema:name "Link records"@en ;
    schema:position 1 .

:mcp a schema:DefinedTerm ;
    schema:description "A protocol surface for exposing and invoking tools or context across compatible clients and servers."@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "Model Context Protocol (MCP)"@en ;
    schema:url <https://community.openlinksw.com/t/introducing-the-openlink-ai-layer-mcp-server/4992> .

:openapi a schema:DefinedTerm ;
    schema:description "An API contract that lets compatible systems connect to web services from their machine-readable API descriptions."@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "OpenAPI-described services"@en ;
    schema:url <https://community.openlinksw.com/t/announcing-virtuoso-release-08-03-3335/6303> .

:paradigm-agent-interface a schema:ListItem ;
    schema:additionalType "forecast"@en ;
    schema:alternateName "Intent, skills, context, and computer access"@en ;
    schema:citation <https://stratechery.com/2026/apps-agents-and-aggregation/> ;
    schema:description "The 2026 essay suggests an agent could become the primary interface across apps and services. This is an emerging thesis, not a settled outcome."@en ;
    schema:isPartOf :paradigm-timeline ;
    schema:name "Agent-mediated computing"@en ;
    schema:position 5 .

:paradigm-mainframe a schema:ListItem ;
    schema:additionalType "historical"@en ;
    schema:alternateName "Batch computing and terminals"@en ;
    schema:citation <https://stratechery.com/2024/the-gen-ai-bridge-to-the-future/> ;
    schema:description "Programs became interactive applications, creating a bridge from mainframes to personal computers."@en ;
    schema:isPartOf :paradigm-timeline ;
    schema:name "Mainframe"@en ;
    schema:position 1 .

:paradigm-personal-computer a schema:ListItem ;
    schema:additionalType "historical"@en ;
    schema:alternateName "Desktop interfaces and the Internet"@en ;
    schema:citation <https://stratechery.com/2024/the-gen-ai-bridge-to-the-future/> ;
    schema:description "The Internet connected PCs and made services less tied to a single device."@en ;
    schema:isPartOf :paradigm-timeline ;
    schema:name "Personal computer"@en ;
    schema:position 2 .

:paradigm-smartphone a schema:ListItem ;
    schema:additionalType "historical"@en ;
    schema:alternateName "Touch interfaces and mobile Internet"@en ;
    schema:citation <https://stratechery.com/2024/the-gen-ai-bridge-to-the-future/> ;
    schema:description "Apps made Internet services available on the move; the 2026 essay emphasizes that people use them to complete many different jobs."@en ;
    schema:isPartOf :paradigm-timeline ;
    schema:name "Smartphone"@en ;
    schema:position 3 .

:paradigm-wearable a schema:ListItem ;
    schema:additionalType "forecast"@en ;
    schema:alternateName "Ambient, context-sensitive interaction"@en ;
    schema:citation <https://stratechery.com/2024/the-gen-ai-bridge-to-the-future/> ;
    schema:description "The 2024 essay forecasts interfaces that appear only when needed, helping wearables act more like general-purpose computers."@en ;
    schema:isPartOf :paradigm-timeline ;
    schema:name "Wearables"@en ;
    schema:position 4 .

:retrieve-relevant-context a schema:ListItem ;
    schema:description "Use ontology-guided queries and linked records to select what applies to the current task."@en ;
    schema:isPartOf :memory-layer ;
    schema:name "Retrieve context"@en ;
    schema:position 2 .

:sharedWebID a schema:Thing ;
    schema:name "Synthetic shared WebID resource"@en .

:skill-files a schema:DefinedTerm ;
    schema:description "host-dependent skill-package conventions"@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "SKILLS.md / SKILL.md"@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills> .

:term-agent a schema:DefinedTerm ;
    schema:definition "Software that uses a model together with computer or tool access to carry out tasks."@en ;
    schema:description "Software that uses a model together with computer or tool access to carry out tasks."@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "Agent"@en .

:term-agent-skill a schema:DefinedTerm ;
    schema:definition "A capability or procedure an agent can apply to a task; relevant skills help match a person’s intent to execution."@en ;
    schema:description "A capability or procedure an agent can apply to a task; relevant skills help match a person’s intent to execution."@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "Agent skill"@en .

:term-aggregation-theory a schema:DefinedTerm ;
    schema:definition "A framework in which an intermediary aggregates demand and gains leverage over suppliers; Thompson applies the analogy to agents."@en ;
    schema:description "A framework in which an intermediary aggregates demand and gains leverage over suppliers; Thompson applies the analogy to agents."@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "Aggregation theory"@en .

:term-entity-reconciliation a schema:DefinedTerm ;
    schema:citation <https://www.w3.org/TR/owl-primer/> ;
    schema:definition "Explicit owl:sameAs states that two IRIs denote the same individual. A suitable OWL reasoner can also entail identity when two subjects share the same object through a declared owl:InverseFunctionalProperty; the shared value must have the intended unique meaning."@en ;
    schema:description "Explicit owl:sameAs states that two IRIs denote the same individual. A suitable OWL reasoner can also entail identity when two subjects share the same object through a declared owl:InverseFunctionalProperty; the shared value must have the intended unique meaning."@en ;
    schema:example :identity-inference-example ;
    schema:inDefinedTermSet :ontology-principles ;
    schema:name "Entity reconciliation"@en .

:term-generative-ui a schema:DefinedTerm ;
    schema:definition "A user interface created or adapted dynamically for a particular request, user, or context."@en ;
    schema:description "A user interface created or adapted dynamically for a particular request, user, or context."@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "Generative UI"@en .

:term-harness a schema:DefinedTerm ;
    schema:definition "A surrounding software workflow that organizes tools, context, and records so an AI system can complete work across runs."@en ;
    schema:description "A surrounding software workflow that organizes tools, context, and records so an AI system can complete work across runs."@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "Harness"@en .

:term-inspiration a schema:DefinedTerm ;
    schema:definition "The discovery or formation of a goal worth pursuing; Thompson argues this may become more important than app discovery."@en ;
    schema:description "The discovery or formation of a goal worth pursuing; Thompson argues this may become more important than app discovery."@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "Inspiration"@en .

:term-inverse-functional-property a schema:DefinedTerm ;
    schema:citation <https://www.w3.org/TR/owl-primer/> ;
    schema:definition "owl:InverseFunctionalProperty says an object value identifies at most one subject. When two subjects point to the same object with that property, OWL entails that the subjects denote the same individual."@en ;
    schema:description "owl:InverseFunctionalProperty says an object value identifies at most one subject. When two subjects point to the same object with that property, OWL entails that the subjects denote the same individual."@en ;
    schema:inDefinedTermSet :ontology-principles ;
    schema:name "Inverse-functional property"@en .

:term-inverse-properties a schema:DefinedTerm ;
    schema:citation <https://www.w3.org/TR/owl-primer/> ;
    schema:definition "owl:inverseOf pairs two properties with reversed subject and object roles. If A has-part B, an inverse is-part-of relation can be traversed or entailed in the other direction."@en ;
    schema:description "owl:inverseOf pairs two properties with reversed subject and object roles. If A has-part B, an inverse is-part-of relation can be traversed or entailed in the other direction."@en ;
    schema:inDefinedTermSet :ontology-principles ;
    schema:name "Inverse properties"@en .

:term-linked-agent-memory a schema:DefinedTerm ;
    schema:definition "Machine-computable records about named entities and their relationships, shaped by an ontology and connected through dereferenceable hyperlinks."@en ;
    schema:description "Machine-computable records about named entities and their relationships, shaped by an ontology and connected through dereferenceable hyperlinks."@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "Linked agent memory"@en .

:term-loose-coupling a schema:DefinedTerm ;
    schema:definition "A design in which memory, skills, agents, tools, and services can evolve independently while remaining connectable through shared identifiers or protocol contracts."@en ;
    schema:description "A design in which memory, skills, agents, tools, and services can evolve independently while remaining connectable through shared identifiers or protocol contracts."@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "Loose coupling"@en .

:term-owl-sameas a schema:DefinedTerm ;
    schema:citation <https://www.w3.org/TR/owl-primer/> ;
    schema:definition "owl:sameAs asserts that two identifiers refer to the same individual. Under OWL semantics, identity is reflexive, symmetric, and transitive."@en ;
    schema:description "owl:sameAs asserts that two identifiers refer to the same individual. Under OWL semantics, identity is reflexive, symmetric, and transitive."@en ;
    schema:inDefinedTermSet :ontology-principles ;
    schema:name "Explicit identity with owl:sameAs"@en .

:term-property-axioms a schema:DefinedTerm ;
    schema:citation <https://www.w3.org/TR/owl-primer/> ;
    schema:definition "Functional properties constrain values per subject; domains and ranges support type entailments; property chains describe relationships derived by composing other properties. Use each axiom only when its meaning is justified."@en ;
    schema:description "Functional properties constrain values per subject; domains and ranges support type entailments; property chains describe relationships derived by composing other properties. Use each axiom only when its meaning is justified."@en ;
    schema:inDefinedTermSet :ontology-principles ;
    schema:name "More ontology rules"@en .

:term-rdf-graph a schema:DefinedTerm ;
    schema:definition "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."@en ;
    schema:description "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."@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "RDF graph"@en .

:term-symmetry a schema:DefinedTerm ;
    schema:citation <https://www.w3.org/TR/owl-primer/> ;
    schema:definition "A property declared owl:SymmetricProperty holds in both directions: if A relates to B, B also relates to A. This differs from a directional relationship."@en ;
    schema:description "A property declared owl:SymmetricProperty holds in both directions: if A relates to B, B also relates to A. This differs from a directional relationship."@en ;
    schema:inDefinedTermSet :ontology-principles ;
    schema:name "Symmetry"@en .

:term-transitivity a schema:DefinedTerm ;
    schema:citation <https://www.w3.org/TR/owl-primer/> ;
    schema:definition "For a property declared owl:TransitiveProperty, if A relates to B and B relates to C, a reasoner can entail that A relates to C. This supports path-based relationships such as ancestor or subtask-of."@en ;
    schema:description "For a property declared owl:TransitiveProperty, if A relates to B and B relates to C, a reasoner can entail that A relates to C. This supports path-based relationships such as ancestor or subtask-of."@en ;
    schema:inDefinedTermSet :ontology-principles ;
    schema:name "Transitivity"@en .

:term-volition a schema:DefinedTerm ;
    schema:definition "The will or intention to choose a goal or action; a person supplies this input to agentic work."@en ;
    schema:description "The will or intention to choose a goal or action; a person supplies this input to agentic work."@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "Volition"@en .

:term-wearable-computing a schema:DefinedTerm ;
    schema:definition "Computing through devices worn on the body, which the 2024 essay frames as a possible next device paradigm."@en ;
    schema:description "Computing through devices worn on the body, which the 2024 essay frames as a possible next device paradigm."@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "Wearable computing"@en .

:term-written-context a schema:DefinedTerm ;
    schema:definition "Notes, records, or other text stored outside a model run and supplied again later to support continuity."@en ;
    schema:description "Notes, records, or other text stored outside a model run and supplied again later to support continuity."@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "Written context"@en .

:write-the-result a schema:ListItem ;
    schema:description "A durable record makes status and next actions available to a later run or collaborator."@en ;
    schema:isPartOf :agent-path ;
    schema:name "Write down the result"@en ;
    schema:position 5 .

<https://www.w3.org/2001/sw/#this> a schema:DefinedTerm ;
    schema:definition "An approach to structuring and connecting data on the Web so that entities and relationships can be processed by machines."@en ;
    schema:description "An approach to structuring and connecting data on the Web so that entities and relationships can be processed by machines."@en ;
    schema:inDefinedTermSet :glossary-set ;
    schema:name "Semantic Web"@en .

<https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/agent-rdf-memory> a schema:SoftwareSourceCode ;
    schema:additionalProperty :property-rdf-first ;
    schema:citation <https://github.com/OpenLinkSoftware/ai-agent-skills>,
        <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/agent-rdf-memory> ;
    schema:codeRepository <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/agent-rdf-memory> ;
    schema:description "A public RDF-Turtle memory harness in OpenLinkSoftware/ai-agent-skills: linked core identity, preferences, ontology, index, how-to documents, sessions, projects, and entities."@en ;
    schema:isPartOf :memory-layer ;
    schema:name "agent-rdf-memory"@en .

<https://stratechery.com/#this> a schema:Organization ;
    schema:name "Stratechery"@en ;
    schema:url <https://stratechery.com/> .

:faq-question-1 a schema:Question ;
    schema:acceptedAnswer :faq-answer-1 ;
    schema:description "Reader question about agentic work, human intent, and written context."@en ;
    schema:hasPart :faq-answer-1 ;
    schema:isPartOf :faq-set ;
    schema:name "What becomes scarce when agents can do more of the execution?"@en .

:faq-question-10 a schema:Question ;
    schema:acceptedAnswer :faq-answer-10 ;
    schema:description "Reader question about agentic work, human intent, and written context."@en ;
    schema:hasPart :faq-answer-10 ;
    schema:isPartOf :faq-set ;
    schema:name "What does the aggregation analogy predict?"@en .

:faq-question-11 a schema:Question ;
    schema:acceptedAnswer :faq-answer-11 ;
    schema:description "Reader question about agentic work, human intent, and written context."@en ;
    schema:hasPart :faq-answer-11 ;
    schema:isPartOf :faq-set ;
    schema:name "Is agent-led aggregation inevitable?"@en .

:faq-question-12 a schema:Question ;
    schema:acceptedAnswer :faq-answer-12 ;
    schema:description "Reader question about agentic work, human intent, and written context."@en ;
    schema:hasPart :faq-answer-12 ;
    schema:isPartOf :faq-set ;
    schema:name "What does linked data add to agent memory and context?"@en .

:faq-question-2 a schema:Question ;
    schema:acceptedAnswer :faq-answer-2 ;
    schema:description "Reader question about agentic work, human intent, and written context."@en ;
    schema:hasPart :faq-answer-2 ;
    schema:isPartOf :faq-set ;
    schema:name "Does 'volition' mean an agent's ability to act?"@en .

:faq-question-3 a schema:Question ;
    schema:acceptedAnswer :faq-answer-3 ;
    schema:description "Reader question about agentic work, human intent, and written context."@en ;
    schema:hasPart :faq-answer-3 ;
    schema:isPartOf :faq-set ;
    schema:name "Why might apps matter less?"@en .

:faq-question-4 a schema:Question ;
    schema:acceptedAnswer :faq-answer-4 ;
    schema:description "Reader question about agentic work, human intent, and written context."@en ;
    schema:hasPart :faq-answer-4 ;
    schema:isPartOf :faq-set ;
    schema:name "What does the agent need besides a prompt?"@en .

:faq-question-5 a schema:Question ;
    schema:acceptedAnswer :faq-answer-5 ;
    schema:description "Reader question about agentic work, human intent, and written context."@en ;
    schema:hasPart :faq-answer-5 ;
    schema:isPartOf :faq-set ;
    schema:name "What is the 'infinite app' idea?"@en .

:faq-question-6 a schema:Question ;
    schema:acceptedAnswer :faq-answer-6 ;
    schema:description "Reader question about agentic work, human intent, and written context."@en ;
    schema:hasPart :faq-answer-6 ;
    schema:isPartOf :faq-set ;
    schema:name "How does generative UI connect to wearables?"@en .

:faq-question-7 a schema:Question ;
    schema:acceptedAnswer :faq-answer-7 ;
    schema:description "Reader question about agentic work, human intent, and written context."@en ;
    schema:hasPart :faq-answer-7 ;
    schema:isPartOf :faq-set ;
    schema:name "Why does Thompson discuss writing things down?"@en .

:faq-question-8 a schema:Question ;
    schema:acceptedAnswer :faq-answer-8 ;
    schema:description "Reader question about agentic work, human intent, and written context."@en ;
    schema:hasPart :faq-answer-8 ;
    schema:isPartOf :faq-set ;
    schema:name "Does a written memory make an AI continuously learning?"@en .

:faq-question-9 a schema:Question ;
    schema:acceptedAnswer :faq-answer-9 ;
    schema:description "Reader question about agentic work, human intent, and written context."@en ;
    schema:hasPart :faq-answer-9 ;
    schema:isPartOf :faq-set ;
    schema:name "Who is responsible when an agent pursues a bad outcome?"@en .

:identity-inference-example a schema:CreativeWork ;
    schema:citation <https://www.w3.org/TR/owl-primer/> ;
    schema:description "Synthetic Turtle example contrasting asserted owl:sameAs identity with identity entailed through a shared object of a declared inverse-functional object property."@en ;
    schema:isPartOf :ontology-principles ;
    schema:name "Illustrative entity-reconciliation example"@en ;
    schema:text """# Explicit identity assertion
:explicitProfileA owl:sameAs :explicitProfileB .

# Shared unique WebID resource; a suitable OWL reasoner entails
# :keyedProfileA owl:sameAs :keyedProfileB .
:hasVerifiedWebID a owl:ObjectProperty, owl:InverseFunctionalProperty ;
    rdfs:domain schema:Person ;
    rdfs:range schema:Thing .
:keyedProfileA :hasVerifiedWebID :sharedWebID .
:keyedProfileB :hasVerifiedWebID :sharedWebID ."""@en .

<https://www.linkedin.com/in/benjaminjthompson#this> a schema:Person ;
    schema:name "Ben Thompson"@en ;
    schema:url <https://www.linkedin.com/in/benjaminjthompson> ;
    owl:sameAs <https://x.com/benthompson#this> .

:faq-question-13 a schema:Question ;
    schema:acceptedAnswer :faq-answer-13 ;
    schema:hasPart :faq-answer-13 ;
    schema:isPartOf :faq-set ;
    schema:name "How can agent-rdf-memory supply reusable context?"@en .

:faq-question-14 a schema:Question ;
    schema:acceptedAnswer :faq-answer-14 ;
    schema:hasPart :faq-answer-14 ;
    schema:isPartOf :faq-set ;
    schema:name "Does RDF memory make every agent automatically compatible with OPAL?"@en .

:protocol-layer-action-api a schema:ListItem ;
    schema:additionalProperty :protocol-value-action-api-protocols-initially,
        :protocol-value-action-api-protocols-today,
        :protocol-value-action-api-purpose ;
    schema:isPartOf :protocol-layer-comparison ;
    schema:name "Action API"@en ;
    schema:position 4 .

:protocol-layer-computing-device a schema:ListItem ;
    schema:additionalProperty :protocol-value-computing-device-protocols-initially,
        :protocol-value-computing-device-protocols-today,
        :protocol-value-computing-device-purpose ;
    schema:isPartOf :protocol-layer-comparison ;
    schema:name "Computing Device"@en ;
    schema:position 1 .

:protocol-layer-data-access-api a schema:ListItem ;
    schema:additionalProperty :protocol-value-data-access-api-protocols-initially,
        :protocol-value-data-access-api-protocols-today,
        :protocol-value-data-access-api-purpose ;
    schema:isPartOf :protocol-layer-comparison ;
    schema:name "Data Access API"@en ;
    schema:position 5 .

:protocol-layer-document-format a schema:ListItem ;
    schema:additionalProperty :protocol-value-document-format-protocols-initially,
        :protocol-value-document-format-protocols-today,
        :protocol-value-document-format-purpose ;
    schema:isPartOf :protocol-layer-comparison ;
    schema:name "Document Format"@en ;
    schema:position 6 .

:protocol-layer-network-protocol a schema:ListItem ;
    schema:additionalProperty :protocol-value-network-protocol-protocols-initially,
        :protocol-value-network-protocol-protocols-today,
        :protocol-value-network-protocol-purpose ;
    schema:isPartOf :protocol-layer-comparison ;
    schema:name "Network Protocol"@en ;
    schema:position 3 .

:protocol-layer-operating-system a schema:ListItem ;
    schema:additionalProperty :protocol-value-operating-system-protocols-initially,
        :protocol-value-operating-system-protocols-today,
        :protocol-value-operating-system-purpose ;
    schema:isPartOf :protocol-layer-comparison ;
    schema:name "Operating System"@en ;
    schema:position 2 .

:sparql-workbench-data a schema:CreativeWork ;
    schema:description "Three editable SPARQL recipes for inspecting entity types, source claims, and the intent-to-action path."@en ;
    schema:hasPart :sparql-recipe-1,
        :sparql-recipe-2,
        :sparql-recipe-3 ;
    schema:isPartOf :collection ;
    schema:name "Query the companion graph"@en .

<https://www.linkedin.com/in/kidehen#this> a schema:Person ;
    schema:name "Kingsley Uyi Idehen"@en .

:metrics-panel a schema:CreativeWork ;
    schema:description "A handful of figures reported in the 2026 essay; each remains attached to its source and context."@en ;
    schema:hasPart :metric-2-cores,
        :metric-5-minutes,
        :metric-689-apps,
        :metric-8-gb-plus-8-gb ;
    schema:isPartOf :collection ;
    schema:name "Small figures, large shift"@en .

:protocol-journey a schema:CreativeWork ;
    schema:citation <https://stratechery.com/2024/the-gen-ai-bridge-to-the-future/>,
        <https://stratechery.com/2026/apps-agents-and-aggregation/>,
        <https://stratechery.com/2026/write-things-down/> ;
    schema:description "A person states a goal in natural language; a fit-for-purpose agent resolves it to an authorized action, and interoperable interfaces carry that action to content in a document. The layered path connects intent with execution and written continuity."@en ;
    schema:hasPart :claim-natural-language-task-expression,
        :earlier-interface-journey,
        :protocol-layer-comparison,
        :today-intent-journey ;
    schema:isPartOf :agent-path,
        :collection ;
    schema:name "From natural-language intent to document change"@en .

:a2a-collaboration a schema:ItemList ;
    schema:citation <https://a2a-protocol.org/latest/> ;
    schema:description "A coordinating agent can delegate bounded workstreams to function-specific agents through messages and task coordination, then assemble their results. This example illustrates one way to organize agent work."@en ;
    schema:isPartOf :memory-layer ;
    schema:itemListElement :a2a-build,
        :a2a-coordinate,
        :a2a-integrate,
        :a2a-research,
        :a2a-review ;
    schema:name "A2A makes division of agent work interoperable"@en .

:paradigm-timeline a schema:CreativeWork ;
    schema:description "A source-attributed timeline from mainframes to a possible agent-mediated interface."@en ;
    schema:hasPart :paradigm-agent-interface,
        :paradigm-mainframe,
        :paradigm-personal-computer,
        :paradigm-smartphone,
        :paradigm-wearable ;
    schema:isPartOf :collection ;
    schema:itemListElement :paradigm-agent-interface,
        :paradigm-mainframe,
        :paradigm-personal-computer,
        :paradigm-smartphone,
        :paradigm-wearable ;
    schema:name "The interface keeps moving"@en .

:agent-path a schema:CreativeWork ;
    schema:description "A possible workflow: a person chooses a goal; an agent with relevant context, tools, and authorization acts; results are recorded for follow-up."@en ;
    schema:hasPart :agent-fit,
        :capability-access,
        :execute-task,
        :human-intent,
        :protocol-journey,
        :write-the-result ;
    schema:isPartOf :collection ;
    schema:itemListElement :agent-fit,
        :capability-access,
        :execute-task,
        :human-intent,
        :write-the-result ;
    schema:name "Intent becomes action through an agent"@en .

:protocol-layer-comparison a schema:ItemList ;
    schema:description "A six-layer comparison of purpose, initial protocols, and the interfaces used today on the route to document content."@en ;
    schema:isPartOf :protocol-journey ;
    schema:itemListElement :protocol-layer-action-api,
        :protocol-layer-computing-device,
        :protocol-layer-data-access-api,
        :protocol-layer-document-format,
        :protocol-layer-network-protocol,
        :protocol-layer-operating-system ;
    schema:name "Protocol layers: initial variety and protocols today"@en .

:argument-map a schema:CreativeWork ;
    schema:description "Notes connecting agentic action, human intention, and written context."@en ;
    schema:hasPart :claim-agent-interface-power,
        :claim-agent-requires-capability,
        :claim-custom-ui,
        :claim-execution-abundance,
        :claim-human-volition,
        :claim-inspiration-scarcity,
        :claim-memory-is-not-motivation,
        :claim-written-context ;
    schema:isPartOf :collection ;
    schema:name "From discovery to intention"@en .

<https://stratechery.com/2024/the-gen-ai-bridge-to-the-future/> a schema:Article ;
    schema:author <https://www.linkedin.com/in/benjaminjthompson#this> ;
    schema:datePublished "2024-12-02"^^xsd:date ;
    schema:description "Thompson describes generative AI as a possible application-layer bridge from current devices toward wearables: interfaces could appear on demand, adapted to a person's request and context."@en ;
    schema:headline "The Gen AI Bridge to the Future"@en ;
    schema:inLanguage "en"@en ;
    schema:isPartOf :collection ;
    schema:name "The Gen AI Bridge to the Future"@en ;
    schema:publisher <https://stratechery.com/#this> ;
    schema:url <https://stratechery.com/2024/the-gen-ai-bridge-to-the-future/> .

:memory-layer a schema:ArticleSection ;
    schema:about <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/agent-rdf-memory>,
        :a2a,
        :agent-instructions,
        :mcp,
        :ontology-principles,
        :opal,
        :openapi,
        :skill-files,
        :term-entity-reconciliation,
        :term-inverse-functional-property,
        :term-inverse-properties,
        :term-linked-agent-memory,
        :term-loose-coupling,
        :term-owl-sameas,
        :term-property-axioms,
        :term-symmetry,
        :term-transitivity,
        <https://www.w3.org/2001/sw/#this> ;
    schema:citation <https://stratechery.com/2026/write-things-down/> ;
    schema:description "Ontology-linked memory can make relevant context inspectable by compatible agents, while skills, instructions, protocols, and APIs remain independently replaceable."@en ;
    schema:hasPart :a2a-collaboration,
        :compose-capabilities,
        :execute-and-record,
        :identity-inference-example,
        :link-memory-records,
        :ontology-principles,
        :retrieve-relevant-context ;
    schema:headline "Write context once; let compatible agents pick up the thread"@en ;
    schema:isPartOf :collection ;
    schema:itemListElement :compose-capabilities,
        :execute-and-record,
        :link-memory-records,
        :retrieve-relevant-context ;
    schema:name "A loosely coupled memory layer"@en ;
    prov:wasDerivedFrom <https://stratechery.com/2026/write-things-down/> .

:ontology-principles a schema:DefinedTermSet ;
    schema:citation <https://www.w3.org/TR/owl-primer/> ;
    schema:description "OWL and RDFS axioms describe when identities or relationships can be reconciled or entailed. These effects depend on declared axioms and an applicable reasoner; RDF does not infer every relationship automatically."@en ;
    schema:example :identity-inference-example ;
    schema:hasDefinedTerm :term-entity-reconciliation,
        :term-inverse-functional-property,
        :term-inverse-properties,
        :term-owl-sameas,
        :term-property-axioms,
        :term-symmetry,
        :term-transitivity ;
    schema:name "Ontology rules make entity links useful"@en .

<https://stratechery.com/2026/write-things-down/> a schema:Article ;
    schema:author <https://www.linkedin.com/in/benjaminjthompson#this> ;
    schema:datePublished "2026-09-08"^^xsd:date ;
    schema:description "Thompson connects written records to human coordination and agent workflows. He argues that notes and harnesses can simulate continuity for non-persistent models, while human intent and responsibility remain central."@en ;
    schema:headline "Write Things Down"@en ;
    schema:inLanguage "en"@en ;
    schema:isPartOf :collection ;
    schema:name "Write Things Down"@en ;
    schema:publisher <https://stratechery.com/#this> ;
    schema:url <https://stratechery.com/2026/write-things-down/> .

:collection a schema:CreativeWork ;
    schema:about :editorial-rdf-extension,
        :memory-layer ;
    schema:abstract "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."@en ;
    schema:accountablePerson <https://www.linkedin.com/in/kidehen#this> ;
    schema:citation <https://stratechery.com/2024/the-gen-ai-bridge-to-the-future/>,
        <https://stratechery.com/2026/apps-agents-and-aggregation/>,
        <https://stratechery.com/2026/write-things-down/> ;
    schema:description "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."@en ;
    schema:hasPart <https://stratechery.com/2024/the-gen-ai-bridge-to-the-future/>,
        <https://stratechery.com/2026/apps-agents-and-aggregation/>,
        :a2a-collaboration,
        :agent-path,
        :argument-map,
        :editorial-rdf-extension,
        :faq-question-13,
        :faq-question-14,
        :faq-set,
        :glossary-set,
        :memory-layer,
        :metrics-panel,
        :ontology-principles,
        :paradigm-timeline,
        :protocol-journey,
        :sparql-workbench-data,
        <https://stratechery.com/2026/write-things-down/> ;
    schema:inLanguage "en"@en ;
    schema:isPartOf <https://stratechery.com/2026/apps-agents-and-aggregation/> ;
    schema:name "Notes on Apps, Agents, and Intent"@en ;
    prov:actedOnBehalfOf <https://www.linkedin.com/in/kidehen#this> ;
    prov:wasGeneratedBy <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/kg-generator#this>,
        <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/rdf-infographic-skill#this> .

:faq-set a schema:CreativeWork,
        schema:FAQPage ;
    schema:description "Answers distinguish Thompson's arguments from practical implications discussed here."@en ;
    schema:hasPart :faq-question-1,
        :faq-question-10,
        :faq-question-11,
        :faq-question-12,
        :faq-question-13,
        :faq-question-14,
        :faq-question-2,
        :faq-question-3,
        :faq-question-4,
        :faq-question-5,
        :faq-question-6,
        :faq-question-7,
        :faq-question-8,
        :faq-question-9 ;
    schema:isPartOf :collection ;
    schema:mainEntity :faq-question-1,
        :faq-question-10,
        :faq-question-11,
        :faq-question-12,
        :faq-question-13,
        :faq-question-14,
        :faq-question-2,
        :faq-question-3,
        :faq-question-4,
        :faq-question-5,
        :faq-question-6,
        :faq-question-7,
        :faq-question-8,
        :faq-question-9 ;
    schema:name "Frequently asked questions"@en .

<https://stratechery.com/2026/apps-agents-and-aggregation/> a schema:Article,
        schema:CreativeWork ;
    schema:about :collection ;
    schema:accountablePerson <https://www.linkedin.com/in/kidehen#this> ;
    schema:author <https://www.linkedin.com/in/benjaminjthompson#this>,
        <https://www.linkedin.com/in/kidehen#this> ;
    schema:dateCreated "2026-09-28" ;
    schema:datePublished "2026-09-28"^^xsd:date ;
    schema:description "A source-grounded RDF collection connecting three Stratechery essays about agents, generative interfaces, and written context."@en,
        "An agent can operate a computer, create task-specific interfaces, and mediate between human intent and underlying apps or services. Thompson argues that as execution becomes abundant, inspiration and control of the agent interface become more consequential."@en ;
    schema:hasPart :agent-path,
        :argument-map,
        :collection,
        :faq-set,
        :glossary-set,
        :metrics-panel,
        :paradigm-timeline,
        :sparql-workbench-data ;
    schema:headline "Apps, Agents, and Aggregation"@en ;
    schema:inLanguage "en",
        "en"@en ;
    schema:name "Apps, Agents, and Aggregation"@en,
        "From Apps to Intent: The Agent as Interface — Collection Document"@en ;
    schema:publisher <https://stratechery.com/#this> ;
    schema:url <https://stratechery.com/2026/apps-agents-and-aggregation/> ;
    prov:actedOnBehalfOf <https://www.linkedin.com/in/kidehen#this> ;
    prov:wasGeneratedBy <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/kg-generator#this>,
        <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/rdf-infographic-skill#this> .

:glossary-set a schema:CreativeWork,
        schema:DefinedTermSet ;
    schema:description "Definitions for concepts in these reading notes on agents, intent, and written context."@en ;
    schema:hasDefinedTerm :a2a,
        :agent-instructions,
        :mcp,
        :openapi,
        :skill-files,
        :term-agent,
        :term-agent-instructions,
        :term-agent-skill,
        :term-aggregation-theory,
        :term-generative-ui,
        :term-harness,
        :term-inspiration,
        :term-linked-agent-memory,
        :term-loose-coupling,
        :term-rdf-graph,
        :term-volition,
        :term-wearable-computing,
        :term-written-context,
        <https://www.w3.org/2001/sw/#this> ;
    schema:hasPart :term-agent,
        :term-agent-skill,
        :term-aggregation-theory,
        :term-generative-ui,
        :term-harness,
        :term-inspiration,
        :term-rdf-graph,
        :term-volition,
        :term-wearable-computing,
        :term-written-context ;
    schema:isPartOf :collection ;
    schema:name "Core terms"@en .