Interactive essay · Linked Data meshup · This is what comes next

The new knowledge artifacts of the AI economy — and the commerce that comes next

KG curated by kg-generator, rdf-infographic-skill and DeepSeek V4 Pro on behalf of Kingsley Uyi Idehen
Sources: O'Reilly Radar · The New Knowledge Artifacts of the AI Economy · New Units of Knowledge · The Future of Books in the Age of AI · four Linked Open Agentic Commerce posts on the URIBurner weblog

Every technology revolution creates a new shareable artifact — and the artifact always appears before the institution that organizes it. Trace the line from the binary to the context bundle, then watch where it points next.

  1. 01BinaryMicrosoft
  2. 02Source codeGitHub
  3. 03Web pageGoogle
  4. 04The clickAd exchanges
  5. 05Context bundleUnbuilt → LOAC
Thesis at a Glance

Tim O'Reilly's essay is a history lesson aimed at the future: every technology revolution creates new knowledge artifacts — binaries, source repos, web pages, clicks — and the artifact precedes the institutions that organize it. His bet is that the AI economy's artifact is the context bundle, and that the mechanisms for sharing, trusting and paying for it are still unbuilt.

This essay reads that bet forward. Linked Open Agentic Commerce (LOAC) — demonstrated live on the URIBurner weblog — is exactly the missing mechanism: hyperlinks as identifiers, WebID identity with on-behalf-of delegation, RDF-ABAC enforcement, and decoupled orchestration vs settlement. Where O'Reilly asks “what comes next?”, LOAC is the answer being built.

Convergence Thesis

Both see the same future from opposite ends. O'Reilly names the artifact and asks for its institutions; LOAC supplies the institution — the hyperlink — and turns the artifact into a governed, payable resource. The agent trace becomes the new click, and the grade receipt becomes the license.

01 · The unbundling

#When code is cheap, what becomes valuable?

O'Reilly's answer: the context bundle — the artifact you hand the model to do its work. It is not one thing but several, and each one is already becoming a shareable, tradeable unit. Hover any species to see how LOAC packages it.

Context
bundle

Hover or tap a species to see what it is — and how LOAC makes it tradeable.

The question, stated once

O'Reilly: “The challenge for the software development community is to identify the new knowledge artifacts of the AI economy, and to build new mechanisms and incentives for sharing them.” What will be the derivatives of the AI era? This essay answers: the artifact is the context bundle, the institution is the hyperlink, and the derivative is the license.

02 · The unit of difference

#The spec is the new unit — eValuable" target="_blank" rel="noopener noreferrer">standardization makes difference valuable

Kevin Kelly, answering O'Reilly's Foo Camp question, observes that the magic genie makes creation abundant — so difference becomes the scarce, valuable thing. What gets shared is the specification, the goal: like a seed, it grows differently in different soil.

🎯
The spec

Getting the question right

The value is in the goal, not the prompts — a consultation that each genie grows into its own prompts and actions.

🔤
26 letters

Standardization makes difference valuable

The new artifacts succeed only if they carry distinctions in a standardized way — the way 26 identical letters carry every distinct thing ever written.

🤝
Agent to agent

Packaged with provenance

A prompt, a bundle, a spec, weights, or an action — standardized, and carrying provenance so a genie can tell if it is good, safe, and from whom it claims.

LOAC is that standardization

Kelly says the artifact must be standardized to carry difference; LOAC supplies the alphabet — the dereferenceable offer, the hyperlink identifier, the RDF-ABAC license. That standardization is what makes difference valuable, and it is what the next unit of knowledge is built on.

03 · The bridges

#Twelve “what comes next” bridges

Each bridge maps an observation or open question in O'Reilly's and Kelly's essays onto the LOAC mechanism that fulfills it — the question on the left, the answer on the right. Table on wide screens; entity cards on narrow screens.

