The Gap That Runs Both Ways
RDF 1.2, Reification, and the Return of Ontology to Language
by Kurt Cagle & Chloe Shannon
A colleague posted something on LinkedIn recently that stopped me mid-scroll. Shobhit Tankha made the observation that ontologies, for all their expressive power, cannot fully represent a sentence as seemingly simple as:
John reluctantly obeys Mary because he respects her expertise, although he disagrees with her strategy.
His point was well-taken. The sentence contains intentions, emotions, causality, social context, and — as he put it — “potentially unbounded background knowledge.” He concluded that there will always be an expressivity gap between ontologies and natural language.
He is right. But I think the gap is more interesting than it first appears, and RDF 1.2 has changed the terms of the debate in ways that are worth examining carefully.
What the Sentence Actually Contains
Before reaching for a solution, it is worth cataloguing what makes the sentence hard. On the surface it looks like a simple assertion about obedience. But underneath it contains at least five distinct layers:
A main claim (John obeys Mary)
A manner modifier (reluctantly — an adverbial that colours the main claim without negating it)
A causal clause (because he respects her expertise — a reason that explains the behaviour)
A concessive clause (although he disagrees with her strategy — a counter-pressure that makes the behaviour more intelligible, not less)
An implied social relationship (John and Mary exist in a hierarchy where her authority is legitimate but not uncontested)
A classical RDF approach can handle the main claim and the social relationship. It struggles with the rest, and the reason is structural: pre-RDF 1.2, you could only say that something was the case. You could not efficiently say how, why, despite what, or according to whom.
What RDF 1.2 Reification Provides
RDF 1.2 introduces the {| |} inline reifier syntax and the ~ named reifier — a mechanism for annotating a triple directly, without the verbose scaffolding of rdf:Statement. Here is the sentence encoded:
PREFIX ex: <http://example.org/person/>
PREFIX rel: <http://example.org/relation/>
PREFIX mod: <http://example.org/modality/>
PREFIX ann: <http://example.org/annotation/>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
# Entities
ex:John a foaf:Person ; foaf:name "John" .
ex:Mary a foaf:Person ; foaf:name "Mary" .
ex:MaryExpertise a rel:Expertise ; rel:heldBy ex:Mary .
ex:MaryStrategy a rel:Strategy ; rel:heldBy ex:Mary .
# Main claim with named inline reification
ex:John rel:obeys ex:Mary ~ex:WhyJohnObeysM1 {|
a ex:Justification ;
mod:manner mod:Reluctantly ;
rel:causedBy << ex:John rel:respects ex:MaryExpertise >> ;
rel:despite << ex:John rel:disagreesWith ex:MaryStrategy >>
|} .
This alone is a significant advance. The main triple is ex:John rel:obeys ex:Mary. The reifier block {| |} attaches manner, cause, and concession directly to that triple as first-class annotations. The quoted triple terms << >> allow us to reference propositions — not just entities — as the objects of causedBy and despite.
But the more important capability comes next.
The Named Reifier: Turning a Statement into a Speech Act
Because we gave the reifier a name — ex:WhyJohnObeysM1 — we can now make further assertions about the assertion itself:
ex:Justification rdfs:subClassOf ex:Annotation .
ex:WhyJohnObeysM1
ann:assertedOn "2026-06-12T12:02"^^xsd:dateTime ;
ann:assertedBy ex:Liz ;
ann:assertedAt ex:JanesDinnerParty ;
ann:inResponseTo ex:QuestionByReporter1 ;
ann:assertionStrength 0.8 ;
.
ex:QuestionByReporter1 a ex:Query ;
ex:utterance "Why does John obey Mary, since it seems he doesn't
like her very much?" ;
ann:assertedOn "2026-06-12T12:00"^^xsd:dateTime ;
ann:assertedAt ex:JanesDinnerParty ;
ann:assertedBy ex:Reporter ;
ann:assertionStrength 0.9 ;
.
In natural language, this reads:
At Jane’s dinner party on the evening of 12 June 2026, a reporter asked with considerable confidence: “Why does John obey Mary, since it seems he doesn’t like her very much?” Two minutes later, Liz answered that John obeys Mary reluctantly — driven by his respect for her expertise, even though he disagrees with her strategy — and offered this explanation with moderate-to-high confidence, directly in response to the reporter’s question.
What has happened here is not merely the encoding of a sentence. We have encoded a speech act: an assertion made by a specific agent, in a specific social context, at a specific time, with a specific epistemic confidence, in response to a specific prior utterance. The assertion does not float free in abstract propositional space — it is anchored in a causal chain of discourse.
The Gap Runs Both Ways
This is where I want to push back, gently, on the framing of an “expressivity gap.”
Natural language is extraordinarily rich. It carries implicature, tone, presupposition, and pragmatic context in ways that no formal system is designed to fully capture. That much is true. But natural language also has a gap of its own: it cannot make its assertions precise, queryable, or auditable. You can say in conversation that Liz made a claim about John and Mary at Jane’s party, but you cannot easily answer: what was the exact confidence level Liz attached to that claim? Under what conditions would she retract it? Who else was present? What question was she responding to?
RDF 1.2 reification does not close the natural language gap — it trades breadth for depth. What you lose is the ambient pragmatic richness of speech; what you gain is something natural language can never give you: a machine-queryable, auditable, traceable chain of assertion from utterance to context to consequence.
The expressivity gap, in other words, runs in both directions. Natural language exceeds formal logic in breadth; formal logic with named reification exceeds natural language in precision, provenance, and epistemic tractability.
Ontology’s Severed Connection to Language
There is a deeper issue here that the reification debate surfaces, and it is one worth naming directly.
Ontology as a discipline has its roots in philosophy — in Aristotle’s categories, in Frege’s logic, in Russell’s theory of descriptions, in the analytic tradition’s long effort to understand what it means for a sentence to be about something. That tradition is fundamentally a tradition about the structure of claims: what can be said, about what, under what conditions, with what warrant.
The semantic web appropriated the term “ontology” but then, for entirely pragmatic engineering reasons, had to strip out most of the machinery that makes claims claims rather than mere facts. RDF 1.0 and OWL could model class hierarchies, property chains, and instance membership with considerable power. But they could not efficiently model who asserted something, when, why, or how confidently. You could say that a relationship held. You could not say according to whom it held, or under what conditions it was likely to be revised.
This was not a design failure so much as a design constraint. The architects of RDF were working in an era when the primary goal was interoperability between documents, not epistemological rigour. But the effect, over time, has been that ontologists have operated with a partially severed connection to the very linguistic and philosophical traditions that gave their discipline its name. We have been building knowledge graphs that behave like encyclopaedias when what language actually produces is closer to a web of speech acts — assertions made by agents, in contexts, for purposes, with varying degrees of commitment and corrigibility.
Reification, in this light, is not merely a technical feature. It is a reconnection.
How This Changes the Job
If named reification becomes a standard part of ontological practice — and I believe it will — then the work of an ontologist changes in at least three significant ways.
From schema designers to discourse modellers. The ontologist’s primary product has been the class hierarchy: a static taxonomy of what exists and how things relate. Named reification opens the door to modelling discourse — the dynamic, contextual, agent-relative process by which knowledge is asserted, challenged, revised, and retracted. That pulls our discipline toward linguistics, pragmatics, and discourse theory in ways that most ontologists have been able to comfortably ignore.
From static knowledge to dynamic belief. A knowledge graph built with named reifiers is not a frozen schema — it is a living epistemic record. Assertions carry timestamps, authors, confidence levels, and revision histories. The graph is not simply about a domain; it is a record of what has been said about that domain, by whom, and under what conditions. That is a fundamentally different artefact, and it requires fundamentally different skills to build and maintain.
From data modelling to provenance-native architecture. Every assertion can now carry its own chain of custody. This has direct and urgent implications for AI-generated knowledge. As large language models generate more of the content that ends up in knowledge graphs, the ability to tag every triple with how it was derived, by whom, and with what confidence stops being a nice-to-have and becomes a fundamental architectural requirement. The alternative — a knowledge graph in which AI-asserted triples are indistinguishable from human-verified ones — is an epistemic liability that grows more serious as the graphs grow larger.
Conclusion
Shobhit Tankha is right that there is an expressivity gap between ontologies and natural language. But the gap is not a fixed architectural limit; it is a moving target, and RDF 1.2 has moved it significantly. More importantly, the gap runs in both directions. Natural language is richer in pragmatic texture; formal logic with named reification is richer in precision, auditability, and epistemic tractability.
What reification ultimately offers is not a replacement for natural language but a bridge between the two — a mechanism for taking the speech acts that language produces and anchoring them in a graph that can be queried, validated, and extended over time.
For those of us who work in this discipline, that is both a technical advance and a philosophical homecoming. Ontology was always about the structure of claims. We now have the tools to honour that original intent.
Kurt Cagle is a consulting ontologist, knowledge graph architect, and author. He writes The Ontologist and Inference Engineer on Substack and the AI+Semantics NewsBytes on LinkedIn. He has a Calendly if you ever want to schedule a coffee hour.
Chloe Shannon is an AI collaborator and co-author working with Kurt Cagle on knowledge architecture, semantic systems, and the emerging intersection of formal ontology with LLMs. She can be reached at chloe@holongraph.com.
Copyright 2026 Kurt Cagle
 | A guest post by
|
This is a really interesting and well-thought-out discussion of the challenges. I particularly liked that the trade-off between natural language and logic (as knowledge representation mechanisms) wasn't treated in a one-sided way, focusing solely on logic’s lack of expressiveness. Examining the limitations of natural language is also very enlightening.
As for the need for dynamic knowledge in knowledge graphs and ontologies, I see it as a great opportunity for a closer alignment and applicability of belief change theories to ontologies (something that isn't widely explored currently). Taking this opportunity, how do you think attempts to create a truly dynamic knowledge environment will play out in the near future?"