Ontologies are on the rise again, expected to solve data access challenges for artificial intelligence (AI) agents by making organizational knowledge structured and usable. Together with knowledge graphs and labeled property graphs, they form a triad in semantic modeling. However, while ontologies define schema and rules, and graphs represent relationships, many implementations remain overly complex and see limited practical adoption.
In the context of AI, however, these concepts are often reinvented with excessive complexity. Significant effort has gone into building sophisticated graph-based models using technologies such as web ontology language (OWL), resource description framework (RDF), and SPARQL (SPARQL protocol and RDF query language). While academically rigorous, these approaches have seen limited practical adoption beyond specialized domains. Notable exceptions are product lifecycle management (PLM), advanced CAD modelling or Zalando’s fashion knowledge graph.
Pragmatic ontology takes a different, less academic approach. It focuses on delivering a semantic layer that works reliably across most real-world enterprise scenarios and supports both AI agents and human users.
It does this without adding unnecessary theoretical or technical overhead, while still representing the connectedness, relationships, and meaning within the data. In this way, it enables ontology-augmented generation (OAG) in a simple and efficient manner.
Pragmatic ontology can be achieved through six principles.
Relational databases remain the backbone of enterprise IT. With few exceptions for specialized use cases, most operational systems are built on relational technology.
Pragmatic ontology builds on established enterprise IT by using object-relational principles instead of graph databases or RDF stores. While some multi-hop queries are less straightforward, this approach enables faster implementation, clearer structures, and better alignment with existing architectures. Modern object-relational technologies also support advanced data types such as semantic embeddings. In practice, the practical benefits outweigh the theoretical limitations.
How does NoSQL fit into the picture? It can serve as a flexible middle ground, but with limitations. While we delivered value using NoSQL databases and enterprise search engines, issues such as joins made them less attractive at scale for connected-data workloads. Schema constraints also tend to emerge over time through business logic, reducing NoSQL’s flexibility advantage. As a result, we see limited long-term benefit in this approach.
A semantic layer must not be reserved for AI agents. Pragmatic ontology is designed to be directly accessible to analysts, engineers, and business users alike. It forms the same foundation on which dashboards, reports, and applications are built. Objects, relationships, and definitions are transparent, explorable, and navigable. This ensures a shared understanding between AI agents and human stakeholders, reducing ambiguity and improving trust in automated reasoning.
Pragmatic ontology is not another data lake and does not physically centralize data. Instead, it virtualizes data across distributed systems, recognizing that no single platform serves all purposes. Data remains in operational systems, transactional databases, existing lakes, lakehouses, warehouses, and data meshes. The ontology spans these sources to provide a unified semantic view without necessarily copying data. This enables incremental adoption and data writebacks, as many agentic workloads are OLTP-driven. Caching or materialization is used only when needed for analytics, avoiding overload of source systems and following a CQRS-like pattern.
Pragmatic ontology serves as an operational and actionable semantic layer, not just a descriptive inventory. While data catalogs focus on documenting datasets, schemas, lineage, and ownership, pragmatic ontology defines domain objects and relationships that are directly usable by both humans and AI agents at runtime.
Object relationships are described in natural language rather than formal class hierarchies. The goal is clarity and usability, not theoretical completeness. We also recognize that enterprise reality is complex and cannot always be modeled neatly within one fully coherent framework.
Deep and complex inheritance structures are deliberately avoided, because extensive class hierarchies are hard to design and maintain. In AI systems, large language models (LLMs) already capture substantial semantic knowledge through pretraining, making explicit hierarchy modeling unnecessary in many practical cases. Expressing semantics in natural language keeps pragmatic ontology understandable to humans and interpretable by AI.
Pragmatic ontology does not attempt to create a single, universal enterprise data model. Large, monolithic entity-relationship (ER) models that aim to unify everything have consistently proven unmanageable. Instead, it follows a domain-driven approach: independent models are created for specific domains and purposes, and these models coexist without being forced into a unified framework.
Pragmatic ontology evolves incrementally. It is built as a foundation for concrete use cases rather than abstract completeness. New objects, relationships, and definitions are added as needed. This additive approach ensures rapid value delivery while maintaining architectural coherence. Over time, the semantic layer grows organically, guided by real requirements, validated by application, and continuously aligned with both human and AI needs. It is not a big-bang, multi-year IT project, but delivers value incrementally and continually. And yes, while this might seem a bit messy, in our experience, a bit of healthy chaos is the differentiator that drives these use cases to success.
A possible architecture for these principles can be implemented using a five-layer approach, although other realizations are also possible. In this layered model, the architecture consists of five layers from top to bottom: L1 - Interaction layer, L2 - Semantic access layer, L3 - Core ontology layer, L4 - Execution layer, and L5 - Source layer.
This layer is primarily directed at human users interacting with the system. This includes business intelligence tools, applications, notebooks, and importantly standardized graphical, human-explorable views on the linked objects (Strictly speaking, this layer might be considered external to the ontology).
This layer serves as the controlled entry point or API layer into the system. It exposes data and operations through familiar interfaces such as SQL, REST, GraphQL, and MCP. This layer is responsible for enforcement concerns such as authorization, policy checks, and rate limiting, ensuring access is safe and governed. Writebacks happen primarily through MCP servers or SQL queries.
This is where business meaning lives. It defines domain objects (for example: customers, orders, or incidents), captures relationships in natural language, maps those concepts to underlying source systems, and defines how writes and updates should behave. This layer translates between human or AI intent and technical execution.
This is the virtualization and execution layer, which focuses on how requests are actually run. It handles query federation across multiple systems, applies patterns such as CQRS, caching, and materialization for performance, and routes transactions appropriately depending on the operation and data source.
At the bottom lie the source systems themselves. These include operational (OLTP) systems, analytical warehouses or data lakes, and external SaaS APIs, including REST (Again, strictly speaking, this layer might be considered external to the ontology).
Overall, the flow is bidirectional: requests move downward from humans and AI agents to source systems, while data and results flow back up.
In summary, pragmatic ontology is a practical, object-relational semantic layer designed for both AI agents and humans. It accepts trade-offs in favor of usability, speed, and operational fit. Rather than relying on complex graph-based models, centralized data stores, or monolithic enterprise models, it virtualizes distributed data across existing systems and expresses relationships in natural language. Its domain-driven, use-case-focused models evolve incrementally, enabling faster adoption and real-world value.
This approach does not aim to be theoretically perfect, nor does it cover every edge case. Graph-based ontologies can be successful in specific contexts, and there is no one-size-fits-all solution. However, by aligning with how enterprise IT systems already operate and leveraging the semantic capabilities of large language models, pragmatic ontology provides a scalable, understandable, and workable foundation for enterprise semantics. In practice, a degree of controlled imperfection—or healthy chaos—can be a key differentiator for successful implementation.