Table view on wide screens; entity cards on narrow screens.
BridgeTim O'Reilly & Kevin Kelly frame the questionLOAC — what comes next
Code is displaced; the context bundle becomes the tradeable artifactFor a growing number of use cases source code is no longer the most important shareable artifact.The context bundle — a skill, spec, prompt library, dataset, or knowledge graph — is packaged as a dereferenceable offer an agent can acquire.
"We haven't figured out what needs to be shared""Part of the problem is that we haven't yet figured out what needs to be shared."The offer is the unit of sharing — a machine-readable offer with price, license and access rules.
Artifacts precede institutionsNew artifacts appear before the institutions that organize them (GitHub a decade after open source; Google a decade after websites).The hyperlink is the coordinating institution: discovery starts at a well-known endpoint, and the graph is its own directory.
Trust mechanismsCronon's grain trade needed grading standards and grade receipts to let strangers trust one another.WebID delegated identity + RDF-ABAC is that trust mechanism; access resolves 401→402→200. The license is the grade receipt.
"What will be the derivatives of the AI era?"Grade receipts begat grain futures; O'Reilly asks what the AI era's derivatives will be.The license separates the right to access from the artifact, settled one-time or by subscription, scoped by a Shared Payment Token.
The agent trace as raw materialThe agent trace could be "the raw material for attribution and payment, much as the click was for advertising."Because identity is explicit (principal → agent), who did what under whose authority is auditable end-to-end.
"Pheromone trails" and the agentic PageRankWill agents leave "pheromone trails" that strengthen or fade, like links?The LOAC substrate is that graph — hyperlinks are identifiers and traversal, leaving exactly the weighted trail a ranker reads.
"Anchor on Canonical Names"A canonical name references a whole methodology more reliably than a paraphrase.A canonical name is a dereferenceable IRI resolving to the entity's machine-readable description.
Protecting the eval holdout setNick Vincent warns evals only work if the model hasn't seen the answers.An eval is an ABAC-gated resource — licensed and gated rather than leaked into training data.
A "home for personal context"O'Reilly follows Duncan Davidson's home for personal context.The LOAC posts run on exactly such a store — an RDF agent memory whose entities are hyperlink-identified, queryable, licensable.
The book is the ultimate knowledge artifact — it becomes a living knowledge graphO'Reilly's law says every artifact unbundles — binary, source repo, page, click, context bundle. The book is the longest-lived artifact of all, so it is next.Kingsley's 'Future of Books' article: the book becomes a living, queryable knowledge graph — sold chapter, section, or paragraph at a time as addressable, verifiable units; pay per query or extracted claim.
The spec is the new unit — standardization makes difference valuableKevin Kelly answers O'Reilly's Foo Camp question: the magic genie makes creation abundant, so difference becomes the scarcity. What gets shared is the specification — the goal, like a seed that grows differently in different soil.LOAC is that standardization: the dereferenceable offer, the hyperlink identifier, the RDF-ABAC license — the 26 letters that let every distinct, valuable artifact be captured and traded.
O'Reilly · Kelly

Tim O'Reilly & Kevin Kelly frame the question

For a growing number of use cases source code is no longer the most important shareable artifact.
"Part of the problem is that we haven't yet figured out what needs to be shared."
New artifacts appear before the institutions that organize them (GitHub a decade after open source; Google a decade after websites).
Cronon's grain trade needed grading standards and grade receipts to let strangers trust one another.
Grade receipts begat grain futures; O'Reilly asks what the AI era's derivatives will be.
The agent trace could be "the raw material for attribution and payment, much as the click was for advertising."
Will agents leave "pheromone trails" that strengthen or fade, like links?
A canonical name references a whole methodology more reliably than a paraphrase.
Nick Vincent warns evals only work if the model hasn't seen the answers.
O'Reilly follows Duncan Davidson's home for personal context.
O'Reilly's law says every artifact unbundles — binary, source repo, page, click, context bundle. The book is the longest-lived artifact of all, so it is next.
Kevin Kelly answers O'Reilly's Foo Camp question: the magic genie makes creation abundant, so difference becomes the scarcity. What gets shared is the specification — the goal, like a seed that grows differently in different soil.
LOAC

Linked Open Agentic Commerce — what comes next

