Series · Knowledge layer deep dives
Ontology for AI agents: how to build one in five stages
How to build an ontology AI agents can use, in five gated stages from a controlled vocabulary to a knowledge graph. The W3C standards for each stage, competency questions, Turtle and SPARQL for a worked example, entity resolution, versioning and "as of" queries.
Inovagio team · Published · Updated · 21 min read

On this page
An ontology for AI agents is a versioned model of your business that software can check: the kinds of things you deal with, how they relate and the rules that must hold, written in W3C standards. Agents use it to read records the way your experts do and to refuse answers your own rules say can't be true.
Most ontology projects that fail start at the top. Someone sets out to model the whole enterprise, the model grows for a year, and no agent ever queries it. The ones that work start from a short list of questions the business needs answered and build up in stages, each approved by whoever the organization makes responsible for it. This guide walks the build stage by stage, with the standard for each, a worked accounts payable example in Turtle and SPARQL, and the operational parts that decide whether it survives: entity resolution, versioning and time. Our plain-English companion, taxonomy, ontology, knowledge graph, covers the same ladder for business readers.
Why a schema isn't enough for an agent
#A database schema tells an agent which columns exist. It doesn't say that EXC_CD = 'PV' and EXC_CD = 'PRC' mean the same exception, that an invoice is billed against exactly one purchase order, or that the controller's "statement" is a different thing from a supplier's. Gartner's May 2026 release says schema-based data models alone "no longer suffice for agentic AI" and recommends a context layer as core data infrastructure. Gartner predicts that by 2027, organizations that prioritize semantics in AI-ready data will increase agentic AI accuracy by up to 80% and reduce costs by up to 60% (Gartner, May 11, 2026). That's a forecast, and the release doesn't name ontologies; the argument for them comes from the benchmarks.
The best-known one comes from insurance. Sequeda, Allemang and Jacob took 13 tables from the OMG standard data model for property and casualty insurance (the full physical model has 199 tables and 243 foreign keys), wrote 43 business questions, and asked a leading model of 2023 to answer them zero-shot, once by writing SQL over the tables and once by writing SPARQL over a knowledge graph built on an ontology of the same data (arXiv 2311.07509, November 13, 2023). In the paper's summary, a model answered 16% of business questions correctly from the raw tables and 54% from a knowledge graph of the same data. The split by question type tells you where the ontology earns its keep.
On questions that needed more than four tables, the model got 0% right from the raw tables and 35.7% to 38.5% right over the knowledge graph. On questions that needed four tables or fewer the gap was narrower: 25.5% and 37.4% from the raw tables, against 71.1% and 66.9% over the knowledge graph. Joins are where text-to-SQL breaks, and joins are what an ontology names.
A follow-up added an ontology-based query check: each generated SPARQL query was tested against the semantics of the ontology, and a query that failed went back to the model with the explanation, for repair. The share of answers that were either right or an honest "I don't know" rose from 54% to 72%, with "I don't know" making up 8 points of it, so the error rate fell to 20% (Allemang and Sequeda, arXiv 2405.11706, May 20, 2024). The check didn't make the model smarter. It gave it a way to know it was wrong.
Forrester's sequencing is the one we'd recommend: a semantic layer is the right starting point, a "data graph" is the bridge, and the knowledge graph is the destination; most organizations aren't ready for the last step yet (Forrester, June 2, 2026). The five stages below are how you get there without a year of modeling first.
How to build an ontology for AI agents in five stages
#Every stage has an approver and a gate, and you decide who approves what. Synesis lets you set the approver for each stage and each class of rule. Many organizations have a department head approve their own terms and a governance body or compliance approve the company-wide model, and you can require two approvers for regulated rules. The last column shows that common pattern; it's a starting point, not a requirement.
| Stage | What it adds | Standard | Typical approver (you decide) |
|---|---|---|---|
| Controlled vocabulary | One preferred term per concept; other names point to it | ANSI/NISO Z39.19; SKOS prefLabel, altLabel, hiddenLabel | The department head |
| Taxonomy | Parent and child terms for roll-up and routing | SKOS broader, narrower, ConceptScheme | The department head |
| Thesaurus | Related terms, scope notes, mappings between schemes | SKOS related, scopeNote, exactMatch; ISO 25964 | The department head |
| Ontology | Classes, properties and constraints software can check | OWL 2 (RL or EL profile) plus SHACL | A governance body or compliance, through the alignment gate; a second approver for regulated rules if you require one |
| Knowledge graph | Real instances, linked under the ontology | RDF, SPARQL 1.1, R2RML, PROV-O | Often the same governance body; a version publishes only once every shape validates and it passes its evaluation |
The hand-off between the third and fourth rows is the one to design with care. A department's term reaches the organization's ontology only through an alignment gate: a reviewed decision that the organization needs the concept, recorded as a SKOS mapping from the department's concept to the organization's, never a merge of every department's list. The ontology gate also requires that every competency question passes and that the reasoner finds no logical inconsistency.
Open standards at every stage aren't a purist's choice. The approvals are the expensive part of this work, and they should outlive any one tool or vendor. In Inovagio, your rulebook exports free, in open standards: SKOS for the vocabularies and OWL for the model, with SHACL for the rules. Any standards-based tool can read it, whoever runs the models.
A few details that trip teams up. SKOS, the Simple Knowledge Organization System, was written for vocabularies, and its own reference says it isn't a formal knowledge representation language. A SKOS concept is an individual, an instance of skos:Concept, not an OWL class (W3C SKOS Reference, August 18, 2009). That's a feature. It lets an accounts payable team maintain its terms without anyone deciding whether "price variance" is a class of invoices or a value on an invoice. OWL 2 does let one IRI name both a concept and a class (punning), but a reasoner treats the two uses as unrelated, so punning buys you no inference across the line. And skos:broader isn't transitive: by convention it states only direct parents. Use the property path skos:broader* in queries, or query skos:broaderTransitive, its transitive super-property, under a reasoner that applies the SKOS schema.
OWL 2, the Web Ontology Language, comes in profiles. EL suits very large class hierarchies with polynomial-time reasoning; QL is built to rewrite queries onto relational databases; RL is designed for rule-based engines and scales well on instance data (W3C OWL 2 Profiles, December 11, 2012). For agents working over operational records, RL is usually the right default when you materialize the graph. If you leave the data where it is and query it through a mapping (see R2RML below), QL is the profile whose reasoning survives being rewritten into SQL. Full OWL 2 DL is a different cost class: reasoning in its underlying logic, SROIQ, is N2ExpTime-complete, which is why production systems pick a profile. Synesis materializes OWL 2 RL incrementally and classifies large EL terminologies with a separate consequence-based reasoner.
SHACL (the Shapes Constraint Language), a separate W3C Recommendation since July 2017, validates data against shapes (W3C SHACL, July 20, 2017). RDF (the Resource Description Framework) is the data model under all of them, and RDF 1.1 is the current Recommendation. RDF 1.2 adds triple terms. A reifier points at a triple with rdf:reifies, and statements about the reifier say who asserted the triple and with what confidence, with standard syntax in place of RDF 1.1's four-triple rdf:Statement pattern. Synesis keeps confidence and provenance on reifiers this way. RDF 1.2 was a Candidate Recommendation Draft as of November 11, 2026 (W3C RDF 1.2 Concepts), and the Data Shapes Working Group published SHACL 1.2 Core as a Working Draft on November 10, 2026 (W3C SHACL 1.2 Core).
Start from competency questions
#Competency questions are the questions an ontology must be able to answer. Michael Grüninger and Mark Fox introduced them in 1995 as the way to scope an ontology and then test it: write motivating scenarios, list the informal questions, define the terms, restate each question formally against them, then write the axioms that make the answers follow (University of Toronto Enterprise Integration Laboratory). Thirty years on, they're still the best defense against an ontology that models everything and answers nothing. The later methods kept them. NeOn starts every build with an ontology requirements specification built around them, and has a scenario for re-engineering thesauri into ontologies, which is the step from stage 3 to stage 4 (Suárez-Figueroa and colleagues, 2012). eXtreme Design runs each question as a unit test and assembles the model from small ontology design patterns (Presutti and colleagues, WOP 2009).
For the accounts payable team at Marrowfield Foods, a regional food distributor (Example company), the first five were:
- How many open invoices have a price variance, including every narrower kind?
- Which open invoices are dated outside their purchase order's validity period?
- Which open price-variance invoices are from a supplier with two or more earlier price variances in the past year?
- Which open invoices are from a supplier whose bank details changed last quarter?
- Under which version of the price tolerance rule was this invoice matched, and what did that rule say then?
Each question names the terms it needs, and nothing gets modeled that no question needs. That's the scoping discipline. The second half matters just as much: once a question has a formal version, it becomes a test. In Synesis, competency questions are stored as executable queries and run against every proposed change, so a change that breaks question 3 is visible before anyone approves it.
Notice that question 5 is about time. Most first drafts miss it, and it's the one an auditor asks.
A worked example in Turtle
#Here are the first four stages for Marrowfield's exception types and invoices, in Turtle, the most readable RDF syntax. The SKOS part is what the accounts payable team maintains. The OWL part goes to whoever Marrowfield makes responsible for the company-wide model. Ontology terms and vocabulary concepts get their own namespaces, apart from the instance data, so a published class IRI never collides with a record.
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix skos: <http://www.w3.org/2004/02/skos/core#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
@prefix mf: <https://example.com/marrowfield/ontology/> .
@prefix mfv: <https://example.com/marrowfield/vocab/> .
# Stages 1 to 3: the accounts payable team's terms (SKOS)
mfv:ExceptionTypes a skos:ConceptScheme ;
skos:prefLabel "Accounts payable exception types"@en .
mfv:MatchException a skos:Concept ;
skos:inScheme mfv:ExceptionTypes ;
skos:topConceptOf mfv:ExceptionTypes ;
skos:prefLabel "Match exception"@en ;
skos:definition "An invoice that fails the match against its purchase order or goods receipt."@en .
mfv:PriceVariance a skos:Concept ;
skos:inScheme mfv:ExceptionTypes ;
skos:broader mfv:MatchException ;
skos:prefLabel "Price variance"@en ;
skos:altLabel "Price mismatch"@en ;
skos:notation "PV"^^mfv:ApExceptionCode , "PRC"^^mfv:ApExceptionCode ;
skos:definition "The invoiced unit price differs from the purchase order price by more than the price tolerance in force."@en ;
skos:scopeNote "A quantity variance is a separate concept."@en .
mfv:FuelSurchargeVariance a skos:Concept ;
skos:inScheme mfv:ExceptionTypes ;
skos:broader mfv:PriceVariance ;
skos:prefLabel "Fuel surcharge variance"@en .
mfv:InvoiceStatuses a skos:ConceptScheme .
mfv:Open a skos:Concept ;
skos:inScheme mfv:InvoiceStatuses ;
skos:prefLabel "Open"@en .
# Stage 4: the ontology, in the OWL 2 RL profile
mf: a owl:Ontology ;
owl:versionIRI <https://example.com/marrowfield/ontology/1.4.0/> ;
rdfs:label "Marrowfield accounts payable ontology"@en .
mf:Invoice a owl:Class ; rdfs:label "Invoice"@en ; owl:disjointWith mf:PurchaseOrder .
mf:PurchaseOrder a owl:Class ; rdfs:label "Purchase order"@en .
mf:Supplier a owl:Class ; rdfs:label "Supplier"@en .
mf:billedAgainst a owl:ObjectProperty ;
rdfs:label "billed against"@en ;
rdfs:domain mf:Invoice ;
rdfs:range mf:PurchaseOrder .
mf:issuedBy a owl:ObjectProperty ;
rdfs:label "issued by"@en ;
rdfs:domain mf:Invoice ;
rdfs:range mf:Supplier .
mf:invoiceDate a owl:DatatypeProperty , owl:FunctionalProperty ;
rdfs:label "invoice date"@en ;
rdfs:domain mf:Invoice ;
rdfs:range xsd:date .
mf:validFrom a owl:DatatypeProperty ; rdfs:domain mf:PurchaseOrder ; rdfs:range xsd:date .
mf:validTo a owl:DatatypeProperty ; rdfs:domain mf:PurchaseOrder ; rdfs:range xsd:date .
# The bridge: invoices point at concepts the accounts payable team maintains
mf:exceptionType a owl:ObjectProperty ;
rdfs:label "exception type"@en ;
rdfs:domain mf:Invoice ;
rdfs:range skos:Concept .
mf:status a owl:ObjectProperty ;
rdfs:label "status"@en ;
rdfs:domain mf:Invoice ;
rdfs:range skos:Concept .Note the bridge. Invoices point at SKOS concepts through mf:exceptionType; the exception types don't become OWL classes. That keeps the accounts payable team's vocabulary editable without an ontology release every time someone adds a narrower term. The source system's codes sit on the concept as skos:notation values with their own datatype, not as alternative labels: a code isn't a word, and SKOS gives codes their own property.
The price tolerance doesn't belong in OWL. OWL 2 can't do arithmetic or compare a value on one individual with a value on another; a datatype restriction only bounds a value by a constant. The tolerance is a versioned rule whose parameter is data, say two percent stored as an xsd:decimal, and the comparison of invoice and purchase order unit prices runs in a SHACL-SPARQL constraint or in the matching step, which records the rule version it applied. That record is what answers question 5. Amounts carry their currency as an ISO 4217 code beside an xsd:decimal, never as a bare floating-point number.
Before minting your own classes, check what you can reuse. schema.org has an Invoice type, FIBO (the Financial Industry Business Ontology) covers financial contracts and the parties to them, and PROV-O covers provenance. A common pattern is to keep your own IRIs and state rdfs:subClassOf or a SKOS mapping to the reused term, so the alignment is explicit and your model doesn't change when theirs does. Practitioners disagree about upper ontologies such as BFO (ISO/IEC 21838-2): they make integration across domains principled, at the price of commitments an accounts payable team rarely needs.
And here is competency question 3 in SPARQL 1.1, the W3C query language for RDF (W3C, March 21, 2013). The property path mf:exceptionType/skos:broader* is where the thesaurus pays off: an invoice coded as a fuel surcharge variance counts as a price variance without anyone listing the children.
PREFIX mf: <https://example.com/marrowfield/ontology/>
PREFIX mfv: <https://example.com/marrowfield/vocab/>
PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
SELECT ?invoice ?supplier (COUNT(DISTINCT ?earlier) AS ?priorPriceVariances)
WHERE {
?invoice a mf:Invoice ;
mf:status mfv:Open ;
mf:exceptionType/skos:broader* mfv:PriceVariance ;
mf:issuedBy ?supplier ;
mf:invoiceDate ?now .
?earlier a mf:Invoice ;
mf:exceptionType/skos:broader* mfv:PriceVariance ;
mf:issuedBy ?supplier ;
mf:invoiceDate ?then .
# One year back from today. SPARQL 1.1 has no standard date arithmetic,
# so the application passes the cutoff in as a literal.
FILTER (?then < ?now && ?then >= "2025-11-12"^^xsd:date)
}
GROUP BY ?invoice ?supplier
HAVING (COUNT(DISTINCT ?earlier) >= 2)Infer with OWL, validate with SHACL
#This is the distinction that most often goes wrong. OWL works under the open-world assumption: anything not stated might still be true. SHACL works closed-world: it checks the data you have against the shapes you wrote.
Take an invoice that the source system links to two purchase orders. The obvious way to say "one purchase order per invoice" in OWL is to declare mf:billedAgainst an owl:FunctionalProperty, and that's exactly why the example above doesn't. With that axiom, an OWL reasoner doesn't flag the record. OWL makes no unique-name assumption, so it concludes the two purchase order IRIs name the same purchase order, and that inference flows into every query. (Declare the purchase orders distinct with owl:differentFrom and the reasoner reports the whole graph inconsistent instead; finding the culprit takes a separate explanation step.) An invoice with no purchase order at all isn't an error either. Even if you add an axiom that every invoice is billed against exactly one purchase order, the reasoner assumes the invoice has one you haven't recorded.
Domains and ranges catch people the same way. They infer types; they don't check them. Reuse mf:issuedBy on a credit note and the reasoner concludes the credit note is an invoice. None of this is what an accounts payable manager means by "an invoice is billed against exactly one purchase order". That rule belongs in SHACL (prefixes as in the first block):
@prefix sh: <http://www.w3.org/ns/shacl#> .
@prefix mfs: <https://example.com/marrowfield/shapes/> .
mfs: a owl:Ontology ;
owl:imports mf: ;
sh:declare [ sh:prefix "mf" ; sh:namespace "https://example.com/marrowfield/ontology/"^^xsd:anyURI ] .
mfs:InvoiceShape a sh:NodeShape ;
sh:targetClass mf:Invoice ;
sh:property [
sh:path mf:billedAgainst ;
sh:class mf:PurchaseOrder ;
sh:minCount 1 ; sh:maxCount 1 ;
sh:message "An invoice is billed against exactly one purchase order"@en ] ;
sh:property [
sh:path mf:invoiceDate ;
sh:datatype xsd:date ;
sh:minCount 1 ; sh:maxCount 1 ] ;
sh:property [
sh:path mf:exceptionType ;
sh:node mfs:ExceptionTypeShape ] ;
sh:sparql [
a sh:SPARQLConstraint ;
sh:message "Invoice date falls outside the purchase order's validity period"@en ;
sh:prefixes mfs: ;
sh:select """
SELECT $this (?d AS ?value) WHERE {
$this mf:invoiceDate ?d ;
mf:billedAgainst ?po .
?po mf:validFrom ?from ;
mf:validTo ?to .
FILTER (?d < ?from || ?d > ?to)
}""" ] .
# An exception type must be a concept from the accounts payable scheme
mfs:ExceptionTypeShape a sh:NodeShape ;
sh:class skos:Concept ;
sh:property [ sh:path skos:inScheme ; sh:hasValue mfv:ExceptionTypes ] .Run against sample data, this shape reports the invoice with two purchase orders, the invoice with none, an invoice dated after its purchase order expired and an exception code from another scheme, each with its own message. The cross-field rule (invoice date inside the purchase order's validity period) needs a SPARQL-based constraint. SHACL Core's comparison constraints, sh:lessThan and its relatives, only compare two properties of the same focus node, and the validity period sits on the purchase order, not the invoice. SPARQL-based constraints are part of the SHACL Recommendation but an optional extension, so check that your validator implements them.
Use OWL 2 RL for what can be inferred safely, such as class membership and inverse relationships, and SHACL for everything an agent must refuse. In Synesis the shapes run over the inferred graph, so a rule doesn't fail on a fact the ontology already entails, and a version can't publish while any shape fails. An agent that gets a SHACL violation back can say "this record breaks rule 2" instead of guessing. It's the same idea as the ontology check behind the honest "I don't know" answers in the Allemang and Sequeda study: give the model a way to find out it's wrong before it answers.
Map the tables you already have
#You don't need to copy your finance system into a graph database to get a knowledge graph. R2RML (the RDB to RDF Mapping Language), a W3C Recommendation since September 2012, maps relational tables to RDF (W3C R2RML, September 27, 2012). The mapping can be materialized into a graph or used virtually, with SPARQL rewritten to SQL at query time. R2RML covers relational sources only. For CSV, JSON and XML, RML extends it with the same structure; RML is a report of the W3C Knowledge Graph Construction Community Group, not a W3C Recommendation (RML-Core).
@prefix rr: <http://www.w3.org/ns/r2rml#> .
@prefix mfm: <https://example.com/marrowfield/mapping/> .
# mf: as in the first block
mfm:InvoiceMap a rr:TriplesMap ;
rr:logicalTable [ rr:sqlQuery """
SELECT i.INVOICE_ID, i.INVOICE_DT, i.PO_NO, i.SUPPLIER_ID, x.CONCEPT_ID
FROM AP_INVOICE i
LEFT JOIN AP_EXCEPTION_CODE x ON x.EXC_CD = i.EXC_CD""" ] ;
rr:subjectMap [
rr:template "https://example.com/marrowfield/id/invoice/{INVOICE_ID}" ;
rr:class mf:Invoice ] ;
# A SQL DATE column becomes an xsd:date literal by R2RML's natural mapping
rr:predicateObjectMap [
rr:predicate mf:invoiceDate ;
rr:objectMap [ rr:column "INVOICE_DT" ] ] ;
rr:predicateObjectMap [
rr:predicate mf:billedAgainst ;
rr:objectMap [ rr:template "https://example.com/marrowfield/id/po/{PO_NO}" ] ] ;
rr:predicateObjectMap [
rr:predicate mf:issuedBy ;
rr:objectMap [ rr:template "https://example.com/marrowfield/id/supplier/{SUPPLIER_ID}" ] ] ;
# No exception code, no triple: R2RML skips a template whose column is NULL
rr:predicateObjectMap [
rr:predicate mf:exceptionType ;
rr:objectMap [ rr:template "https://example.com/marrowfield/vocab/{CONCEPT_ID}" ] ] .The AP_EXCEPTION_CODE lookup table is generated from the concepts' skos:notation values, so PV and PRC both land on mfv:PriceVariance and the vocabulary the accounts payable team approved is the one the mapping uses. In Synesis, R2RML bindings map each class and property to tables, graph labels and document collections, and the approved graph lives in MNEMOS beside the records it describes.
Resolve entities, reversibly
#The same supplier appears as "Kestrow Packaging Ltd", "KESTROW PACKAGING" and a tax number in the vendor file. Until those are one node, question 4 undercounts. The statistics of record linkage go back to Ivan Fellegi and Alan Sunter, who in 1969 framed it as comparing pairs of records field by field, weighting each agreement by how informative it is, and setting two thresholds: above one it's a match, below the other it isn't, and the band in between goes to a person (Fellegi and Sunter, Journal of the American Statistical Association, December 1969). That middle band is a review queue, and it should look like one.
Be careful with owl:sameAs. Asserting it merges every fact about both nodes, in both directions, and unwinding a wrong merge later is painful. Keep a candidate link with its evidence and score, have the right person approve it, and only then merge. The same caution applies between vocabularies: when the accounts payable scheme and the procurement scheme both define "price variance", skos:exactMatch says the two can be used interchangeably without fusing every statement about them the way owl:sameAs would. It's still transitive, though, so one loose mapping in a chain spreads, and skos:closeMatch is the safer default when you aren't sure.
Synesis does entity resolution with explainable, reversible merges for exactly this reason. An approved merge is an owl:sameAs that the engine applies by rewriting, leaving the source records untouched, so an unmerge withdraws exactly the conclusions that depended on it. The same discipline covers everything an agent extracts or proposes. It's a candidate with a confidence score, kept out of the graph the reasoner works from until it's approved, and no score approves anything on its own until it has been calibrated against a random audit of reviewed items.
Version everything, and keep both clocks
#An ontology that agents read is production code. Every change should arrive as a change set, be reviewed against the competency questions, be approved by the right person and be published with a version. In Synesis a change set moves from proposed to in review to approved to published, and every concept carries a stage, status, confidence and version, with a link to the interview or document it came from, recorded in PROV-O, the W3C provenance ontology.
Keep the ontology IRI stable and give each release a new owl:versionIRI. Derive the version number from the logical change rather than choosing it: removing an entailment or tightening a shape is a major version, adding terms or entailments a minor one, and annotation-only edits a patch. Never delete a published term. Mark it owl:deprecated true with dcterms:isReplacedBy pointing at its replacement, so queries and mappings written against the old term still resolve.
By default, Virtual Employees read only knowledge that has passed every gate, so a draft can't leak into a decision.
Time needs two axes. Valid time is when something was true in the world; recorded time is when you knew it. Suppose the price tolerance rule v1 was published on January 5. On March 10 an invoice was matched under it. On April 2, v2 was approved: a correction that applies from February 1. An auditor can ask two different questions about March 10, and both are fair: what should have applied, and what did the agent know? A bi-temporal store answers both. Synesis supports bi-temporal "as of" queries for that reason; read a task record shows where the rule version lands in the record of each task.
Regulated rules go through the same flow, and you can require two approvers for them; how a rule is approved walks through one.
Where the ontology sits among the other layers
#If most of your questions are about numbers (days payable, first-pass match rate, cycle time), start with governed metrics in a semantic layer for AI agents and bind those metrics to the ontology later. If your questions cross many documents and you're weighing a curated graph against one extracted by a model, the trade-offs are in how AI agents use your knowledge graph. For how an approved ontology becomes part of what an agent reads at each step, see what a context layer is, and for short answers to the questions architects ask most, the knowledge layer questions and answers.
Call it a pragmatic, domain-scoped ontology: one department's questions first, joined to the next department's through mappings, never one enterprise model drawn up front. Our recommendation for a first quarter: one department, five to ten competency questions, the vocabulary and taxonomy approved, one OWL and SHACL module for the rules those questions need, R2RML over the existing tables, and every question running as a test. Then add the next department's questions.
Further reading
#- A Benchmark to Understand the Role of Knowledge Graphs on Large Language Model's Accuracy for Question Answering on Enterprise SQL Databases, Sequeda, Allemang and Jacob, November 13, 2023: arxiv.org
- Increasing the LLM Accuracy for Question Answering: Ontologies to the Rescue, Allemang and Sequeda, May 20, 2024: arxiv.org
- Build Meaning Before Machines, Forrester, June 2, 2026: forrester.com
- Gartner Says Lack of Semantics Causes Inaccurate AI Agents and Wasted Spending, Gartner, May 11, 2026: gartner.com
- SKOS Simple Knowledge Organization System Reference, W3C, August 18, 2009: w3.org
- OWL 2 Web Ontology Language Profiles (Second Edition), W3C, December 11, 2012: w3.org
- Shapes Constraint Language (SHACL), W3C, July 20, 2017: w3.org
- R2RML: RDB to RDF Mapping Language, W3C, September 27, 2012: w3.org
- SPARQL 1.1 Query Language, W3C, March 21, 2013: w3.org
- RDF 1.2 Concepts and Abstract Data Model, W3C Candidate Recommendation Draft, November 11, 2026: w3.org
- Methodology for the Design and Evaluation of Ontologies, Grüninger and Fox, IJCAI-95 workshop, 1995 (summary): utoronto.ca
- A Theory for Record Linkage, Fellegi and Sunter, 1969: jstor.org
- The NeOn Methodology for Ontology Engineering, Suárez-Figueroa, Gómez-Pérez and Fernández-López, in Ontology Engineering in a Networked World, 2012: doi.org
- eXtreme Design with Content Ontology Design Patterns, Presutti, Daga, Gangemi and Blomqvist, Workshop on Ontology Patterns, 2009: ceur-ws.org
- A Translation Approach to Portable Ontology Specifications, Gruber, Knowledge Acquisition, 1993: doi.org
- Knowledge Engineering: Principles and Methods, Studer, Benjamins and Fensel, Data & Knowledge Engineering, 1998: sciencedirect.com
- PROV-O: The PROV Ontology, W3C, April 30, 2013: w3.org
- SHACL 1.2 Core, W3C Working Draft, November 10, 2026: w3.org
- RML-Core, W3C Knowledge Graph Construction Community Group, Draft Community Group Report: w3id.org
Questions
What people ask.
What is an ontology in AI?
An ontology in AI is a formal model of a domain: the kinds of things in it, how they relate, and the rules that must hold, written in a standard such as OWL 2 so software can reason over it, usually with SHACL shapes to check data against it. The definition most practitioners cite is Studer, Benjamins and Fensel's 1998 refinement of Tom Gruber's, which calls an ontology a formal, explicit specification of a shared conceptualization. AI agents use an ontology to interpret records consistently, to answer questions that cross systems and to recognize answers that break the rules.
What is the difference between SKOS and OWL?
SKOS describes vocabularies, taxonomies and thesauri: preferred and alternative labels, broader and narrower terms, related terms and scope notes. OWL 2 describes classes, properties and the axioms a reasoner uses to infer new facts. A SKOS concept is an individual, while an OWL class has members. Most enterprise ontologies use both, with SKOS for the terms people maintain, OWL for the logic and SHACL to check the data.
Why use SHACL if we already have OWL?
OWL assumes an open world, so missing or conflicting data often produces an inference instead of an error. SHACL validates the data you actually have against shapes, closed-world, and reports a violation with a message. Agents need SHACL to know when to stop and OWL to infer what can be inferred safely.
What are competency questions?
Competency questions are the questions an ontology must be able to answer, written before it is modeled. They set the scope, since nothing is modeled that no question needs, and once formalized they become tests that run against every proposed change.
Do we have to move our data into a graph database?
No. The W3C R2RML standard maps relational tables to RDF, so the knowledge graph can be materialized or queried virtually over the systems you already run. Many teams map first and materialize only the parts that need graph-speed traversal.
How do you keep an ontology from going stale?
Treat it like production code. Every change arrives as a versioned change set, runs against the competency questions, is approved by whoever your organization makes responsible for that part, and is published with a version agents can cite. Keeping valid time and recorded time lets you answer what was true and what was known on any date.
The products, industries and examples it covers.
- Knowledge layerSynesisTurns your policies, procedures, records and your people’s know-how into a rulebook your experts approve, which you own and can take anywhere.
- Data engineMNEMOSRecords, documents, vectors, graph and agent memory in one engine, with a ledger behind every write.
- OverviewArchitectureHow the platform fits together, from your data to finished work.
- OverviewDevelopersBuild agents, workflows and apps, already governed.
Read next.
Article · OntologyTaxonomy, ontology, knowledge graph: what each one does for AIA taxonomy sorts your words, an ontology writes down the rules between the things they name, and a knowledge graph connects your real records under those rules. What each stage fixes for an AI agent, who approves it, and where to start. · 13 min read
Guide · Semantic layerSemantic layer for AI agents: governed metrics for accurate answersA semantic layer defines each business metric once, with its joins and its owner, so an AI agent asks for "credit note rate" instead of writing its own SQL. What the 2023 to 2026 benchmarks show, a worked metric definition, the open Ossie standard and where MCP fits. · updated November 20, 2026 · 14 min read
Guide · Knowledge graphHow AI agents use your knowledge graphAn AI agent uses your knowledge graph in five steps. Approved terms become concepts, the ontology types the graph, retrieval finds connected records and their evidence, your rules check the result, and failures go to a person. How each step works, and what the GraphRAG research shows. · 17 min read
Developer edition
Build on Inovagio.
The MNEMOS data engine, the command line and the desktop app, with guides and API references.








