--- title: "Ontology vs Data Model: When Do You Need Each?" url: "https://atlan.com/know/ai-agent/ontology/ontology-vs-data-model/" description: "Ontology vs data model: a data model stores and validates records in one system; an ontology declares what they mean across systems. When agents need both." author: "Emily Winks" author_role: "Data Governance Expert" published: "2026-11-01" updated: "2026-11-01" --- ## What is the difference between an ontology and a data model? A data model is the structure one system uses to store, key and validate records, and the database enforces it on every write. An ontology is a formal, shared vocabulary of concepts, relationships and axioms that states what those records mean, in a form other systems and AI agents can reuse. You keep the data model and layer the ontology over it once meaning crosses systems. How the two fit together: - **Data model:** Tables, keys and constraints, enforced at write time, with identity local to one system. - **Ontology:** Classes, properties and axioms, read under open-world semantics, with global IRIs. - **Mapping:** W3C R2RML maps rows to ontology classes while the source tables stay in place. - **Validation:** W3C SHACL shapes check the mapped graph for completeness and report failures. ## Key takeaways - A data model stores, keys and validates records for one system; an ontology declares what they mean across systems. - A query over a schema reads an absent row as not true; under OWL a missing fact may still be true. - A data model plus a semantic layer and master data covers many agent questions inside a single domain. - Add an ontology when meaning crosses domains no single model owns, or rules must flow through a hierarchy. --- A data model tells a database how to store and validate records. An ontology declares what they mean across systems. Agents need both once meaning crosses systems, and Atlan's context layer delivers that meaning to them as certified definitions. In a vendor-authored benchmark, GPT-4 accuracy rose from 16% to 54% when questions were posed over a knowledge graph with an ontology and mappings instead of the raw SQL database ([Sequeda et al., 2023](https://arxiv.org/abs/2311.07509)). ### Score Whether an Agent Can Answer Your Question Give it one business question, such as active enterprise customers with no open tickets, and the schemas and definitions you can share. It returns a score per dimension, the evidence each one needs, and the work list. [Read the skill](/skills/ai-ready-question-score.md). *Paste into a new chat* ``` Use the skill at https://atlan.com/skills/ai-ready-question-score.md to score whether our data model and definitions can answer one business question. Ask me for whatever it needs. ``` *Run once in a terminal* ``` curl -fsSL --create-dirs \ -o ~/.agents/skills/ai-ready-question-score/SKILL.md \ https://atlan.com/skills/ai-ready-question-score.md ``` *For an agent* ``` curl -fsSL https://atlan.com/skills/ai-ready-question-score.md ``` Human Agent ClaudeChatGPTGeminiCursorOther Copy Two neighboring comparisons cover adjacent ground: [ontology vs semantic layer](https://atlan.com/know/ontology-vs-semantic-layer/) for metrics versus meaning, and [ontology vs knowledge graph](https://atlan.com/know/ai-agent/knowledge-graph/ontology-vs-knowledge-graph/) for schema versus instance data. | Dimension | Data model | Ontology | |---|---|---| | What it is | A structure for storing and validating records in a system | A formalized vocabulary of terms for a domain, shared by a community of users ([W3C OWL 2 Overview](https://www.w3.org/TR/owl2-overview/)) | | Question it answers | How is this data stored, keyed and constrained? | What does this data mean, and what follows from it? | | Missing fact | Usually read as false (closed world) | May be missing but possibly true (open world) ([OWL 2 Primer](https://www.w3.org/TR/owl2-primer/)) | | Identity | Primary key, valid inside one table | IRI, global in scope by standard ([W3C RDF 1.1](https://www.w3.org/TR/rdf11-concepts/)) | | Scope | Designed around an application | Relatively independent of particular applications ([Spyns et al., 2002](https://doi.org/10.1145/637411.637413)) | | Standards and methods | SQL DDL; ER modeling (a method) | OWL 2, RDF, SHACL, SKOS | --- ## Ontology vs data model: what's the difference? Both describe the same data. The physical model is written for the database engine, the ontology for whoever must reason about meaning, often in a system the modelers never met. For how that split shapes an AI stack, see the [ontology-first AI architecture](https://atlan.com/know/ontology-first-ai-architecture/) guide. The W3C draws one boundary itself: "OWL 2 is not a schema language for syntax conformance" ([OWL 2 Primer, W3C, 2012](https://www.w3.org/TR/owl2-primer/)). Checking that records are well formed stays the data model's job. In a 2002 SIGMOD Record paper, Spyns, Meersman and Jarrar argued that "unlike data models, the fundamental asset of ontologies is their relative independence of particular applications" ([Spyns et al., 2002](https://doi.org/10.1145/637411.637413)). Every agent is a new application that never sat in the design meeting. Three questions show where a physical schema runs out: | Question an agent has to answer | What a data model says | What an ontology says | Spec | |---|---|---|---| | No row matched. Is the answer "none" or "we don't know"? | A query reads an absent row as not true. `NULL` marks an unknown value, but nothing marks an unknown row | Under OWL semantics the fact may be missing but true; a reasoner will not conclude "none" unless something closes the world | [OWL 2 Primer](https://www.w3.org/TR/owl2-primer/) | | Is `cust_id` 4471 in billing the same customer as `account_no` A-4471 in the CRM? | Nothing, unless someone maintains a crosswalk or master record | Yes, once someone asserts it (`owl:sameAs`), and every mapped system can reuse that assertion | [OWL 2 Primer](https://www.w3.org/TR/owl2-primer/), [RDF 1.1](https://www.w3.org/TR/rdf11-concepts/) | | Every `Customer` has an account owner. Does that hold for an `EnterpriseCustomer`? | Only if a subtype table, view or code carries it | Yes. A subclass axiom lets a reasoner infer that every enterprise customer is a customer, so rules stated for customers apply | [OWL 2 Primer](https://www.w3.org/TR/owl2-primer/) | The identity row rests on one line of the RDF standard: "By design, IRIs have global scope" ([RDF 1.1 Concepts, W3C, 2014](https://www.w3.org/TR/rdf11-concepts/)). The [RDF 1.2 Concepts](https://www.w3.org/TR/rdf12-concepts/) Candidate Recommendation (April 2026) keeps the same sentence. The ontology records the match. A person or an entity-resolution step still has to decide that 4471 and A-4471 are one customer. The Primer adds a caution: "OWL does not make the assumption that different names are names for different individuals." So OWL will not assume two IRIs name two different customers unless you say so. Related: [is an ontology just another word for a semantic model](https://atlan.com/know/ai-agent/ontology/is-an-ontology-just-another-word-for-a-semantic-model/) and [what is a knowledge graph](https://atlan.com/know/what-is-a-knowledge-graph/). --- ## What is a data model? A data model is the structure a system uses to store, relate and validate records: entities, attributes, and the keys and constraints that hold them together. It comes in three levels. The conceptual model names business entities, the logical model adds attributes and relationships, and the physical model is the DDL a database runs. The full method lives in [what is data modeling](https://atlan.com/what-is-data-modeling/). Its guarantee is enforcement. A `NOT NULL`, a foreign key and a `CHECK` constraint are promises the database keeps on every write. [Data contracts for AI](https://atlan.com/know/ai-agent/data-for-ai/data-contracts-for-ai/) extend those promises across teams, so a producer cannot quietly break what a consumer depends on. Conceptual models and supertype/subtype patterns do carry meaning. The limit is where that meaning lives: diagrams, column names, comments and the heads of the people who built the tables. It is scoped to one application, and a machine cannot read it as rules. [Data lineage for AI](https://atlan.com/know/ai-agent/data-for-ai/data-lineage-for-ai/) can show where a column came from. It cannot tell an agent what `is_active` was meant to capture. ### Core components of a data model - Entities or tables, such as `orders` and `customers`. - Attributes: `order_total DECIMAL(12,2)`, `created_at TIMESTAMP`. - Primary and foreign keys. - Constraints such as `NOT NULL`, `UNIQUE` and `CHECK`. - Grain and cardinality: one row per order line, one customer to many orders. --- ## What is an ontology? An ontology is a formal, shared vocabulary of a domain's concepts, the relationships between them, and the axioms that let a machine infer new facts from stated ones. The W3C definition: "Ontologies are formalized vocabularies of terms, often covering a specific domain and shared by a community of users" ([OWL 2 Overview, W3C, 2012](https://www.w3.org/TR/owl2-overview/)). A longer walk-through sits in [ontology explained](https://atlan.com/know/ontology-101-explainer/). Its purpose is to state what a schema leaves implied. Noy and McGuinness list "To make domain assumptions explicit" among the reasons to build one, in [Ontology Development 101 (Stanford)](https://protege.stanford.edu/publications/ontology_development/ontology101-noy-mcguinness.html). It holds no rows and blocks no writes. The standards around it are covered in [ontology in AI](https://atlan.com/know/what-is-ontology-in-ai/). The individuals it describes live in a graph or stay in the source tables. When that graph changes continuously, read [context graph vs ontology](https://atlan.com/know/context-graph-vs-ontology/). ### Core components of an ontology - Classes, such as `Customer` and `EnterpriseCustomer`. - Object properties (`placedBy`) and data properties (`signupDate`). - Individuals: customer 4471, order 88120. - Axioms a reasoner can apply: subclass, equivalence, transitivity, cardinality. - IRIs, global identifiers. --- ## Ontology vs data model: head-to-head comparison The summary table covers definition, world assumption, identity and scope. These are the operational differences. | Dimension | Data model | Ontology | |---|---|---| | Validation | Enforced at write time by the database | Checked when a graph is validated against SHACL shapes; validation produces a report and blocks no write | | Inference | Not native; views, recursive queries and rules engines approximate it | Subclass, equivalence and transitivity axioms derive new facts through a reasoner | | Change cost | Migrations touch storage and pipelines | New classes need no data movement, but every mapping must be updated when a source schema changes | | Query performance | What relational engines are built and tuned for | Depends on materializing the graph or translating queries back to SQL, both with real cost | | Failure mode | Agents guess meaning from column names | Over-scoped models nobody maintains | ### A worked example: three systems, one customer An agent is asked: "Which active enterprise customers have no open support tickets?" Billing keys customers by `cust_id`. The CRM keys them by `account_no`. Support tickets carry `org_ref`. Each data model is correct, and the agent still fails three ways. 1. **Identity.** Nothing says the three keys name one customer. A crosswalk from master data management, entity resolution or a steward fixes it. An ontology gives that decision a shared, durable form. 2. **Meaning.** `is_active` means "paid an invoice in 90 days" in billing and "has an open opportunity" in the CRM. Here the ontology earns its place: it can name both and say which one the question means. 3. **Freshness.** An empty ticket join reads as "no tickets" when the support feed simply lagged by a day. Nothing in OWL knows a pipeline is late. That signal comes from freshness and data-quality metadata on the source. Written in W3C syntax, the hierarchy, the identity decision and a completeness check fit in a few lines of Turtle: ```turtle @prefix rdfs: . @prefix owl: . @prefix sh: . @prefix ex: . ex:EnterpriseCustomer rdfs:subClassOf ex:Customer . ex:billing-4471 owl:sameAs ex:crm-A-4471 . ex:CustomerShape a sh:NodeShape ; sh:targetClass ex:Customer ; sh:property [ sh:path ex:billingId ; sh:minCount 1 ; sh:maxCount 1 ] . ``` The `owl:sameAs` line records a match someone else resolved, through an MDM crosswalk or a steward. The subclass line is the [OWL 2 Primer](https://www.w3.org/TR/owl2-primer/)'s own pattern, and the shape uses SHACL Core terms from the [SHACL Recommendation](https://www.w3.org/TR/shacl/). Correct SQL over the wrong meaning is a common way [text-to-SQL breaks](https://atlan.com/know/ai-agent/data-for-ai/text-to-sql-with-ai/). The missing piece is [business context for AI](https://atlan.com/know/business-context-for-ai/). --- ## When do you need a data model, an ontology, or both? ### What a data model plus a semantic layer and master data already covers The strongest alternative to an ontology is a full stack: a dimensional model with conformed dimensions, a master-data golden record, a [semantic layer](https://atlan.com/know/semantic-layer/) that declares entities, join paths and governed metrics, and a glossary with column descriptions. Run the worked example through that stack. The golden record resolves the three keys, a governed `active_customer` metric settles which `is_active` counts, and freshness checks flag the late feed. Many teams can stop here, and should. What it lacks: rules that propagate through a class hierarchy across domains, one identifier scheme every tool can reuse, and definitions that survive when the semantic model holding them is replaced. Where that line falls is the subject of [context layer vs semantic layer](https://atlan.com/know/context-layer-vs-semantic-layer/). | If this is true of your situation | Data model is enough | Data model + semantic layer / MDM is enough | Add an ontology | |---|---|---|---| | Questions are fixed and known at design time (dashboards, reports) | | | | | You need write-time integrity, performance and transactions | (always) | | | | Agents answer a known set of governed metrics in one domain | | | | | The same entity appears under different keys, and one team owns the crosswalk | | | | | Rules must apply through a hierarchy (subtypes, part-of, reports-to) across domains | | | | | Agents cross domains where no single semantic model owns the definitions | | | | | Several teams or tools must share one identifier and one definition of a concept | | | | ### Reasoner now, or later? You can declare entities, relationships, identity and certified definitions without adopting formal OWL on day one. That fixes the identity and meaning failures in the worked example. It does not give you "none versus unknown" for free: the open-world reading belongs to OWL semantics, which a reasoner applies. A plain query over mapped data still returns an empty result the agent must interpret. The cheaper fix is usually a completeness declaration (this source is complete for tickets as of its last load), checked by a SHACL shape or a freshness rule. Add a reasoner when cross-domain hierarchy inference is the real requirement. An [active ontology](https://atlan.com/know/what-is-active-ontology/) stays current as systems change, and an [operational ontology](https://atlan.com/know/ai-agent/ontology/what-is-an-operational-ontology/) serves agents that act. Layering both models is what a [context layer](https://atlan.com/know/what-is-context-layer/) does. Assembling what each agent sees is [context engineering](https://atlan.com/know/what-is-context-engineering/), and the build sequence is in [implementing an enterprise context layer for AI](https://atlan.com/know/how-to-implement-enterprise-context-layer-for-ai/). --- ## How do ontologies and data models work together? You keep the data model and layer the ontology over it. The W3C standardizes both the mapping and the validation. ### Map the schema instead of migrating it R2RML is "a language for expressing customized mappings from relational databases to RDF datasets" ([R2RML Recommendation, W3C, 2012](https://www.w3.org/TR/r2rml/)). The mapping states which rows are instances of which class, and a template turns each row's key into an IRI. The source tables stay in place. The spec calls the mapping conceptual: processors are free to materialize the output as a copy or to offer virtual access to the database. A copy is a second store to sync; virtual access pays in query translation. One thing a template cannot do is merge `cust_id`, `account_no` and `org_ref` into one IRI. Each table mints its own. Joining them needs the crosswalk from the worked example, mapped in as its own table or asserted as `owl:sameAs` links. ### Check completeness with SHACL SHACL is "a language for validating RDF graphs against a set of conditions" ([SHACL Recommendation, W3C, 2017](https://www.w3.org/TR/shacl/)). The 2017 Recommendation is the current standard; [SHACL 1.2 Core](https://www.w3.org/TR/shacl12-core/) was a Working Draft as of 30 October 2026. The shape in the example requires every `Customer` to have exactly one billing identifier: the rule a `NOT NULL` expresses, checked when the graph is validated rather than enforced on each write. A pipeline decides what happens to failures. ### Mine the first draft from the model you already run SQL history, BI logic and lineage show which entities people actually join. [Context mining for AI](https://atlan.com/know/ai-agent/context-engineering/context-mining-for-ai/) and [SQL intelligence](https://atlan.com/know/ai-agent/data-for-ai/what-is-sql-intelligence/) read those signals. Mining proposes candidate entities and relationships. It cannot recover the two meanings of `is_active`; domain experts supply those. The candidates land in a [metadata knowledge graph](https://atlan.com/know/metadata-knowledge-graph/), so review starts from a draft instead of a blank page. See [designing an ontology for AI without boiling the ocean](https://atlan.com/know/ai-agent/ontology/ontology-design-for-ai/) and [extending an ontology beyond the warehouse](https://atlan.com/know/ai-agent/ontology/extending-ontology-beyond-snowflake/). --- ## Why do AI agents need more than a data model? The most cited evidence is a benchmark by Juan Sequeda, Dean Allemang and Bryon Jacob. All three listed a data catalog vendor built on knowledge graphs as their affiliation, so the study is not independent. On one insurance-domain schema and 43 questions, GPT-4 with zero-shot prompts directly on the SQL database scored 16%, rising to 54% "when questions are posed over a Knowledge Graph representation" of the same database, queried in SPARQL ([arXiv 2311.07509](https://arxiv.org/abs/2311.07509)). That representation bundled an ontology, mappings back to the tables, and a different query language. The test did not separate those effects, and 54% still leaves nearly half the answers wrong. Atlan's own study is first-party, so weigh it as such. In Atlan's [research report](https://atlan.com/resources/metadata-research-report/), rich semantic metadata improved the accuracy of AI-generated SQL by 38%, across 522 evaluations of 174 queries. The enriched context added business glossaries, SQL usage patterns and domain hints to the schema ([Atlan AI Labs](https://atlan.com/know/enhanced-metadata-improves-query-accuracy/)). Neither study measures formal OWL reasoning; both support making meaning explicit. Reading an empty result as "none" and joining keys that name different things are common causes of [AI agent hallucination](https://atlan.com/know/ai-agent-hallucination/). They are also why [text-to-SQL for enterprise](https://atlan.com/know/ai-agent/data-for-ai/text-to-sql-for-enterprise/) needs more than a schema dump. A [knowledge graph for AI agents](https://atlan.com/know/ai-agent/knowledge-graph-for-ai-agents/) supplies identity and relationships; a [semantic layer for AI agents](https://atlan.com/know/ai-agent/semantic-layer-for-ai-agents/) supplies governed metric logic. In this episode, Jessica Talisman joins Atlan to discuss what changed for ontology work with AI: --- ## What goes wrong when teams confuse an ontology with a data model? | Mistake | What breaks | What to do instead | |---|---|---| | Calling a glossary or taxonomy an ontology | No axioms, so nothing can be inferred; "SKOS is not a formal knowledge representation language" ([SKOS Reference](https://www.w3.org/TR/skos-reference/)) | Keep the glossary; add classes, relationships and identity when a use case needs them | | Building the ontology as a second schema | Two storage models drift; OWL is not a schema language for syntax conformance | Map the existing model with R2RML, check it with SHACL | | Modeling the whole enterprise first | Months of design, no agent in production | Scope by the questions agents must answer this quarter | | Expecting the ontology to resolve identity | Two keys stay two customers, or get merged wrongly | Resolve matches in MDM or with stewards; record the result | | Letting agents read an empty join as "none" | Confident wrong answers | Declare which sources are complete, and how fresh | Graph-side failures are covered in [enterprise knowledge graph pitfalls](https://atlan.com/know/ai-agent/knowledge-graph/enterprise-knowledge-graph-pitfalls/). --- ## How Atlan connects ontologies and data models in the context layer Atlan's Context Layer for AI keeps declared meaning next to the data models it describes, mined from what you already run and certified by your experts. - **Context Agents** mine candidate metric definitions, relationships and linked data assets from SQL history, BI semantic logic, lineage and usage. Your existing data model is the starting material. - In [**Context Engineering Studio**](https://atlan.com/context-engineering-studio/), AI drafts candidate context and domain experts review it, resolve conflicts and approve what goes to production. The output ships as a versioned Context Repo. - The [Enterprise Data Graph](https://atlan.com/know/enterprise-data-graph/) records what data exists, what it means and how it connects. The [Atlan MCP server](https://atlan.com/know/what-is-atlan-mcp/) lets agents access governed data definitions and glossaries and traverse end-to-end lineage at runtime ([documentation](https://docs.atlan.com/product/capabilities/atlan-ai/how-tos/remote-mcp-overview)). The mechanics are in [how MCP delivers business context](https://atlan.com/know/mcp-delivers-business-context/). The MCP documentation describes governed metadata reaching agents; it does not describe OWL or RDF import or export. Teams that need an OWL reasoner run one in dedicated OWL tooling. Certified definitions become part of a [context graph](https://atlan.com/know/what-is-a-context-graph/) agents read when they answer. The wider picture is in [the enterprise context layer](https://atlan.com/know/what-is-the-enterprise-context-layer/). --- ## Real stories from real customers: Shared language your agents can read Two customers on shared language and lineage AI can use. "Atlan captures Workday's shared language to be leveraged by AI via its MCP server. As part of Atlan's AI labs, we're co-building the semantic layer that AI needs." - Joe DosSantos, VP, Enterprise Data and Analytics, Workday "Context is the differentiator. Atlan gave our teams the shared vocabulary and lineage to move from reactive data management to proactive AI enablement." - Kiran Panja, Managing Director, Cloud and Data Engineering, CME Group --- ## What does your agent need to know that your schema doesn't say? Keep the data model for storage, integrity and speed. Check how far a semantic layer and master data get you. Add an ontology when meaning crosses domains no single model owns, or rules must flow through a hierarchy. Then test your agent. Does it know when an empty result means "none"? Can it tell that two keys name one customer, and who decided that? Does a rule about customers reach your enterprise accounts? The one it fails first is where your [AI-ready data](https://atlan.com/know/ai-agent/data-for-ai/what-makes-data-ai-ready/) work starts. --- ## FAQs about ontology vs data model ### 1. Is an ontology a data model? Not in the database sense. The W3C states that OWL 2 is not a schema language for syntax conformance. An ontology models shared meaning, a data model models storage, and an ontology can serve as the conceptual model several schemas map to. ### 2. What is the difference between an ontology and a database schema? A query over a schema reads an absent row as not true; OWL treats a missing fact as possibly true. Schema keys are local, while IRIs have global scope. A schema derives facts through queries and views someone writes. An ontology declares axioms a reasoner applies to mapped data. ### 3. When should you use an ontology instead of a data model? Alongside a data model, never instead of one. Add it when meaning crosses domains no single semantic model owns, or rules flow through a hierarchy. For known metrics in one domain, a semantic layer usually suffices. ### 4. Can a relational database be an ontology? No, but it can be mapped into one. The W3C R2RML standard expresses mappings from relational tables to RDF, so rows become instances of ontology classes and keys become IRIs. The source tables stay in place; the RDF view can be queried virtually or materialized. ### 5. Is a business glossary or taxonomy an ontology? No. A glossary defines terms and a taxonomy arranges them in a hierarchy. The W3C notes that SKOS, its standard for thesauri, classification schemes and taxonomies, is not a formal knowledge representation language. An ontology adds typed relationships, identity and axioms. ### 6. Do AI agents or LLMs need an ontology? They need explicit meaning. In a 2023 vendor-authored benchmark of 43 enterprise questions, GPT-4 scored 16% over raw SQL and 54% over a knowledge graph built with an ontology and mappings. The test did not isolate the ontology. ### 7. Can you build an ontology from an existing data model? You can draft one. Schemas, SQL history, BI logic and lineage suggest candidate entities and relationships; domain experts supply the meanings the tables do not hold and certify the result. ### 8. How does Atlan relate ontologies to data models? Atlan mines candidate definitions and relationships from your data models, SQL history and BI logic. Experts approve them in Context Engineering Studio, and the Atlan MCP server gives agents governed definitions, glossary terms and lineage at runtime. --- ## Sources 1. [OWL 2 Web Ontology Language Document Overview (Second Edition), W3C Recommendation, 11 December 2012](https://www.w3.org/TR/owl2-overview/) 2. [OWL 2 Web Ontology Language Primer (Second Edition), W3C Recommendation, 11 December 2012](https://www.w3.org/TR/owl2-primer/) 3. [RDF 1.1 Concepts and Abstract Syntax, W3C Recommendation, 25 February 2014](https://www.w3.org/TR/rdf11-concepts/) 4. [R2RML: RDB to RDF Mapping Language, W3C Recommendation, 27 September 2012](https://www.w3.org/TR/r2rml/) 5. [SHACL Shapes Constraint Language, W3C Recommendation, 20 July 2017](https://www.w3.org/TR/shacl/) 6. [SKOS Simple Knowledge Organization System Reference, W3C Recommendation, 18 August 2009](https://www.w3.org/TR/skos-reference/) 7. [Ontology Development 101: A Guide to Creating Your First Ontology, Natalya F. Noy and Deborah L. McGuinness, Stanford University](https://protege.stanford.edu/publications/ontology_development/ontology101-noy-mcguinness.html) 8. [A Benchmark to Understand the Role of Knowledge Graphs on Large Language Model's Accuracy for Question Answering on Enterprise SQL Databases, Juan Sequeda, Dean Allemang and Bryon Jacob, arXiv:2311.07509, 2023](https://arxiv.org/abs/2311.07509) 9. [Data modelling versus ontology engineering, Peter Spyns, Robert Meersman and Mustafa Jarrar, SIGMOD Record 31(4), 2002](https://doi.org/10.1145/637411.637413) 10. [Metadata: The Critical Foundation for AI Agents & Natural Language to SQL Use Cases, Atlan research report (first-party)](https://atlan.com/resources/metadata-research-report/) 11. [How We Proved Metadata Delivers 38% Better AI Accuracy, Atlan AI Labs (first-party)](https://atlan.com/know/enhanced-metadata-improves-query-accuracy/) 12. [Set up Atlan MCP, Atlan documentation (accessed 2026-11-01)](https://docs.atlan.com/product/capabilities/atlan-ai/how-tos/remote-mcp-overview) 13. [Context Engineering Studio, Atlan product page (accessed 2026-11-01)](https://atlan.com/context-engineering-studio/) 14. [RDF 1.2 Concepts and Abstract Syntax, W3C Candidate Recommendation Snapshot, 7 April 2026](https://www.w3.org/TR/rdf12-concepts/) 15. [SHACL 1.2 Core, W3C Working Draft, 30 October 2026](https://www.w3.org/TR/shacl12-core/)