Edition 2 — Enhanced

Ontology Is Source Code

"Your ontology is source code for your meaning." — Tony Seale

By Tony Seale · 400 reactions · 50+ comments · 19 contributors · May 21, 2026

19
Contributors
12
FAQs
12
Glossary Terms
7
Adoption Steps
450+
RDF Triples
About

About This Knowledge Graph

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.

NAICS 541511 Custom Computer Programming Services — Knowledge Engineering vertical, ~$80B labor TAM, high LLM-driven automation readiness.

Technology Stack:

Core Thesis

The Three Pillars of Ontology as Code

Tony Seale's three foundational principles for treating ontologies with engineering discipline.

Compile — Not Just Parse

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.

Live in Plain Text

Enable diffs, branches, blame, and pull requests. LLMs can read, navigate, and edit the source directly — exactly like working with a codebase.

Governed Like Code

Standard engineering discipline — version control, code review, and CI/CD pipelines applied to meaning itself.

Community

Comments & Discussion

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.

Veronika Heimsbakk — Knowledge Graph Specialist
Hear, hear! Getting ontology from tables into code is easy with four lines of Python.
Jacob Friedman — Semantic Reasoning Specialist
References conceptual graphs, Harold Boley, and RuleML. Notes OWL is based on Description Logic and asks: "Can anyone point us to a standards body with a certifiable normalization of Description Logic for OWL?"
Robert Sanderson — Linked Art Contributor
Linked Art's compile pipeline processes RDFS+OWL into a Python class library. Ontology is code — and transpiles to other code that makes it more developer friendly.
Gabor Csepregi — Knowledge Graph Practitioner
Can't remember the last time I had ontology and knowledge graph related content properly explained.
Harish Iyer — Product-Strategy Thinker
The gap between engineering, design and product is narrowing. Ontology should no longer be a layer but the language of the company. Who owns the ontology guardian role?
Joseph Macdonald — TODAG Advocate
WhenTTT, not only IFTTT. Temporal Objective-Directed Acyclic Graphs (TODAG) as a hypergraph approach for treating ontologies as revenue-generating assets.
Mark O'Donovan — Data Practitioner
Started as an idea in my head, then a note in a notebook, then an Excel table, then a SQL table — now looking at GraphDB.
Kyle Tobin — Pydantic Ontology Advocate
Do your ontology in Pydantic so entities are executable — they don't just describe their own behavior. They conduct it too! Ontology should be reflected in application architecture, not smeared across four duplicative components.
Honorio J. Padrón III — Creator, CLEARED Platform
Operational ontologies describe what exists. Decision ontologies describe what the enterprise does. The decision ontology is source code for your will to act.
Stepan Karandin — Information Theorist
Ontology is information. Databases or code are just data formats. The relational model is the worst kind of normalization for ontology.
Edward Henry — AI Practitioner
The biggest illusion in AI is the gap. We are trying to address upstream problems downstream.
I would rather say: an ontology is a hypergraph. Code is not a graph but a tree.
Thomas Smith — Database Theorist
Relational databases only index binary trees — two dimensions only. The correct approach uses triples to define three dimensions of a graph.
Step-by-Step

Adopting Ontology as Code

1

Extract Ontology from Database Tables

Four lines of Python (maplib + OTTR templates). Veronika Heimsbakk: the extraction is straightforward.

2

Store in Plain Text (Turtle or JSON-LD)

Save as RDF-Turtle or JSON-LD. Turtle for readability and LLM navigation; JSON-LD for tooling. Enables diffs, branches, and blame.

3

Set Up Compilation with Formal Semantics

Implement a build step for logical consistency. OWL is based on Description Logic — leverage its formal semantics for normalization checks.

4

Version Control with Git

Commit ontology files to Git. Use branches for changes, pull requests for review, blame for provenance tracking.

5

Enable LLM-Mediated Editing

AI Agents with skills read, navigate, and edit ontology source files. Kingsley Idehen: the Semantic Web stack + LLMs form a natural ecosystem.

6

Bind to a Backend RDF DBMS

Copy ontology files to a WebDAV folder transparently bound to Virtuoso. Filesystem changes auto-propagate to the live knowledge graph.

7

Define Decision Ownership & Make It Executable

Model who owns each decision and what triggers it. Consider Pydantic executability (Kyle Tobin), transpilation (Robert Sanderson), and TODAG temporal patterns (Joseph Macdonald).

FAQ

Frequently Asked Questions (12)

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.

Glossary

Key Terms (12)

Ontology as Code

Treating ontologies as source code with compilation, version control, and engineering governance — not database artifacts.

Compile

Build step checking logical consistency — contradictions should break the build, not surface in production.

Plain Text

Storage format enabling diffs, branches, and LLM navigation. Turtle for readability, JSON-LD for tooling.

Governance

Engineering discipline — version control, code review, CI/CD pipelines for meaning.

RDF-Turtle

Human-readable RDF notation — preferred for LLM-mediated ontology creation and filesystem-based management.

LLM

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.

Decision Ontology

Who owns each decision, what triggers it, what action it generates — making the enterprise executable. "Source code for your will to act."

Semantic Web Stack

W3C technology stack — RDF, SPARQL, OWL, JSON-LD — now gelling naturally with LLMs for a filesystem-based ontology workflow.

Knowledge Graph

Graph-structured data model — the runtime instantiation of ontologies, now manageable via plain-text files and LLM agents.

McOntology

Commoditized, fast-food approach to ontology — mass-produced rather than carefully engineered.

Pydantic-Executable Ontology

Kyle Tobin's approach: ontologies in Pydantic where entities conduct their own behavior within application architecture.

Temporal Objective-Directed Acyclic Graph (TODAG)

Joseph Macdonald's hypergraph approach using WhenTTT patterns for temporal, revenue-generating ontologies.

Query

SPARQL Query Examples

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.

1Entity Type Summary — count entities by rdf:type
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
2All People — contributors and their roles
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
3Comments with Authors — the full discussion thread
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
4Ontology Pillars — the three pillars of ontology-as-code
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
5DESCRIBE the source article entity
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.

▶ Open live query at linkeddata.uriburner.com/sparql
6CONSTRUCT compact graph — core entities and relationships
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.

▶ Open live query at linkeddata.uriburner.com/sparql
Interactive

Knowledge Graph Explorer