"Your ontology is source code for your meaning." — Tony Seale
This knowledge graph distills a May 2026 LinkedIn post by knowledge graph engineer Tony Seale and the 45-comment discussion it generated. Seale's thesis — ontologies should be treated as source code, not database rows — rests on three engineering principles: compile for logical consistency, store in plain text for version control, and govern with CI/CD discipline. The commentary thread surfaces the practical implications: Kingsley Uyi Idehen's demonstration that LLM-powered agents with filesystem-bound RDF stores make ontology management dramatically simpler, Honorio J. Padrón III's distinction between operational and decision ontologies, and Veronika Heimsbakk's four-line Python bridge from tables to triples. The knowledge graph encodes 38 entities, 40 typed relationships, 19 contributors, 12 FAQs, and a 7-step adoption guide — all navigable through the KG Explorer below and queryable via the embedded SPARQL workbench.
Technology Stack:
Tony Seale's three foundational principles for treating ontologies with engineering discipline.
A build should break on contradictions or unexpected entailments. An absent entailment is a test failure, not a curiosity discovered six months later in production.
Enable diffs, branches, blame, and pull requests. LLMs can read, navigate, and edit the source directly — exactly like working with a codebase.
Standard engineering discipline — version control, code review, and CI/CD pipelines applied to meaning itself.
Ontology management is a classic files-and-filesystem interaction pattern. RDF-Turtle is very much human-readable shorthand but lacked tooling support. Today the Semantic Web stack gels naturally with LLMs and AI Agents.
Ask an AI Agent to express worldviews in whatever notation you prefer, save to a file, and copy to a folder bound to a backend RDF DBMS. LLM-powered Agents with Skills make this process a zillion times easier.
The demo showcases at linkeddata.uriburner.com/DAV/demos/daas/ are live examples of this filesystem-to-quad-store pipeline.
The post sparked a 45-comment discussion spanning LLM integration, decision ontologies, Pydantic-executable entities, temporal hypergraphs, transpilation, and the upstream/downstream AI gap. Kingsley Idehen's commentary appears above in Featured Insight.
Four lines of Python (maplib + OTTR templates). Veronika Heimsbakk: the extraction is straightforward.
Save as RDF-Turtle or JSON-LD. Turtle for readability and LLM navigation; JSON-LD for tooling. Enables diffs, branches, and blame.
Implement a build step for logical consistency. OWL is based on Description Logic — leverage its formal semantics for normalization checks.
Commit ontology files to Git. Use branches for changes, pull requests for review, blame for provenance tracking.
AI Agents with skills read, navigate, and edit ontology source files. Kingsley Idehen: the Semantic Web stack + LLMs form a natural ecosystem.
Copy ontology files to a WebDAV folder transparently bound to Virtuoso. Filesystem changes auto-propagate to the live knowledge graph.
Model who owns each decision and what triggers it. Consider Pydantic executability (Kyle Tobin), transpilation (Robert Sanderson), and TODAG temporal patterns (Joseph Macdonald).
Because ontologies express formal logic and axioms — not database rows. They should compile, live in plain text for version control, and be governed with engineering discipline. Tony Seale: "Your ontology is source code for your meaning."
A build should break on contradictions or unexpected entailments. An absent entailment is a test failure, not a curiosity discovered six months later. This catches logical errors at build time rather than in production.
Plain text enables diffs, branches, blame, and PRs. LLMs can read, navigate, and edit the source directly — exactly like working with a codebase.
Kingsley Idehen: The Semantic Web stack gels naturally with LLMs and AI Agents. Users can ask an AI Agent to express worldviews in any notation, save to a file, and copy to a folder bound to a backend RDF DBMS. LLM-powered Agents with Skills make this "a zillion times easier."
Honorio J. Padrón III: Operational ontologies describe what exists. Decision ontologies describe what the enterprise does — who owns each decision, what triggers it, what action it generates. The decision ontology is "source code for your will to act."
Tony Seale's term for commoditized, fast-food approaches to ontology — mass-produced rather than carefully engineered. The antithesis of ontology-as-code.
RDF-Turtle is human-readable shorthand for triples; JSON-LD has more tooling support. Combined with LLMs, the stack now provides both readability and tooling. Files in a DAV folder bound to Virtuoso automatically become part of a live quad store.
Tony Seale: You wouldn't write application code in a database table. Thomas Smith: relational databases index binary trees — two dimensions. Ontologies need triples for three dimensions. Stepan Karandin: the relational model is the worst kind of normalization for ontology.
Veronika Heimsbakk: four lines of Python — maplib + OTTR templates to map structured data to ontology properties.
Kyle Tobin: Pydantic-defined ontologies where entities are executable — "they don't just describe their own behavior. They conduct it too!" Robert Sanderson: Linked Art transpiles RDFS+OWL into Python class libraries.
Harish Iyer: one of the most consequential product decisions a company will make. The ontology guardian role sits at the intersection of engineering, design, and product.
Edward Henry warns the biggest illusion is trying to address upstream problems downstream — turning LLM slop into something real. Ontology-as-code addresses this by formalizing meaning at the source.
Treating ontologies as source code with compilation, version control, and engineering governance — not database artifacts.
Build step checking logical consistency — contradictions should break the build, not surface in production.
Storage format enabling diffs, branches, and LLM navigation. Turtle for readability, JSON-LD for tooling.
Engineering discipline — version control, code review, CI/CD pipelines for meaning.
Human-readable RDF notation — preferred for LLM-mediated ontology creation and filesystem-based management.
Large Language Models that can read, navigate, and edit ontology source files. Paired with skills and RDF DBMS, they enable natural-language-driven ontology management.
Who owns each decision, what triggers it, what action it generates — making the enterprise executable. "Source code for your will to act."
W3C technology stack — RDF, SPARQL, OWL, JSON-LD — now gelling naturally with LLMs for a filesystem-based ontology workflow.
Graph-structured data model — the runtime instantiation of ontologies, now manageable via plain-text files and LLM agents.
Commoditized, fast-food approach to ontology — mass-produced rather than carefully engineered.
Kyle Tobin's approach: ontologies in Pydantic where entities conduct their own behavior within application architecture.
Joseph Macdonald's hypergraph approach using WhenTTT patterns for temporal, revenue-generating ontologies.
Ready-to-run SPARQL queries against the companion RDF graph. Each query targets the URIBurner SPARQL endpoint. SELECT queries use text/x-html+tr; DESCRIBE and CONSTRUCT use text/x-html-nice-turtle.
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 : <https://www.linkedin.com/posts/tonyseale_did-you-start-building-your-ontology-as-a-share-7463353332565356545-jY54#>
SELECT ?type (SAMPLE(?s) AS ?sampleEntity) (SAMPLE(?label) AS ?sampleLabel) (COUNT(?s) AS ?entityCount)
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/ontology-as-source-code-deepseek_v4pro-2.ttl> {
?s rdf:type ?type .
OPTIONAL { ?s rdfs:label ?label }
}
}
GROUP BY ?type
ORDER BY DESC(?entityCount)
▶ Open live query at linkeddata.uriburner.com/sparql
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX schema: <http://schema.org/>
PREFIX : <https://www.linkedin.com/posts/tonyseale_did-you-start-building-your-ontology-as-a-share-7463353332565356545-jY54#>
SELECT ?person ?name ?description
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/ontology-as-source-code-deepseek_v4pro-2.ttl> {
?person rdf:type schema:Person ;
schema:name ?name .
OPTIONAL { ?person schema:description ?description }
}
}
ORDER BY ?name
▶ Open live query at linkeddata.uriburner.com/sparql
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX schema: <http://schema.org/>
PREFIX : <https://www.linkedin.com/posts/tonyseale_did-you-start-building-your-ontology-as-a-share-7463353332565356545-jY54#>
SELECT ?comment ?authorName ?text
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/ontology-as-source-code-deepseek_v4pro-2.ttl> {
?comment rdf:type schema:Comment ;
schema:author ?author ;
schema:text ?text .
?author schema:name ?authorName .
}
}
ORDER BY ?authorName
▶ Open live query at linkeddata.uriburner.com/sparql
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX schema: <http://schema.org/>
PREFIX : <https://www.linkedin.com/posts/tonyseale_did-you-start-building-your-ontology-as-a-share-7463353332565356545-jY54#>
SELECT ?pillar ?name ?description
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/ontology-as-source-code-deepseek_v4pro-2.ttl> {
?pillar rdf:type :OntologyPillar ;
schema:name ?name ;
schema:description ?description .
}
}
ORDER BY ?name
▶ Open live query at linkeddata.uriburner.com/sparql
DESCRIBE <https://www.linkedin.com/posts/tonyseale_did-you-start-building-your-ontology-as-a-share-7463353332565356545-jY54#analysis> FROM <https://linkeddata.uriburner.com/DAV/demos/daas/ontology-as-source-code-deepseek_v4pro-2.ttl>
DESCRIBE uses text/x-html-nice-turtle result format.
PREFIX schema: <http://schema.org/>
CONSTRUCT { ?s ?p ?o }
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/ontology-as-source-code-deepseek_v4pro-2.ttl> {
?s ?p ?o .
FILTER(?p IN (schema:about, schema:author, schema:comment, schema:hasPart, schema:name, schema:headline))
}
}
LIMIT 100
CONSTRUCT uses text/x-html-nice-turtle result format.