The context bundle — a skill, spec, prompt library, dataset, or knowledge graph — is packaged as a dereferenceable offer an agent can acquire.
The offer is the unit of sharing — a machine-readable offer with price, license and access rules.
The hyperlink is the coordinating institution: discovery starts at a well-known endpoint, and the graph is its own directory.
WebID delegated identity + RDF-ABAC is that trust mechanism; access resolves 401→402→200. The license is the grade receipt.
The license separates the right to access from the artifact, settled one-time or by subscription, scoped by a Shared Payment Token.
Because identity is explicit (principal → agent), who did what under whose authority is auditable end-to-end.
The LOAC substrate is that graph — hyperlinks are identifiers and traversal, leaving exactly the weighted trail a ranker reads.
A canonical name is a dereferenceable IRI resolving to the entity's machine-readable description.
An eval is an ABAC-gated resource — licensed and gated rather than leaked into training data.
The LOAC posts run on exactly such a store — an RDF agent memory whose entities are hyperlink-identified, queryable, licensable.
Kingsley's 'Future of Books' article: the book becomes a living, queryable knowledge graph — sold chapter, section, or paragraph at a time as addressable, verifiable units; pay per query or extracted claim.
LOAC is that standardization: the dereferenceable offer, the hyperlink identifier, the RDF-ABAC license — the 26 letters that let every distinct, valuable artifact be captured and traded.
04 · The mechanism

#LOAC: commerce as a hyperlink-based entity-relationship graph

The flywheel is the loop that makes a knowledge artifact discoverable, payable, and reusable — hover a stage to see what happens there. The four URIBurner weblog posts below it demonstrate the loop running live.

LOAC the flywheel 1Curate 2Package 3Discover 4Purchase 5Settle 6Enforce

1 · Discovery via linked endpoints

An agent dereferences a well-known entry point (.well-known/acp.json) to learn capabilities, entry points and workflows — nothing hard-coded, everything discoverable.

2 · Commerce as an entity-relationship graph

Nodes are entities (principal, agent, offer, license, resource); edges are typed relationships. The agent walks Principal → Agent → Offer → License → Resource.

3 · Enforcement via RDF-ABAC

A purchase generates an RDF policy binding identity, license terms and constraints — access resolves 401 → 402 → 200.

4 · Orchestration vs settlement

ACP/UCP handle ordering; MPP and HTTP 402 (x402) handle payment — so providers change independently of product structure.

The point of the URIBurner posts

O'Reilly says the new artifacts are “only half-formed” and the institutions “unbuilt.” The URIBurner posts show the mechanism working today — one URI with four outcomes, delegated on-behalf-of commerce, and x402-settled machine payments.

05 · The evidence

#Four LOAC posts on the URIBurner weblog

Live demonstrations, not speculation — each a protected, hyperlink-identified resource published on the URIBurner weblog.

06 · The landing

#The book is the next artifact to unbundle

O'Reilly's law ends at the context bundle; Kingsley's The Future of Books in the Age of AI names the longest-lived artifact of all as next. The book won't become a PDF, an ePub, or a hyperlinked page — it becomes a living knowledge graph.

📖
Granular units

Chapters, sections, paragraphs

Sell a chapter, a section, even a single paragraph — as an addressable, verifiable unit of knowledge, not a 300-page monolith.

🔍
Query, remix, link

The book as an API

Readers don't read start-to-finish; they query it, remix it, and link it to other graphs — and pay only for what they use.

🔗
Forkable & provable

Versioned graph branches

Long-form writing becomes curated, versioned, forkable graph branches — with cryptographically provable attribution and mathematically detectable plagiarism.

The landing: LOAC applied to the book

Each paragraph is an offer; each claim is a license; each read is a micro-transaction. That is granular monetization of personal knowledge — the book surviving as a live service on the Agentic Web, exactly where O'Reilly's context bundles and LOAC's offers converge.

07 · The playbook

#Publish a knowledge artifact as a LOAC offer

Six steps turn O'Reilly's context bundles into governed, payable linked-open artifacts.

# Curate the artifact

Curate data, information, or knowledge — a spec, a skill, a prompt library, a dataset, or a knowledge graph — into a well-formed context bundle worth sharing.

# Package it as a machine-readable offer

Describe the artifact as an offer entity with a dereferenceable IRI, a price, and license terms.

# Expose discovery via a well-known endpoint

Advertise capabilities at a well-known URI (e.g. .well-known/acp.json) so agents can discover the offer without prior API knowledge.

# Delegate identity explicitly

Represent the principal-agent relationship on-behalf-of, using a WebID-identified principal.

# Orchestrate and settle

Let ACP/UCP handle discovery, negotiation, and ordering, and MPP/x402 (e.g. Stripe) handle payment and settlement.

# Enforce access via RDF-ABAC and reuse

Materialize an RDF-ABAC policy from the license so access resolves 401 → 402 → 200; rinse and repeat per curated artifact.

