How to read the marks
The claim restates or paraphrases what one of the three source essays says.
The claim restates what a standard, specification or documentation page says.
The claim is this collection's own reading, built on the claims it cites.
Where power moves¶
From discovery to intent
Essay-backed. For a long time the hard problem on the web was finding things. Apps, Agents, and Aggregation argues that agents change what is scarce: doing becomes cheap, and wanting becomes the bottleneck.
Essay-backed. An Agent, in the essay's sense, is an AI with access to a computer. Give it one and it can use any app or website a person would rather not open, so Volition, and not the ability to act, is what runs short. The author reports that the number of apps he looks at is plummeting, while the services behind them become suppliers to the agent.
Essay-backed. That moves the contest. Publishing became free, so discovery decided who held power. With agents the problem to solve is Inspiration, and the essay expects whoever solves it to gain power over every entity that has things to be done. Because an agent improves with the context, logins and files it holds, most people are expected to keep only one, so choosing it carries a weight that choosing an app never did.
Collection synthesis. Read plainly, that leaves a person two decisions that cannot be delegated: what to accomplish, and which agent, with the skills and the Authorization for the job, to trust with it. In Aggregation Theory terms the prize moves from the aggregator of demand to the agent a person trusts with their intent. Everything downstream of those two decisions is work an agent can do.
| Aspect | Discovery era: web and apps | Agent era: intent and action | Evidence |
|---|---|---|---|
| What is abundant | Publication and distribution | The ability to act on the web and in apps | Essay-backed |
| What is scarce | Finding the right thing, and attention | Volition: knowing what you want done | Essay-backed |
| Where the power sits | With aggregators that solve discovery and gather demand | With whoever solves inspiration, and with the agent a person chooses | Essay-backed |
| Role of the app | The destination a person opens | An implementation detail behind the agent | Essay-backed |
| The interface | Pre-built, written once for everyone | Generated for the person and the moment | Essay-backed |
| What the person chooses | Which apps and services to open | What to accomplish, and which agent to trust with it | Collection synthesis |
| Cost of switching | Low for any single app | Rises with the context, logins and files the agent holds | Essay-backedCollection synthesis |
Evidence for this section9 essay-backed 1 synthesis
- Essay-backed
In the essay's framing an agent is an AI that has access to a computer: models do not replace computers, they operate them, which is why a useful agent needs a computer of its own.
Source: Apps, Agents, and Aggregation - Essay-backed
Agents make the ability to do things on the web and in apps abundant, and what remains scarce is volition.
Source: Apps, Agents, and Aggregation - Essay-backed
When distribution became free the problem to solve was discovery, and the companies that solved it aggregated demand. With agents the problem to solve moves from discovery to inspiration, and whoever solves inspiration gains power over every entity that has things that need to be done.
Source: Apps, Agents, and Aggregation - Essay-backed
Once a user is focused on a problem, the apps and services needed to solve it are abstracted into implementation details, suppliers beneath the agent.
Source: Apps, Agents, and Aggregation - Essay-backed
Models are relatively substitutable, but agents work better the more context they hold about a person and the more access they have to logins and files. That makes them sticky, and most people and companies will keep only one agent.
Source: Apps, Agents, and Aggregation - Essay-backed
An agent of the user's choosing can generate a custom app on command, so an app can be disposable because it is effectively infinite.
Source: Apps, Agents, and Aggregation - Essay-backed
With computer use an agent can operate an app through its own interface, so acting does not depend solely on an underdeveloped and intentionally limited API.
Source: Apps, Agents, and Aggregation - Essay-backed
The first agent products that fit the use case come from Meta and Microsoft, companies with distribution to nearly every person and nearly every employee respectively.
Source: Apps, Agents, and Aggregation - Essay-backed
Volition and a sense of morality are what AI lacks; they come from humans, cannot be transposed into Markdown files, and leave agents directed by others.
Source: Write Things Down - Collection synthesis
Power shifts from app discovery to two decisions the person keeps: what they want to accomplish, and which agent, with the necessary skills and authorization, they trust to do it.
A job getting done¶
Intent, capability, authorization, record
Collection synthesis. Turn the shift into something practical: a job gets done when four things line up.
Collection synthesis. The first is an Intent: what the person wants done, stated plainly. It echoes the Jobs to be done framing that Apps, Agents, and Aggregation revives from 2014, in which neither the app nor the person is the centre of the phone; the job is.
Collection synthesis. The second is agent capability: the skills and tools the agent brings. The third is authorization: the access the person grants for this job and no more. They are separate. An agent can be capable and unauthorized, or authorized and unable, and either way the job stops.
Collection synthesis. The fourth is a written record: what is already known, kept where the agent can read it. When the job finishes, its outcome becomes context for the next one, which is why the diagram loops.
| Part | The question it answers | Who supplies it | It fails when | Evidence |
|---|---|---|---|---|
| Intent | What do I want done? | The person, from their own volition | It is vague, or nobody asked for it | Collection synthesisEssay-backed |
| Agent capability | Can this agent do it? | The agent's skills and tools | The agent lacks a skill or a tool the job needs | Collection synthesis |
| Authorization | May this agent do it for me? | The person, scoped to this job | Access is too broad, or missing | Collection synthesis |
| Written record | What is already known? | Earlier records, linked to one another | Context lives only in one chat, or one agent | Collection synthesis |
Essay-backed. The Gen AI Bridge to the Future adds a sense of how the interface fits: generative AI can produce exactly the interface a person needs at the moment they need it, so the interface for a job can be as small as the job.
Evidence for this section2 essay-backed 2 synthesis
- Essay-backed
In a 2014 argument the essay reproduces, neither apps nor people are the centre of a phone; the jobs to be done are.
Source: Apps, Agents, and Aggregation - Essay-backed
Generative AI can deliver the exact interface a person needs and nothing more, generated on the fly from the context of the request and of the person's surroundings.
Source: The Gen AI Bridge to the Future - Collection synthesis
A job gets done when four things line up: an intent, an agent with the capability, an authorization scoped to the job, and written records of context.
- Collection synthesis
Capability says what an agent can do and authorization says what it may do for this person; the two are separate, and a job needs both.
Builds on: A job needs four things to line up
Writing things down¶
Context that outlives the moment
Essay-backed. An agent that cannot remember cannot resume, and writing is the oldest cure.
Essay-backed. Write Things Down makes the point from two directions. For people, writing scaled learning where biology and speech could not, and David Allen's Getting Things Done compares the mind to RAM: open loops belong in a trusted place that is reviewed. For models, the essay notes that a language model is not a persistent entity, since each new token is computed from context read anew, so a model has always had to write things down to carry on.
Essay-backed. The practical form is the Harness. A workflow that writes copious notes in Markdown files and reads them back into context is a crude memory: it simulates continuous learning while the model stays frozen. The author's own version began as a list of what he was working on, what was waiting and what was queued, grew into a status board, and was rebuilt as a deterministic harness he intends to scale.
Collection synthesis. Notes kept inside one agent help that agent. Records that are linked and machine-readable can help any task: identify each record by a hyperlink, describe it with a shared vocabulary, and a later task, or a different agent, can find it, follow it to related records and query it. That is the difference the table shows, and the reason this collection stores its own claims as a graph.
| Aspect | Notes held by one agent | Linked, machine-readable records | Evidence |
|---|---|---|---|
| How it is found | By that agent, in its own store | By hyperlink, from any task or agent that has the link | Collection synthesis |
| What it leads to | Nothing beyond the note | Further records, sources and definitions, by following links | Collection synthesis |
| How it is queried | By reading it again | With SPARQL, across all records at once | Collection synthesis |
| If the agent is replaced | The context stays behind | The context stays with the records | Essay-backedCollection synthesis |
| When two records describe one thing | They stay two | sameAs links or an inverse-functional key let them be read as one | Collection synthesis |
| Where it came from | Often not recorded | Provenance can be stated in the same graph | Collection synthesis |
Essay-backed. None of this supplies the wanting. The essay closes by separating the two: volition and morality come from humans and cannot be moved into Markdown files, and writing things down matters less than actually doing the things.
Collection synthesis. Persisted context lets an agent resume; a person still decides which job comes next.
Evidence for this section6 essay-backed 2 synthesis
- Essay-backed
A harness that writes copious notes in Markdown files and reads them back into context is a crude form of memory: it simulates continuous learning even though the model itself stays frozen.
Source: Write Things Down - Essay-backed
Language models are not persistent entities: every new token is computed from context that is read anew, so a model has always had to write things down in order to continue.
Source: Write Things Down - Essay-backed
Writing is what made learning extendable and scalable, in contrast to slow biological evolution and lossy oral communication.
Source: Write Things Down - Essay-backed
Getting Things Done compares short-term memory to RAM: open loops held there drain focus, so they belong in a trusted place that is reviewed on a schedule.
Source: Write Things Down - Essay-backed
The author built an agent workflow that writes down active, waiting and queued work, then a status board, and rebuilt it as a deterministic harness that he intends to scale.
Source: Write Things Down - Essay-backed
Writing things down is powerful, but its power pales beside getting things done: a system is not a substitute for acting.
Source: Write Things Down - Collection synthesis
Written context carries between tasks and between agents most reliably when it is linked and machine-readable, with records identified by hyperlinks and described by shared vocabularies, rather than held in one agent's private notes.
- Collection synthesis
Persisting context lets an agent resume, but it does not supply volition: a person still decides which job is worth doing next.
A memory layer for agents¶
agent-rdf-memory and the open standards
Collection synthesis. agent-rdf-memory is a memory and context layer for agents, built the way the Semantic Web builds everything: things are named by hyperlinks, described by ontologies and joined by relationships.
Collection synthesis. Concretely, it is a folder of Turtle documents: core facts and identity, a manifest of standing preferences written as how-to steps, an ontology, an index of sessions, and further project, entity and how-to documents. An agent can read them as plain files or, where a Virtuoso endpoint exists, query them with SPARQL. A nine-step retrieval protocol, itself written in the folder, says how to load them at the start of a session (agent-rdf-memory (OpenLink ai-agent-skills repository)).
Collection synthesis. It is loosely coupled in the sense that matters for interoperability. No service is required, each document stands alone, and documents connect only through hyperlinks, so any tool that can read a file or issue an HTTP request can take part.
Collection synthesis. It does not compete with the standards agents already use. It sits beside them and supplies the one thing none of them owns: linked context that any of them can point to. The table takes them one at a time.
| Piece | What it standardizes | How agent-rdf-memory relates (collection synthesis) | Evidence |
|---|---|---|---|
| AGENTS.md | A plain Markdown file giving coding agents predictable, agent-focused instructions; often also written AGENT.md. | Instructions point to the memory. An AGENTS.md can tell the agent to load the memory first, so standing rules are queryable steps rather than prose to re-read. | Collection synthesisSpecification-backed |
| SKILL.md skill package | A folder whose SKILL.md tells an agent how to perform a class of task; often also written SKILLS.md. | The memory records which skills ran, naming each by a stable hyperlink, so a later task can find how a result was produced. | Collection synthesis |
| Model Context Protocol (MCP) | An open-source standard for connecting AI applications to external systems: data sources, tools and workflows. | MCP lets an agent act on tools and data. The memory is one of the sources it can reach, and an MCP tool that runs SPARQL can query it. | Collection synthesisSpecification-backed |
| OpenAPI Specification | A standard, language-agnostic description of an HTTP API that both people and machines can read. | A SPARQL endpoint is itself an HTTP API, so an OpenAPI-described function can query the graph; the memory names the operation and its result by hyperlink. | Collection synthesisSpecification-backed |
| Agent2Agent (A2A) Protocol | An open protocol for communication and collaboration between AI agents built on different frameworks by different vendors. | Agents that keep their internals private can still share context by passing hyperlinks to records in a task message. | Collection synthesisSpecification-backed |
| OPAL (OpenLink AI Layer) | OpenLink's layer for agents, skills and function tools, reachable through OpenAPI, MCP and A2A interfaces. | OPAL exposes agents, skills and function tools through these interfaces; the memory supplies context that none of them owns. | Collection synthesis |
Collection synthesis. Within OPAL, the OpenLink AI Layer, agents, skills and function tools are reachable through OpenAPI descriptions, MCP tools and an A2A endpoint with an Agent Card (opal-agent-skill-assembler skill (OpenLink ai-agent-skills repository)). Because the memory layer is only linked documents, the same context can serve an agent that arrives by any of those routes.
Naming varies in practice: AGENTS.md is often written AGENT.md, and a SKILL.md package is sometimes written SKILLS.md. This page uses the names as published by agents.md and by the skill packages in the repository.
Evidence for this section3 specification-backed 4 synthesis
- Specification-backed
The Model Context Protocol is an open-source standard for connecting AI applications to external systems: data sources, tools and workflows.
- Specification-backed
AGENTS.md gives coding agents a clear, predictable place for the build steps, tests and conventions that would clutter a README.
Source: AGENTS.md - Specification-backed
The OpenAPI Specification defines a standard, programming-language-agnostic interface description for HTTP APIs, so that both people and machines can understand what a service offers without reading its source code.
Source: OpenAPI Specification - Collection synthesis
agent-rdf-memory is a loosely coupled memory and context layer: Turtle documents whose entities and relationships are identified by hyperlinks and described with ontologies, readable as plain files and queryable with SPARQL.
- Collection synthesis
agent-rdf-memory complements AGENTS.md, SKILL.md, A2A, MCP and OpenAPI rather than replacing them: each standard does a different job, and the memory layer supplies the linked context they can point to.
- Collection synthesis
In OPAL, the OpenLink AI Layer, agents, skills and function tools are reachable through open interfaces: OpenAPI descriptions, MCP tools and an A2A endpoint with an Agent Card.
- Collection synthesis
Because the memory layer is only linked documents, the same context can be read by an agent that arrives through any of those interfaces, without the layer knowing which one.
What an ontology adds¶
Formal semantics versus implementation choice
Collection synthesis. A vocabulary says what words mean. An ontology also says what follows.
Collection synthesis. Two things are easy to confuse. What follows is an entailment: it holds in every interpretation of the declared axioms, whatever software reads them. What a system does is a choice: which axioms to declare, whether to store the entailed statements, and whether to compute them when a query arrives. The table separates the two for five capabilities. The entailments come from the OWL 2 specifications (OWL 2 Web Ontology Language Primer, OWL 2 Direct Semantics and OWL 2 RDF-Based Semantics).
Collection synthesis. In agent-rdf-memory's own practice, reasoning is applied per query, through a pragma on the query when it needs entailment or a reasoner above SPARQL, and entailed statements are not written back into the stored graphs.
| Capability | Example | Follows from the formal semantics | Implementation choice |
|---|---|---|---|
| Entity reconciliation with owl:sameAsDeclares that two IRIs denote one and the same individual. | asserted: A owl:sameAs B . A schema:jobTitle "Founder" .entailed: B schema:jobTitle "Founder" . B owl:sameAs A . | Identity is symmetric and transitive, and every statement made about one name holds for the other (OWL 2 RDF-Based Semantics). | Which links to assert and who curates them, and whether a store applies them at query time (Virtuoso offers a same-as query pragma) or materializes them. The assertion is a claim, so a wrong link merges two things for good.Rule of thumb: Use it for identity, never for similar or related. |
| Reconciliation by key: inverse-functional propertiesDeclares that a property's value identifies at most one subject. | asserted: A :agentCard C . B :agentCard C . :agentCard a owl:InverseFunctionalProperty .entailed: A owl:sameAs B . | Two subjects that share a value of an inverse-functional property are the same individual, and OWL does not assume that different names mean different things. | Which properties you dare to declare inverse-functional (a mailbox hash or an Agent Card address can be; a name cannot), and whether the inference runs in the store, in a query pragma or in a separate reasoner.Rule of thumb: Declaring a non-unique property inverse-functional merges strangers. |
| Chained relations: transitivityDeclares that a relation carries across a chain. | asserted: :documentFormat :dependsOn :dataAccess . :dataAccess :dependsOn :actionApi .entailed: :documentFormat :dependsOn :actionApi . | x related to y and y related to z entails x related to z. | Whether the store materializes the closure, applies a rule set at query time, or leaves the chain to a SPARQL 1.1 property path such as :dependsOn+, which needs no reasoner at all.Rule of thumb: Do not declare a relation transitive if a chain of it would not be true. |
| Two-way relations: symmetryDeclares that a relation holds in both directions. | asserted: :researchAgent :collaboratesWith :draftingAgent .entailed: :draftingAgent :collaboratesWith :researchAgent . | x related to y entails y related to x. | Whether to store both directions explicitly for portability or to rely on inference, which portable consumers may not perform.Rule of thumb: A relation like reports-to is not symmetric; only declare it where both directions are true. |
| Reverse relations: inverse propertiesDeclares that one property is the reverse of another. | asserted: :capability :enables :job . :enables owl:inverseOf :enabledBy .entailed: :job :enabledBy :capability . | x related to y by the first property entails y related to x by the second. | Whether to assert both directions in the data. RDF stores do not add the reverse triple on their own, so portable graphs, including this one, state both.Rule of thumb: Inverse is not the same as symmetric: the two directions use different property names. |
Specification-backed. Two cautions from the specifications. OWL does not assume that different names denote different things, which is why sharing a key can identify two records as one, and also why a wrong sameAs or a wrongly declared key merges things that should stay apart. The entailments also depend on which OWL 2 semantics a tool implements, so check the one yours uses.
Collection synthesis. Reconciliation is what lets records from different tasks meet. Written in one task under one hyperlink and in another under a different one, they can still be read together.
Evidence for this section5 specification-backed 3 synthesis
- Specification-backed
owl:sameAs states that two IRIs denote the same individual, so anything said about one holds for the other.
- Specification-backed
If a property is inverse-functional and two subjects share the same value for it, the two subjects are the same individual, because OWL does not assume that different names denote different things.
- Specification-backed
If a property is transitive, then x related to y and y related to z entails x related to z.
- Specification-backed
If a property is symmetric, then x related to y entails y related to x.
- Specification-backed
If one property is declared the inverse of another, then x related to y by the first entails y related to x by the second.
- Collection synthesis
Each ontology capability has two parts: what follows from the formal semantics, and what an implementation chooses, such as which axioms to declare, whether to materialize entailments, and whether to reason at query time.
- Collection synthesis
In agent-rdf-memory's own practice, reasoning is applied per query, through a pragma on the query when it needs entailment or a reasoner above SPARQL, and entailed statements are not written back into the stored graphs.
- Collection synthesis
When two records describe the same person, agent or document under different hyperlinks, sameAs links or an inverse-functional key let them be read as one, so context written in one task is found in another.
Coordinating agents¶
A2A for agents that divide work
Collection synthesis. When one agent is not enough, agents need a way to talk to each other that does not depend on who built them.
Specification-backed. The Agent2Agent (A2A) Protocol is an open standard for exactly that: communication and collaboration between agents built on different frameworks by different vendors. Agents can delegate sub-tasks, exchange information and coordinate actions, without exposing internal memory, tools or proprietary logic. The same documentation pairs it with MCP: MCP for tools and data, A2A for other agents.
Collection synthesis. That fits two ways of dividing work. By task: an orchestrating agent hands research, drafting and review to different agents and collects the results. By function: agents specialize, such as one that speaks to databases and another that handles documents, and any task that needs them asks. In both, the agent is a black box and the conversation is the interface.
Collection synthesis. Opaque does not have to mean context-blind. An agent can keep its internals private and still publish a linked record of what it produced, so the next agent receives a hyperlink in the message rather than a pasted copy. The repository's a2a-client skill exercises the OPAL side of that arrangement: it fetches an Agent Card from a well-known address, then sends tasks as JSON-RPC messages.
| Conversation | Open interface | What it carries | Evidence |
|---|---|---|---|
| Person and agent | Natural language | The person's intent, in ordinary words | Collection synthesis |
| Agent and tools or data | MCP or OpenAPI | Defined operations, and their results | Specification-backed |
| Agent and agent | A2A | Tasks, messages and results between agents that keep their internals private | Specification-backed |
| Agent and standing instructions | AGENTS.md and SKILL.md | Conventions to follow and procedures to run | Specification-backedCollection synthesis |
| Anyone and shared context | Linked records, such as agent-rdf-memory | Context that any of the above can point to by hyperlink | Collection synthesis |
Evidence for this section3 specification-backed 2 synthesis
- Specification-backed
The Agent2Agent (A2A) Protocol is an open standard for communication and collaboration between AI agents that are built on diverse frameworks by different vendors.
- Specification-backed
A2A lets agents delegate sub-tasks, exchange information and coordinate actions to solve problems a single agent cannot, while interacting without sharing internal memory, tools or proprietary logic.
- Specification-backed
A2A's own documentation pairs the two standards: MCP connects agents to tools and data, and A2A connects agents to other agents.
- Collection synthesis
A2A gives agents that divide work by task, or specialize by function, an open way to message each other, so an orchestrating agent can hand a sub-task to a specialist and receive the result without seeing the specialist's internals.
- Collection synthesis
A2A keeps agent internals private; explicitly published, linked records are how such agents can still share context, by passing a hyperlink in a message instead of pasting the content.
Peel back the onion¶
An intention through the layers that act on a document
Collection synthesis. An intention is stated in ordinary language, but it has to pass through six layers before a document changes. Peel them back and compare what each layer looked like historically with what it is now.
Essay-backed. The Gen AI Bridge to the Future follows the same pattern across whole paradigms: mainframes, PCs, smartphones and wearables each had an application layer that bridged to the next, and the Internet was the bridge that did not care which device reached it.
Collection synthesis. The table under the animation is the present-day basis. In its initially column every layer reads Various: many competing answers, each stack a private path. Today most layers have converged on a small set, and the document format is negotiated between the two ends rather than fixed by either. The computing device layer remains varied.
Natural language is the way in, not a layer
It changes how a person states an intent, in ordinary words and to an agent. It leaves everything beneath to open standards. Take the standards away and the intention has nowhere to go.
Your system asks for reduced motion, so the animation does not play by itself. Use Next layer or the step slider.
Then: fragmented
Today: harmonized
Dashed scatter: many paths, each stack private.Solid line: one path shared by everyone.
| Layer | Purpose | Protocols initially | Protocols today | What happens to the intention |
|---|---|---|---|---|
| 1 Computing Device | Various | Variouse.g. mainframes and terminals, then PCs, smartphones and wearables | Various | The agent needs a computer to act on: a phone, a laptop, or a virtual machine provisioned for the agent. |
| 2 Operating System | Various | Variouse.g. one proprietary system per vendor line, such as IBM's TSS/360 | macOS, Linux, Windows | The operating system schedules the agent's work and gives it files, processes and permissions on whichever host runs it. |
| 3 Network Protocol | Various | Variouse.g. vendor networking stacks such as SNA, DECnet and AppleTalk | HTTP | HTTP carries the request to the services and documents the agent needs, whoever runs them. |
| 4 Action API | Various | Variouse.g. bespoke, per-application interfaces and remote-call schemes | MCP or OpenAPI | The agent picks an action interface, an MCP tool or an OpenAPI-described API, and calls a defined operation instead of steering a screen. |
| 5 Data Access API | Various | Variouse.g. a different call interface for each database vendor | ODBC, JDBC | Where the job touches a database, ODBC or JDBC gives the action a uniform way to read and write its tables. |
| 6 Document Format | Various | Variouse.g. each application's own file format | Negotiated | The document arrives in a format negotiated between requester and server, such as PDF, HTML or RDF Turtle, chosen by content negotiation. |
Evidence for this section4 essay-backed 2 synthesis
- Essay-backed
The application layer of one computing paradigm provides the bridge to the next: applications bridged mainframes to PCs, the Internet bridged PCs to smartphones, and generative AI is the proposed bridge to wearables.
Source: The Gen AI Bridge to the Future - Essay-backed
The Internet differed from earlier applications by being available on every PC, enabling communication between PCs, and being agnostic to the device used to reach it.
Source: The Gen AI Bridge to the Future - Essay-backed
An application differs from a batch program because it can be interacted with and amended while it runs, which opened a new industry to build applications that ran across a whole family of mainframes.
Source: The Gen AI Bridge to the Future - Essay-backed
The product overhang from today's generative AI is large, and the application layer for the next paradigm has to be built first on the devices that already exist.
Source: The Gen AI Bridge to the Future - Collection synthesis
Natural language makes it easier for a person to express intent; the open standards underneath (HTTP, MCP or OpenAPI, ODBC and JDBC, negotiated document formats) still carry out the work.
- Collection synthesis
Compared with a history in which each layer offered many competing protocols, the present-day path has converged on a small set at most layers; the computing device layer remains varied.
Turn an intent into a finished job¶
A seven-step practice
Seven steps from stating a job in plain language to recording the outcome as linked records and choosing what comes next.
State the job in plain language
Say what you want done as a sentence a colleague would understand. This is the intent; it comes before any choice of app or agent, and it is the part that stays yours.
Choose an agent with the capability
Pick the agent that has, or can be given, the skills and tools the job needs. The choice matters because the agent will accumulate the context that makes it useful.
Grant only the authority the job needs
Scope access to the accounts, files and actions this job requires, and no more. Capability without authorization should stop; authorization without capability should be noticed.
Point the agent at written context
Give the agent hyperlinks to earlier records, not pasted copies, so it can follow them to related decisions, sources and definitions.
Let it act through open interfaces
The agent reaches tools and data through MCP or OpenAPI, and hands sub-tasks to specialist agents through A2A when the work divides by task or function.
Write the outcome down as linked records
Have the agent record what was done as machine-readable, hyperlinked notes with provenance, so the next task can start from them.
Review, then decide what is next
Read the result and choose the next intent. Records let an agent resume; only a person supplies the volition to pick the next job.
Frequently asked questions¶
14 questions
Glossary¶
29 terms
Intent
What a person wants to accomplish, stated in ordinary language, before any choice of app, agent or protocol.
Volition
The human capacity to decide what one wants. In Thompson's argument it becomes the scarce resource once agents make the ability to act abundant.
Inspiration
Thompson's word for the problem that replaces discovery: helping a person find something worth doing.
Aggregation Theory
Thompson's framework in which companies that solve discovery aggregate demand and gain power over suppliers.
Agent
In the essay's sense, an AI that has access to a computer and can operate it on a person's behalf.
Agent capability
The skills and tools an agent can use to do work, such as reading a document, calling an API or querying a database.
Authorization
The permission a person grants an agent for a particular job: which accounts, files and actions it may touch.
Written record
A durable note of context, decisions or results that can be read again in a later task, by the same or another agent.
Harness
The deterministic software around a model that manages its notes, tools and workflow so it can return to work later.
Bridge (between paradigms)
Thompson's term for the application-layer change that carries one computing paradigm to the next.
Natural-language interface
Speaking or typing intent in ordinary language, with open standards doing the work underneath.
agent-rdf-memory
A loosely coupled memory and context layer of Turtle documents linked by hyperlinks and described with ontologies.
OPAL (OpenLink AI Layer)
OpenLink's layer for agents, skills and function tools, reachable through OpenAPI, MCP and A2A interfaces.
Agent2Agent (A2A) Protocol
An open protocol for communication and collaboration between AI agents built on different frameworks by different vendors.
Model Context Protocol (MCP)
An open-source standard for connecting AI applications to external systems: data sources, tools and workflows.
OpenAPI Specification
A standard, language-agnostic description of an HTTP API that both people and machines can read.
AGENTS.md
A plain Markdown file giving coding agents predictable, agent-focused instructions; often also written AGENT.md.
SKILL.md skill package
A folder whose SKILL.md tells an agent how to perform a class of task; often also written SKILLS.md.
Getting Things Done
David Allen's method for clearing the mind by writing every open loop into a trusted system that is reviewed regularly; the essay builds on it.
Jobs to be done
A framing in which people use products to get a job done; Thompson uses it to argue the job, not the app, is the centre.
Linked data
Structured data published so that things are identified by hyperlinks that can be followed to more data.
Entity reconciliation
Deciding that records under different names or hyperlinks describe the same thing, and linking them.
Ontology capability
A reasoning ability that a declared ontology adds to data, such as identity, chaining, symmetry or inverses.
owl:sameAs
The OWL property that states two IRIs denote the same individual.
Inverse-functional property
An OWL property class in which each value identifies at most one subject.
Transitive property
An OWL property class in which a chain of the relation implies the relation across the whole chain.
Symmetric property
An OWL property class whose relation holds in both directions.
Inverse property
The OWL property that declares one property to be the reverse of another.
Standards stack
The ordered layers an intention passes through to act on a document, from the computing device to the document format.
Knowledge Graph Explorer¶
271 nodes and 905 links
Open the Knowledge Graph ExplorerDrag nodes, filter by class, property or predicate, and follow any node or edge to its description. Built from the companion Turtle.
From Intent to Action — graph of claims, layers and vocabulary
KG Settings
Predicate Filters
Node Types
Literal Filter
The graph library did not load. The companion Turtle file has the same data.
SPARQL Workbench¶
Test the page's claims against its own graph
Open the SPARQL WorkbenchRun recipes against the named graph on URIBurner, edit them, or copy the live link. Five ready-made queries are below.
Explore Knowledge Graph using SPARQL
Choose a recipe, edit the query if you like, then open it on URIBurner. Every SELECT returns an IRI column, so results can be followed.
SELECT uses text/x-html+tr. DESCRIBE and CONSTRUCT use text/x-html-nice-turtle. The graph is https://linkeddata.uriburner.com/DAV/demos/daas/intent-to-action-agents-web-claude_sonnet_5_5-1.ttl.
1Entity types in this graph
SELECT the entity types, one sample entity and a count for each. This is the summary the workbench opens with.
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/intent-to-action-agents-web-claude_sonnet_5_5-1.ttl> {
?s rdf:type ?type .
OPTIONAL { ?s schema:name ?label }
}
}
GROUP BY ?type
ORDER BY DESC(?entityCount)2Claims and their basis
List every claim with the label saying whether it is backed by an essay, by a specification, or is this collection's synthesis.
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/>
PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
PREFIX prov: <http://www.w3.org/ns/prov#>
PREFIX itoa: <https://linkeddata.uriburner.com/DAV/demos/daas/intent-to-action-agents-web-claude_sonnet_5_5-1.html#>
SELECT ?claimIri ?claim ?basisIri ?basis
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/intent-to-action-agents-web-claude_sonnet_5_5-1.ttl> {
?claimIri a schema:Claim ;
schema:name ?claim ;
itoa:claimBasis ?basisIri .
?basisIri skos:prefLabel ?basis .
}
}
ORDER BY ?basis ?claim3The layers, outermost first
Read the six standards layers in peel order with the protocols used today.
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/>
PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
PREFIX prov: <http://www.w3.org/ns/prov#>
PREFIX itoa: <https://linkeddata.uriburner.com/DAV/demos/daas/intent-to-action-agents-web-claude_sonnet_5_5-1.html#>
SELECT ?order ?layerIri ?layer ?today
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/intent-to-action-agents-web-claude_sonnet_5_5-1.ttl> {
?layerIri a itoa:StandardsLayer ;
schema:name ?layer ;
itoa:layerOrder ?order ;
itoa:protocolsToday ?today .
}
}
ORDER BY ?order4Ontology capabilities
Compare, for each capability, what follows from the formal semantics and what is an implementation choice.
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/>
PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
PREFIX prov: <http://www.w3.org/ns/prov#>
PREFIX itoa: <https://linkeddata.uriburner.com/DAV/demos/daas/intent-to-action-agents-web-claude_sonnet_5_5-1.html#>
SELECT ?capIri ?capability ?formal ?choice
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/intent-to-action-agents-web-claude_sonnet_5_5-1.ttl> {
?capIri a itoa:OntologyCapability ;
schema:name ?capability ;
itoa:formalPart ?formal ;
itoa:choicePart ?choice .
}
}
ORDER BY ?capability5What backs the volition thesis
Follow the synthesis claim about power shifting to intent and choice of agent back to the claims and essays it is built on.
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/>
PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
PREFIX prov: <http://www.w3.org/ns/prov#>
PREFIX itoa: <https://linkeddata.uriburner.com/DAV/demos/daas/intent-to-action-agents-web-claude_sonnet_5_5-1.html#>
SELECT ?synthesisIri ?synthesis ?builtOnIri ?builtOn ?sourceIri ?source
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/intent-to-action-agents-web-claude_sonnet_5_5-1.ttl> {
?synthesisIri itoa:basedOnClaim ?builtOnIri ;
schema:name ?synthesis .
FILTER(?synthesisIri = <https://linkeddata.uriburner.com/DAV/demos/daas/intent-to-action-agents-web-claude_sonnet_5_5-1.html#claim-agentChoice>)
?builtOnIri schema:name ?builtOn ;
prov:wasDerivedFrom ?sourceIri .
?sourceIri schema:name ?source .
}
}
ORDER BY ?builtOn