This week YAML-LD advanced down the W3C standards track - a fresh working draft, published on Wednesday.
YAML-LD turns plain YAML into Linked Data. Useful, technical, invisible. Plumbing. But plumbing decides what you can build on top.
Take agent memory - the problem we open-sourced Vault-LD for last week.
The pattern Andrej Karpathy called the LLM wiki is simple: give an agent a folder of markdown files it reads and writes. The objection is instant: "Cute. But it doesn't scale."
In one sense, fair. Plain markdown is local - readable and human, but not part of any shared semantic fabric.
But those notes are rarely just markdown. At the top sits YAML frontmatter: status, tags, dates, links, types. The wiki is already half-structured. The semantic island is already there. It just isn't semantic yet.
Turn that YAML into YAML-LD and the block does what JSON-LD already does across the web: point to a shared context, identify things, say what they mean, connect local notes to other documents, agents and systems - with no central platform holding them all.
Look at JSON-LD. W3Techs puts it on 54% of websites. More than half the web.
JSON-LD is not an app, database or platform. It is a little island of structured data inside ordinary HTML. Nobody mandated it. No database contains it. No vendor owns it. Millions of sites adopted the same move: one page, two readers. Humans read the prose; machines read the island. And because the islands share a context, they don't just coexist - they connect.
That is not a theory of distributed meaning. It is the actual current state of the web.
Vault-LD is the same move, aimed at agent memory. Not "swap your wiki for a database". Not "move your memory into our platform". Keep the notes, keep the files - just make the frontmatter linked data.
JSON-LD put linked data inside HTML. VAULT-LD puts Linked Data inside markdown.
Same @context. Same Open Standards. Same scalability!
So when someone says the LLM wiki cannot scale, the answer isn't to turn it into someone else's platform. It is to give it the pattern the web already used.
The web did not scale through one giant database. It scaled through independent documents carrying shared meaning at the edges. That is what web-scale means: no centre, no bottleneck, no single place all meaning must pass through.
Scaleless.
Human meaning went web-scale as islands of JSON-LD scattered across pages. Agent meaning can go the same way - islands of Vault-LD scattered across notes, memories and workflows.
The Agentic Web will be part of the human web not separate from it.
⚡ JSON-LD made the web a knowledge graph. Vault-LD is how agents can join it ⚡
JSON-LD put Linked Data inside HTML — an island of structured data on 54% of websites, with no central platform, database, or vendor owning it.
YAML-LD (now a fresh W3C working draft) does the same thing for YAML: it turns the frontmatter block already sitting atop most markdown notes into Linked Data.
Vault-LD applies that move to agent memory: keep the notes, keep the files, keep the "LLM wiki" pattern Andrej Karpathy popularized — just make the frontmatter linked data. Same @context, same open standards, same scalability the web already proved.
Reproduced from the W3C YAML-LD 1.0 Working Draft — Example 1 and Example 2, the spec's own introductory example — not an invented illustration. Every identifier resolves to a real, dereferenceable HTTP IRI on DBpedia or Schema.org via the compact-IRI prefixes in @context.
"@context":
- https://json-ld.org/contexts/dollar-convenience.jsonld
- schema: https://schema.org/
dbo: http://dbpedia.org/ontology/
dbp: http://dbpedia.org/property/
dbr: http://dbpedia.org/resource/
xsd: http://www.w3.org/2001/XMLSchema#
dbp:discovered:
"@type": xsd:date
dbp:star:
"@type": "@id"
$id: dbr:Proxima_Centauri_b
$type: dbo:Planet
schema:description: >-
The closest known exoplanet to Earth,
orbiting in Proxima Centauri's habitable zone.
dbp:discovered: 2016-08-24
dbp:star: dbr:Proxima_Centauri
{
"@context": [
"https://json-ld.org/contexts/dollar-convenience.jsonld",
{
"schema": "https://schema.org/",
"dbo": "http://dbpedia.org/ontology/",
"dbp": "http://dbpedia.org/property/",
"dbr": "http://dbpedia.org/resource/",
"xsd": "http://www.w3.org/2001/XMLSchema#",
"dbp:discovered": {
"@type": "xsd:date"
},
"dbp:star": {
"@type": "@id"
}
}
],
"$id": "dbr:Proxima_Centauri_b",
"$type": "dbo:Planet",
"schema:description": "The closest known exoplanet to Earth, orbiting in Proxima Centauri's habitable zone.",
"dbp:discovered": "2016-08-24",
"dbp:star": "dbr:Proxima_Centauri"
}
The entity (dbr:Proxima_Centauri_b), its type (dbo:Planet), and its properties (dbp:discovered, dbp:star) all expand — via the @context prefix map — to real, resolvable DBpedia HTTP IRIs, not placeholder identifiers. This is the exact JSON-LD-proven mechanism the post argues Vault-LD should apply to agent-memory frontmatter.
Frequently asked questions, glossary terms, the HowTo walkthrough, and live SPARQL queries against the companion knowledge graph — grouped here for quick browsing.
A W3C working-draft specification (advanced this week per Tony Seale's post) that turns plain YAML into Linked Data by adding an @context block, letting YAML frontmatter identify entities, express meaning, and connect to other documents, agents, and systems.
A W3C Linked Data serialization embedded inside ordinary HTML pages — present on 54% of websites per W3Techs. An "island" of structured data that machines read while humans read the surrounding prose.
An open-sourced pattern (referenced in the post as launched "last week") that applies the YAML-LD move to agent memory: keep the markdown notes and files, but make the YAML frontmatter Linked Data — so agent memory scales the way the web scaled, without a central platform.
The agent-memory pattern popularized by Andrej Karpathy: give an agent a folder of markdown files it reads and writes. Criticized as not scaling — a critique the post's author addresses via Vault-LD.
The structured block (status, tags, dates, links, types) at the top of a markdown file. Already half-structured; YAML-LD is what makes it semantic by anchoring it to a shared @context.
The W3C architectural principles underlying the Web — distinct from "the Web" itself as a public, Internet-scale network. Kingsley Uyi Idehen's comment stresses that AWWW and the Web are often conflated: using hyperlinks to break down silo technical debt does not require public Internet-scale access.
A method of publishing structured data using dereferenceable URIs and shared vocabularies (@context) so that data items can be interlinked and become more useful through association with related data — the underlying pattern of both JSON-LD and YAML-LD/Vault-LD.
The JSON-LD / YAML-LD keyword that maps local terms to shared, dereferenceable vocabulary IRIs, letting independent documents carry compatible meaning without a central schema authority.
The post's closing claim: the Agentic Web will be part of the human web, not separate from it — agent memory scaling via islands of Vault-LD the same way human meaning scaled via islands of JSON-LD.
A publication stage on the W3C standards track for a technical specification, indicating community review is underway but the spec is not yet finalized. YAML-LD advanced to a fresh working draft, published the Wednesday before this post.
A practical path from a plain markdown LLM wiki to a scalable, standards-based agent memory layer — following the YAML-LD / Vault-LD pattern set out by Tony Seale and the hyperlink-first principles reinforced by Kingsley Uyi Idehen's comment.
Queries target the companion knowledge graph. Load the companion TTL file into a SPARQL endpoint (e.g. URIBurner) then click ▶ Run to execute. SELECT queries render as text/x-html+tr; DESCRIBE/CONSTRUCT queries render as text/x-html-nice-turtle.
PREFIX schema: <http://schema.org/>
SELECT ?position ?author ?text
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/tony-seale-yaml-ld-vault-ld-claude_sonnet_5-1.ttl>
WHERE {
?comment a schema:Comment ;
schema:position ?position ;
schema:author ?person ;
schema:text ?text .
?person schema:name ?author .
}
ORDER BY ASC(?position)
▶ Run
Returns all 17 captured comments in sequence with author name and text.
PREFIX schema: <http://schema.org/>
SELECT ?position ?name ?url ?description
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/tony-seale-yaml-ld-vault-ld-claude_sonnet_5-1.ttl>
WHERE {
?ref schema:position ?position ;
schema:name ?name ;
schema:url ?url ;
schema:description ?description .
?list schema:itemListElement ?ref .
}
ORDER BY ASC(?position)
▶ Run
Lists the 5 reference links Kingsley Uyi Idehen posted in-thread, in order.
PREFIX schema: <http://schema.org/>
SELECT ?name ?profileIRI
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/tony-seale-yaml-ld-vault-ld-claude_sonnet_5-1.ttl>
WHERE {
?person a schema:Person ;
schema:name ?name ;
schema:url ?profileIRI .
}
ORDER BY ASC(?name)
▶ Run
Lists every contributor (author + all commenters + mentioned people) with their LinkedIn profile URL.
PREFIX schema: <http://schema.org/>
SELECT ?title ?author ?url ?interactionType ?count
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/tony-seale-yaml-ld-vault-ld-claude_sonnet_5-1.ttl>
WHERE {
?post a schema:SocialMediaPosting ;
schema:name ?title ;
schema:author ?p ;
schema:url ?url ;
schema:interactionStatistic ?ctr .
?p schema:name ?author .
?ctr schema:interactionType ?interactionType ;
schema:userInteractionCount ?count .
}
▶ Run
Returns post title, author, URL, and all interaction counts (reactions, comments).
PREFIX schema: <http://schema.org/>
SELECT ?position ?author ?excerpt
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/tony-seale-yaml-ld-vault-ld-claude_sonnet_5-1.ttl>
WHERE {
?comment a schema:Comment ;
schema:position ?position ;
schema:text ?excerpt ;
schema:author ?p .
?p schema:name ?author .
FILTER (CONTAINS(LCASE(STR(?excerpt)), "scal"))
}
ORDER BY ASC(?position)
▶ Run
Filters to comments that explicitly discuss scaling — the post's central objection and rebuttal.
PREFIX schema: <http://schema.org/>
DESCRIBE ?post
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/tony-seale-yaml-ld-vault-ld-claude_sonnet_5-1.ttl>
WHERE {
?post a schema:SocialMediaPosting .
}
▶ Run (Turtle)
Returns a full DESCRIBE of the post node in nice Turtle format — useful for verifying the KG structure.
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/tony-seale-yaml-ld-vault-ld-claude_sonnet_5-1.ttl> {
?s rdf:type ?type .
OPTIONAL {
?s rdfs:label ?label
}
}
}
GROUP BY ?type
ORDER BY DESC(?entityCount)
Entity-type summary across all nodes — grouped by RDF type, with sample IRI and label, ordered by count.
Comments (24 of 30 captured)
Yep!
What's sometimes lost is the fact that the Architecture of the World Wide Web (AWWW) and the World Wide Web (the Web) are easily conflated, whether inadvertently or cynically. The net effect is that mentioning the "Web" automatically leads many to presume public access at Internet scale. In reality, this is simply about using the magic of hyperlinks (pointers surfaced in user, not just developer, space) to break down the compounding technical debt native to silos.
The perennial battle remains platform silos versus standards-based interoperability. In the past, proprietary platforms exploited the GUI-driven complexities of software design, development, use, and support. The arrival of LLMs has largely removed that friction by adding multimodal and multilingual natural language processing to computing's UI/UX stack. This is driving a long-overdue reconstruction of the software industry at every level.
2 replies — continued by Kingsley Uyi Idehen
The new workflow is both simple and profound i.e., deceptively simple:
Step 3 used to be esoteric. Today, it's as simple as calling an AI agent skill (tacitly or explicitly) to generate the information representation in whatever notation is appropriate, whether YAML-LD, JSON-LD, RDF-Turtle, or another notation. The beauty of LLMs is that they've been trained on the publicly available specifications for virtually every open standard published on the Web.
Ultimately, this is about communication, IMHO. Our ability to communicate has taken a covert quantum leap. It will simply take a little time for the world to appreciate just how profound this change really is.
SeeAlso:
My LLM Knowledge Base example, based on this post.
The workflow is as follows:
SKILL.mdbundles—as follows: "Generate an RDF and HTML bundle for {post-url}."Link: this document, published on URIBurner
As usual, just click and follow your nose to explore.
1 reply — continued by Kingsley Uyi Idehen
I created the skills that produce this document as a fundamental showcase of what the Semantic Web Project has always been about. Until now, it simply wasn't feasible to deliver this kind of experience cost-effectively because of the associated UI/UX challenges.
As I've stated repeatedly, eliminating the distracting esoterica associated with properly harnessing RDF through Linked Data principles is one of the most profound benefits of LLMs. By abstracting away that complexity, LLMs unleash a massively productive symbiosis that will fundamentally transform how software is designed, developed, and used.
Links that didn't fit in the post - for anyone who wants to go deeper:
⭕ Islands of JSON-LD - anchor GPT to your own data (2023)
⭕ Building a Semantic Layer (another 2023 one)
⭕ Building Your Own Schema.org - own your JSON-LD vocabulary (2023)
⭕ Networks Structure - an early take on JSON-LD as the web's data layer
⭕ Plain Text - The Timeless Foundation of AI and the Semantic Web
⭕ Knowledge Graphs Are Going Mainstream
⭕ Memory Tool - structured memory for agents
⭕ The Simplest Thing That Could Possibly Work
⭕ The Agentic Web Will Be Open
1 reply from George Burch
Tony Seale Linkapedia.net has semantically indexed billions of URL at sentence level (UID W3C RDF triple). 10m KG nodes. How does that database fit into this schema.
100%! YAML-LD seems like a tailored fit for Open Knowledge Format and similar markdown-based llm-wiki proposals. I wonder if we shouldn't define also a dedicated schema.org property to map the remaining body of the markdown to, so that we can just consume all such content as RDF and get over the whole markdown intermediate representation altogether ;)
3 replies — from Tony Seale and Kingsley Uyi Idehen
Szymon Klarman, Yeah I think that makes really good sense. Dan Brickley - what do you think about that?
Szymon, Remember, LLMs can handle all of this. Syntaxes and notations are just inputs, what you seek is already a native LLM capability 😀
Szymon, Yes, and LLMs handle all of that. In fact, that exactly how I work 😀
Tony Seale I haven't quite figured out yet why Vault-LD scales better than LLMWiki. After all, semantic isn't the factor that limits scaling on LLMWiki.
1 reply from Tony Seale
Dr. Florian Patzer, great question - it's the crux, so thanks for pushing on it.
You're right: semantics doesn't limit a single markdown wiki. On one machine, for one agent, a folder of markdown scales fine.
But there are two kinds of scale. Scaling up is a bigger pile in one place - markdown handles that. Scaling out is many independent wikis, across many machines and agents, becoming one queryable whole. That's what the Agentic Web runs on, and where a plain wiki hits the wall.
The reason is locality. A markdown link is a private string - it means something to you, nothing to another wiki. Two can't merge without a human deciding "does your customer mean mine?" The wiki works locally because its meaning is implicit - and that's exactly what blocks integration.
That's what semantics fixes: a shared @context gives fields common meaning, URIs give entities global identity (your decentralised identifiers), and RDF merges any two graphs by default - same URI, same node, no central database.
Same JSON-LD move: the web scaled not through bigger pages, but through pages sharing enough meaning to federate. Scaleless = no ceiling, because no centre. Semantics doesn't make one wiki bigger - it lets a billion behave as one.
Just waiting for the Obsidian integration.
1 reply from Tony Seale
watch this space :-)
Tony Seale great stuff - thanks for such clear explanations on the "plumbing." This is the important but not urgent work that companies ignore until it's usually too late to fix.
1 reply — continued by Kyle Gilbride
Tony Seale I agree but for the buyers and decision makers (CEO, CFO, CRO) - do they get this? I was chatting with Daniel Remedios about this and I don't think most understand the need.
It sounds like something very similar to LinkML.
1 reply from Tony Seale
yes same backbone - the semantic web
Interesting approach. But scaling concepts for shared semantic frameworks like YAML-LD might face resistance without clear immediate benefits for adopters. We'll see if this can seamlessly integrate into existing systems without causing chaos. Keeping it decentralized is key though!
The frontmatter already being half-structured is the detail most people miss on first read. The gap to linked data is smaller than it looks.
AWESOME!
1 reply from Tony Seale
Thank you 😊
I Use LLM wiki. Is good organise to obsidian.