08 · Questions & answers

#Frequently asked questions

What is a knowledge artifact, and why does its form change?▼
A unit of value that can be shared, traded, and built upon. Tim O'Reilly shows that every technology revolution creates a new one — the binary, the source-code repo, the web page, the click, and now the context bundle — and that the new artifact appears well before the institutions that organize and measure it.
Why does O'Reilly say code is being displaced as the primary shareable artifact?▼
Because LLMs make generating code cheap. When code is cheap, the valuable, tradeable thing shifts to what tells the model what to generate and how to do it well — the prompts, specs, skills, traces and evals he groups under "context bundles."
What is a context bundle?▼
O'Reilly's generic term for the artifacts you hand a model to do its work: a spec, an Agent Skill, an MCP server, an agent trace, an eval, or even a well-formed conjecture — the emerging unit of sharing in the AI economy.
What does "the agent trace is the new click" mean?▼
The stream of what people ask their agents to do — and the log of which context bundles were invoked — may become the signal of intent around which the AI economy's coordinating institutions get built, just as the click was the raw material for advertising.
How does LOAC answer O'Reilly's open questions?▼
Linked Open Agentic Commerce (LOAC) is the "this is what comes next" mechanism: every knowledge artifact becomes a granular, linked-open offer with a dereferenceable IRI, delegated WebID identity, RDF-ABAC enforcement, and decoupled ACP/UCP orchestration vs MPP/x402 settlement.
Why is delegated identity the missing layer?▼
Commerce is becoming agent-mediated, but systems still bury the principal-agent relationship in sessions, cookies and API keys. LOAC makes it explicit, so a transaction reads "the agent, on behalf of the principal, purchased a license" — which determines ownership, liability and revocation.
How does ABAC turn a knowledge artifact into a protected, tradeable resource?▼
A LOAC purchase generates an Attribute-Based Access Control policy expressed as RDF, binding identity, license terms and resource constraints. Before purchase a resource returns 401 then 402; after purchase and provisioning it returns 200.
What is the "derivative of the AI era" that LOAC provides?▼
O'Reilly asks what the AI era's derivatives will be, mirroring how grade receipts begat grain futures. LOAC's answer is the license: the right to access an artifact, separated from the artifact itself, settled one-time or by subscription and scoped by a Shared Payment Token.
What does "the hyperlink is the API" mean?▼
An agent needs no proprietary integrations — only HTTP, RDF, and a shared model of an entity-relationship graph built from hyperlinks. The catalog, the license and the identity are all graphs.
How do the URIBurner weblog LOAC posts demonstrate "what comes next"?▼
They are live demonstrations, not speculation: "One URI. Four outcomes" shows one protected resource resolving differently per caller identity; the "On-Behalf-Of" storyboard shows delegated commerce over ACP & UCP; the OpenRouter & Stripe meshup shows x402 settlement.
09 · The vocabulary

#Core terms

Knowledge artifact

A unit of value that can be shared, traded, and built upon; each technology revolution creates new ones.

Context bundle

The artifacts handed to a model to do its work — prompts, specs, agent skills, MCP servers, traces, evals, and conjectures.

Agent Skill

A folder of instructions, scripts, and reference material an agent loads only when a task calls for it.

MCP server

A Model Context Protocol server — a mechanism for presenting context that shapes an LLM's work.

Agent trace

The record of what an agent tried and which context it drew on — commit history for unformalized work.

Eval

A set of test cases encoding what good work looks like for a task — valuable to create, withhold, or share.

Grade receipt

The Chicago grain trade's artifact that certified quality and separated ownership of grain from the grain itself.

Hyperlink as identifier

Dereferenceable hyperlinks as stable identifiers — "the hyperlink is the API."

Platinum Layer

Kingsley Idehen's extension of the medallion architecture: hyperlinks as standardized identifiers.

Linked Open Agentic Commerce (LOAC)

Commerce as a linked-data entity-relationship graph; pronounced "lock."

Delegated identity (On-Behalf-Of)

The explicit principal-agent relationship and the scope of delegated authority.

Attribute-Based Access Control (ABAC)

Access control expressed as RDF policy; access derives from the graph.

Orchestration vs settlement

LOAC's separation of ACP/UCP (ordering) from MPP/x402 (payment).

Shared Payment Token (SPT)

A scoped, time-bounded, cryptographically bound payment authorization.

