A closer look at why AI agents need executable ontological semantics, and how the Open Semantic Interchange makes that meaning portable between modeling languages.
At Snowflake Summit 2026, I joined my colleague Kurt Stirewalt and Snowflake's Josh Klahr for a session - Open Semantic Interchange: Dimensions & Ontologies for Agents - to share how OSI is growing beyond its dimensional roots to carry the ontological semantics that AI agents need. The most useful part wasn't the talk itself; it was the conversations it sparked, in the room and in the hallways afterward. One question kept resurfacing, and with it, a persistent misconception. Those discussions are what prompted this post.
When people hear "OSI now supports ontologies," many assume we've added yet another modeling language to an already crowded field. We haven't. OSI is not a new semantic language. It's an interchange format. That distinction is the whole point, and it's worth unpacking, along with what ontological semantics actually add and why agents need them in the first place.
Think of OSI the way you'd think of any interchange format: not as a competitor to the languages you already use, but as the thing that lets them understand one another. The enterprise semantic world is full of capable modeling languages: RDF/OWL, labeled property graphs, Object-Role Modeling, Goldman Sachs Legend, Palantir's object model, and RelationalAI's relational knowledge graphs at the conceptual level, plus dbt MetricFlow, Cube, Looker, AtScale and many others at the logical level. OSI's job is not to replace any of them. Its job is to make their meaning portable.
It does this with a deliberately small core set of three composable primitives. Concepts (entity types and value types), relationships (declared with roles, multiplicity, and natural-language verbalization, including those beyond simple binary links), and relational expressions (derivation rules, requirements, and the mappings that bridge the conceptual model to the logical one). These primitives are optional and composable, so a team can adopt them incrementally without breaking changes. And the format is designed as a superset of what those underlying languages can express: which is exactly what makes bi-directional translation, or transpilation, possible. An RDF/OWL or Palantir model can be transpiled into OSI, moved across tools, and transpiled back out with its mappings and bindings preserved.
A language is where you author meaning. An interchange format is how that meaning travels. OSI is the latter.
If every ontology language were equivalent, you wouldn't need an interchange format at all. But they aren't. The conceptual layer is genuinely fragmented, and the languages that live there differ in ways that matter for AI: how much they can express, whether they support relationships beyond simple binary links, whether their constraints are enforceable or merely documented, and how (or whether) their semantics can be executed.
These aren't academic distinctions. A language that can only express binary relationships strains to capture a fact that is inherently three-way; one whose constraints are documentation rather than enforced rules can't stop an agent from acting on an invalid combination; one that can't execute its own semantics leaves the reasoning to be reconstructed elsewhere. Because there has been no standard for representing the logical and conceptual layers together (and no standard mapping between them) enterprises have been left stitching brittle point-to-point integrations and risking their hard-won semantics being trapped inside a single vendor's proprietary format. That is the total-cost-of-ownership and lock-in problem OSI exists to solve. Define your meaning once; use it everywhere.
Most enterprises have been climbing a ladder of semantics, and most are trying to get higher on it.
Dimensional semantics, the rung most enterprises have reached, are excellent at one thing: telling you what happened. Revenue last quarter by region. Churn this month. A dashboard can render "revenue by region = SUM(amount) GROUP BY region," and that's enough to draw a chart.
It is not enough for an agent to act. Dimensional models describe aggregations; they don't describe the world. Ask an agent a question that crosses relationships between two concepts such as: "if our Tier-2 supplier in Shenzhen goes offline next month, which finished goods and customer commitments are exposed?", and a dimensional model hits its limits. It can roll up shipments by region or aggregate spend by supplier, but it can't tell you what a Tier-2 supplier actually is, which vendors qualify, or how to traverse the chain (supplier → parts → sub-assemblies → finished goods → orders → customers) to assemble an answer that spans multiple hops across relationships. Ontologies capture precisely that missing layer of meaning: entity identity (what makes a vendor a Tier-2 supplier, not just a row in a table), relationships with roles and multiplicity (which parts go into which assemblies, who fulfills which orders), and constraints (which values are valid, which combinations are impossible).
Consider a Trade. In a dimensional model, a trade is a row in a fact table with an ID, an amount, a timestamp, an account. Accurate, and useful for aggregation, but incomplete. In the business, a Trade is an entity that must be executed by exactly one Account, not zero, not two. An EquityTrade is a specific kind of Trade with its own constraints, such as requiring a counterparty and a settlement date. Those rules exist somewhere, possibly in a trading application, a compliance document, or even a senior engineer's head, but not in a form an agent can use. An ontology puts them in exactly that form.
Ontologies model business meaning, not just data structure, giving agents the precise, conflict-free vocabulary they need to act with confidence rather than guess.
An agent with only dimensional semantics will still answer the revenue question, but it will quietly make assumptions about every edge case: what "exposed" means, where the supplier chain stops, whether an EquityTrade missing a counterparty should count. In domains like finance the edge cases are where the risk lives. An agent grounded in an ontology can recognize that a question is under-specified and say so, rather than return a confident answer built on an assumption no one sanctioned. That isn't the agent being unhelpful. That's the agent being trustworthy.
Capturing meaning is only half the story; the other half is what you can do with it. With executable dimensional semantics you get retrieval, filtering, and aggregation: the work an agent can hand off to a SQL engine. That covers "what happened." It doesn't cover what's true, what's connected, what's likely, and what to do about it. Those questions need reasoning that sits beyond SQL, and an executable ontology is what makes it possible:
This is the jump from the analytics to genuine decision intelligence: agents that reason, act, and execute workflows rather than just return rows. As we argued in Beyond Context: Closing the AI Value Gap, context tells an agent what the world looks like, but it's the right tools (reasoners for rules, graphs, prediction, and optimization) that tell it what to do. It's also the work RelationalAI's reasoners perform directly on your data inside Snowflake, over a relational knowledge graph, without moving anything.
The shape of the argument is simple. Ontologies capture the meaning that dimensions leave out. That meaning unlocks reasoning SQL can't do. And OSI, as an interchange format rather than a new language, is what lets that meaning move freely across the tools and platforms an enterprise already runs, without lock-in and without rebuilding it for every system. Define your semantics once, and every dashboard and every decision agent in your stack can mean the same thing by them.
This builds on the standard we launched with a coalition of industry leaders last fall, and the ontological extension that OSI community, with RelationalAI leading the OSI Ontology Representation Working Group, shipped this spring. The work is open, community-governed, and owned by neither Snowflake nor RelationalAI.
Join the OSI community. The ontology representation working group is actively seeking input from data leaders, semantic practitioners, and platform teams. Learn more at open-semantic-interchange.org, and explore the spec and reference implementations on GitHub.
Talk to RelationalAI. If you're building decision agents on top of your data cloud, and want to put RelationalAI’s ontological semantics and advanced reasoning to work, get in touch.
Related reading
Start building with the Rel API, install the native app inside Snowflake, or get in touch about access to our ready-to-use Rel experience.
Rel is a decision agent aligned to your business, grounded in your semantic model, and powered by the advanced reasoners of the RelationalAI decision intelligence platform.
©2026 RelationalAI. All rights reserved.
