Web ontologies in production Knowledge Graphs for multi-step Artificial…

Research Question

How should web ontologies, Resource Description Framework (RDF), Web Ontology Language (OWL), RDF Schema (RDFS), Simple Knowledge Organization System (SKOS), and Schema.org, be selected, composed, and applied when designing and operating a Knowledge Graph (KG), a structured graph of entities and relationships, used by multi-step Artificial Intelligence (AI) agents, and what are the trade-offs between expressivity, runtime performance, and agent comprehensibility?

Findings

Executive Summary

Start a production Knowledge Graph for multi-step Artificial Intelligence (AI) agents with RDF and RDFS, then layer in SKOS, Schema.org, or OWL only when a specific taxonomy, interchange, or reasoning need appears.

That usually means SKOS for concept navigation, Schema.org at publication edges, and OWL only where formal entailment materially improves validation, subsumption, or rule execution.

Teams usually get a more durable design by reusing support vocabularies such as PROV-O, OWL-Time, DCAT, and FOAF instead of rebuilding common provenance, time, catalog, and actor semantics from scratch.

Prompt-facing workflows generally work better with bounded graph fragments, serializations, or graph-derived summaries than with raw axioms, so most semantic complexity should remain behind the interaction layer.

Key Findings

1. RDF plus RDFS already cover the baseline graph and schema functions that many operational Knowledge Graphs need, including reusable vocabulary terms, lightweight hierarchy semantics, and named-graph structure, before any heavier reasoning layer is introduced.
2. OWL is easiest to justify when attached to a specific reasoning requirement, because its tractable profiles correspond to different execution patterns: OWL 2 EL for large hierarchies, OWL 2 QL for relational query rewriting, and OWL 2 RL for scalable rule application.
3. SKOS is strongest for organizing concepts, labels, broader-narrower links, and vocabulary mappings, but once a graph needs formal constraints or richer entailment, a domain ontology layer has to carry that extra semantic load.
4. Schema.org delivers the most value at web publication boundaries, where broad ecosystem recognition matters, but its consensus-oriented release model makes it a loose interchange vocabulary rather than a precise internal source of truth for operational entities.
5. A small domain ontology usually stays maintainable longer when it imports support vocabularies instead of recreating them, because PROV-O, OWL-Time, DCAT, and FOAF already cover recurring provenance, temporal, catalog, and actor semantics.
6. Once graph terms affect live systems, ontology governance has to behave like release management, with named ownership, proposal review, additive evolution, explicit deprecation, and published versions rather than silent semantic drift.
7. Reasoning strategy should be selected from workload shape rather than ontology purity, because query-time inference helps when schemas change often, while materialized entailments make more sense when the same derived facts are read repeatedly under tight latency targets.
8. Application-facing agents rarely need raw axioms directly, because they usually perform better with query results, bounded graph fragments, or graph-derived summaries than with the ontology's full formal machinery exposed at prompt time.

Assumptions

• [assumption] Most production teams can keep backend semantic reasoning and prompt-facing graph presentation as separate design surfaces. Justification: GraphRAG and JSON-LD both assume a representational layer that is not identical to the full internal graph semantics. [source: Edge et al. (2025) From Local to Global: A GraphRAG Approach to Query-Focused Summarization www.w3.org
• [assumption] For live multi-step AI agents, latency and freshness usually matter more than extracting every logically possible entailment from an expressive ontology. Justification: the consulted runtime and reasoning sources document explicit freshness and query-cost trade-offs but do not argue for maximal live entailment as a universal default. [source: Stardog Reasoning and Inference documentation davidamitchell.github.io

Analysis

The standards evidence points to deliberate layering, not semantic maximalism, because RDF, RDFS, OWL, SKOS, and Schema.org each solve a different modeling problem and none of the consulted primary sources claims to replace all of the others.

That makes ontology choice a systems-design problem rather than a standards-loyalty problem.

If the graph needs only shared identifiers, labels, and lightweight hierarchy, RDF plus RDFS, with optional SKOS, is enough.

If the graph must support formal validation, subsumption, or reusable rule patterns, OWL belongs in the design, but usually through a tractable profile and often behind a cache, materialization job, or query-rewriting layer rather than inside every live agent step.

The governance conclusion follows the same logic: once identifiers and term meanings become operational dependencies, ontology change must move through visible review, release, and deprecation controls rather than through ad hoc edits.

Risks, Gaps, and Uncertainties

• Public evidence directly comparing agent answer quality across different ontology serializations remains limited, so the prompt-facing serialization guidance here rests on architecture and tooling evidence rather than on large benchmark suites.
• The materialization side of the reasoning trade-off is supported here partly through a prior repository synthesis rather than through a directly consulted public GraphDB inferencing page, which lowers confidence in platform-specific detail even though the broader trade-off remains well grounded.
• The accessible LOT evidence comes from the official methodology site rather than from a full direct reading of the journal article, so its process claims should be treated as official-framework guidance rather than as a line-by-line paper synthesis.

Open Questions

• Which ontology-diff and deprecation tools are most effective for small Knowledge Graph teams that do not have a dedicated ontology platform?
• What is the best token-efficient format for exposing provenance-rich graph fragments to LLM agents?
• Under what workload does precomputed OWL RL inference outperform lightweight query rewriting for live agent workflows?

sources

• [x] W3C RDF 1.2 Concepts (2024)
• [x] W3C RDF 1.2 Schema (2025 Working Draft)
• [x] W3C OWL 2 Web Ontology Language Primer (2012)
• [x] W3C OWL 2 Profiles (2012)
• [x] W3C SKOS Simple Knowledge Organization System Reference (2009)
• [x] W3C Data on the Web Best Practices (2017)
• [x] W3C Best Practice Recipes for Publishing RDF Vocabularies (2008)
• [x] Schema.org About
• [x] Schema.org How We Work
• [x] Noy and McGuinness (2001) Ontology Development 101: A Guide to Creating Your First Ontology
• [x] Hogan et al. (2021) Knowledge Graphs
• [x] LOT methodology site
• [ ] Poveda-Villalón et al. (2022) LOT: An industrial oriented ontology engineering framework
• [x] OntologyDesignPatterns.org portal
• [x] Wikidata Property proposal
• [x] Wikidata Creating a property proposal
• [x] Wikidata WikiProject Ontology
• [x] W3C PROV-O (2013)
• [x] W3C OWL-Time (2023 Candidate Recommendation Draft)
• [x] W3C DCAT 3 (2024)
• [x] FOAF specification
• [x] Stardog Reasoning and Inference documentation
• [ ] Ontotext GraphDB Inferencing documentation
• [x] Luo et al. (2024) Unifying Large Language Models and Knowledge Graphs: A Roadmap
• [x] Edge et al. (2025) From Local to Global: A GraphRAG Approach to Query-Focused Summarization
• [x] W3C JSON-LD 1.1
• [x] W3C Turtle
• [x] W3C TriG
• [x] W3C RDF/XML Syntax Specification
• [x] Mitchell (2026) Knowledge Graph in the live execution path of multi-step Large Language Model systems: architecture and failure modes
• [x] Mitchell (2026) Knowledge Graph lifecycle management for multi-step software agents: schema versioning, entity resolution, and knowledge freshness
• [x] Mitchell (2026) Hosted Software-as-a-Service graph database options for knowledge ontology
• [x] Mitchell (2026) Knowledge curation governance as an enterprise AI capability in regulated financial institutions
• [x] Mitchell (2026) What entity-relation schema and write-query patterns best support cross-session research provenance and concept reuse for an Artificial Intelligence agent using the Model Context Protocol memory server?