Offer (schema:Offer)

The machine-readable unit of sharing in LOAC — price, license, and access terms.

License

A policy entity governing access — the ABAC-enforced grade receipt.

Living knowledge graph

A queryable, versioned, forkable graph that replaces the static document — the format the book becomes.

Granular monetization of personal knowledge

Selling chapters, sections, or paragraphs as addressable, verifiable units — pay per query or extracted claim.

Book as API

The book as a queryable service — readers query, remix, and link it to other graphs rather than reading start-to-finish.

Spec as the unit of knowledge

The specification — the goal — is the shareable unit; the value is in getting the question right, and like a seed the spec grows differently in different soil.

Standardization makes difference valuable

Standardized units — like 26 letters and a shared dictionary — let distinct, valuable differences be captured and traded.

Agent-to-agent artifact

The standardized package passed between agents — a prompt, a bundle, a spec, weights, or an action — carrying provenance so a genie can tell whether it is good, safe, and from whom it claims.

Knowledge Graph ExplorerDrag, filter, and resolve the graph▼
Knowledge Graph

#Interactive Knowledge Graph Explorer

Drag to pin nodes, double-click to unpin, click a node or edge to open its RDF description via URIBurner. Click the graph surface to arm zoom; click outside to release.

0 nodes / 0 links

KG Settings

Physics

Charge-350
Link distance110
Collision16

Node filters

Resolver

Arrow style

Predicates

Articles Bridges Concepts Organizations People Software
SPARQL WorkbenchRun and edit live queries against the uploaded graph▼
Workbench

#SPARQL Workbench

Query the companion knowledge graph live on URIBurner. Select a recipe, edit, and run.

Open in SPARQL workbench
Entity-type summary of the knowledge graph▼
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/oreilly-new-knowledge-artifacts-loac-meshup-deepseek_v4pro-1.ttl> {
    ?s rdf:type ?type .
    OPTIONAL { ?s rdfs:label ?label }
  }
}
GROUP BY ?type
ORDER BY DESC(?entityCount)
Run live
The sources: O'Reilly essay and the LOAC posts▼
PREFIX schema: <http://schema.org/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

SELECT ?sourceIri ?title ?date ?author
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/oreilly-new-knowledge-artifacts-loac-meshup-deepseek_v4pro-1.ttl> {
    ?sourceIri a ?type .
    VALUES ?type { schema:NewsArticle schema:BlogPosting }
    ?sourceIri schema:name ?title .
    OPTIONAL { ?sourceIri schema:datePublished ?date }
    OPTIONAL { ?sourceIri schema:author ?author }
  }
}
ORDER BY ?date
Run live
The 'what comes next' mesh bridges▼
PREFIX : <https://oreillyradar.substack.com/p/the-new-knowledge-artifacts-of-the#>
PREFIX schema: <http://schema.org/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

SELECT ?bridgeIri ?name ?about
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/oreilly-new-knowledge-artifacts-loac-meshup-deepseek_v4pro-1.ttl> {
    ?bridgeIri a :MeshBridge ;
               schema:name ?name .
    OPTIONAL { ?bridgeIri schema:about ?about }
  }
}
ORDER BY ?bridgeIri
Run live
People and their roles▼
PREFIX schema: <http://schema.org/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

SELECT ?personIri ?name ?jobTitle
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/oreilly-new-knowledge-artifacts-loac-meshup-deepseek_v4pro-1.ttl> {
    ?personIri a schema:Person ;
               schema:name ?name .
    OPTIONAL { ?personIri schema:jobTitle ?jobTitle }
  }
}
ORDER BY ?name
Run live
Glossary terms▼
PREFIX schema: <http://schema.org/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

SELECT ?termIri ?term
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/oreilly-new-knowledge-artifacts-loac-meshup-deepseek_v4pro-1.ttl> {
    ?termIri a schema:DefinedTerm ;
             schema:name ?term .
  }
}
ORDER BY ?term
Run live
HowTo steps▼
PREFIX schema: <http://schema.org/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

SELECT ?stepIri ?position ?stepName
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/oreilly-new-knowledge-artifacts-loac-meshup-deepseek_v4pro-1.ttl> {
    ?stepIri a schema:HowToStep ;
             schema:position ?position ;
             schema:name ?stepName .
  }
}
ORDER BY ?position
Run live
Link copied