A Semantic Layer Unifies Discovery, Not Definitions
A semantic layer makes governed metrics findable and executable across tools and agents, but it does not settle what a term means. Here is what it unifies, who owns definitions, and how to test whether yours works.
Introduction
A semantic layer's real contribution is that governed metrics become findable and executable the same way across tools and agents. It does not resolve the organizational argument about what a term should mean.
That distinction matters because the argument is the bottleneck. In an A-Team Group webinar survey of capital-markets participants, none reported a fully implemented semantic layer and 44% said they were still exploring the technology. The panel's diagnosis was that the primary hurdle is non-technical: achieving consensus across business units on core definitions. Unresolved divergence has a running cost — reconciliation work before meetings, parallel reports built for self-protection, and, once agents query the estate, answers computed from whichever definition the agent happened to find.
What follows separates the two problems. First, what the layer actually unifies. Second, who owns definitions and how that ownership is governed. Third, a decision rule for core versus scoped variants. Fourth, how to test whether the layer is working.
The Claim: Unification of Discovery, Not Settlement of Meaning
A semantic layer sits between source data and the systems that consume it, abstracting physical structures — tables, joins, column names — into business vocabulary. Databricks describes the mechanism concretely: a column like fact_subscriptions.bookings_amount becomes a governed metric called "ARR Run-Rate," complete with calculation logic, the filters that define it (active contracts only, specific date windows), the joins that enrich it, and the security policies that restrict who sees what.
That is a real achievement, and it is narrower than it sounds. What the layer delivers is one place where a metric is found and executed the same way whether the request arrives from a dashboard, a notebook, or an agent. What it does not deliver is agreement.
Alation states the limit directly: the configs and join logic are the part a semantic layer handles well, while definitional turf wars, shadow analytics, and the incentive structures that keep teams siloed are organizational, and "no config file resolves it." If two VPs each have a reason to prefer their own revenue number, no YAML file settles that argument.
The practical consequence is worth stating precisely. The layer converts a recurring meeting into a versioned artifact. That is progress — the decision becomes inspectable, changeable, and attributable. But the artifact still encodes someone's decision, and the quality of that decision is not a property of the software.
What the Layer Actually Unifies
To scope expectations, it helps to inventory what actually gets unified.
dbt Labs' 2026 benchmark compared text-to-SQL against its Semantic Layer on a modeled project. The gap is modest on the full question set; the authors note that text-to-SQL was given the entire schema as context, which they describe as impractical at larger scale. Vendor-published, single-project result — validate against your own schema.
Calculation logic and join paths. Metric definitions, filters, and relationships are declared once and reused. Databricks makes the architectural point: join logic becomes a durable part of the semantic model rather than an ad hoc query fragment re-coded by every analyst. The alternative is the pattern most multi-tool organizations recognize — DAX in Power BI, LookML in Looker, VizQL in Tableau, each a capable language inside its own boundary, and definitions diverging the moment an organization runs more than one.
Execution consistency across consuming surfaces. The same metric returns the same result regardless of which client asks. This is the core of the value case, and it is testable in a way that most data investments are not.
Governance metadata that travels with the metric. Ownership, descriptions, certification status, tags, synonyms, lineage, and row-level or column-level policies attach to the asset rather than being recreated per tool. Databricks frames the consequence as governance becoming enforcement by construction: a row-level policy set on source data applies when a metric view is queried from a dashboard or a natural language interface.
The interface agents query through. Certified measures, dimensions, joins, and time behavior become the menu an agent selects from rather than a schema it improvises against.
On the accuracy question, dbt Labs' 2026 benchmark reports that for Semantic Layer queries it "barely matters" which model or reasoning effort is used — most models hit 100% or near it. Treat that as a vendor-published benchmark on a modeled project, and validate it against your own schema before relying on the number.
The more durable claim from that work is about failure modes. With text-to-SQL, failure looks like a plausible but incorrect answer. With a semantic layer, failure looks like an error message. For anything headed to a board deck, an auditor, or a customer, visible failure beats invisible error.
What It Leaves Unresolved
Three things remain outside what the layer can settle.
Which definition is authoritative. The layer can hold one definition and execute it consistently. Choosing it is a decision with an owner, not a configuration step. Databricks is candid that the initial modeling investment requires collaboration among data engineers, analysts, and business stakeholders "who may not initially agree on definitions" — and frames that friction as a feature, because it forces definitional clarity that was previously hidden in inconsistent ad hoc queries. That is a fair description of the benefit, but it is also an admission that the work is human.
The governance cadence mismatch. Collate points out that governance teams own the glossary and typically update it on a slower, more formal review cycle, while analytics engineering owns metric logic and ships changes with every sprint. The artifact and the executable metric are governed by different teams on different clocks. A cadence mismatch produces drift even when everyone agrees on the definition in principle — which is why agreement alone is an insufficient control.
The platform boundary. Every major data platform maintains its own semantic layer, each defining metrics inside its own boundary. Alation notes that platform-native governance stops at the platform boundary as a design reality. Cross-platform consistency therefore depends on interchange formats rather than on any single layer. The Open Semantic Interchange specification defines a vendor-neutral, extensible model for representing data sets, metrics, dimensions, relationships, and contexts so they can be interpreted consistently across tools, platforms, and agentic applications. Alation reports joining as a launch partner in September 2025, with the project entering the Apache Incubator in July 2026 as Apache Ossie. The standard supplies portability; it does not supply the decision about which definition wins.
Who Owns Definitions — And How That's Governed
The question "who owns the definitions?" is often answered with a tool name. Alation reframes it usefully: not which tool holds them, but which named person approves a change to "active customer."
That reframing implies a set of mechanics the layer can support.
Named ownership recorded on the definition itself. The owner is an attribute of the metric, not a line in a wiki that drifts from the model. The same applies to certification status — certified, deprecated, or draft — visible to whoever asks, including an agent.
Authorship and review through version control. Definitions are versioned as code. Honeydew's documented workflow, as described in Atlan's comparison, stores each entity, attribute, metric, dataset, and domain as its own YAML file in a Git repository, with publishing a change opening a pull or merge request against the main branch, and branch protection rules recommended so production changes require review. Coalesce makes the same demand of any semantic layer: can you treat definitions as code, version them in Git, peer-review, test, and roll back? If not, governance does not scale.
Certification and status as consumer-facing signals. A consumer — human or machine — should be able to tell whether a metric is certified before using it, and see when it was deprecated.
A core/edge architecture with a promotion path. Databricks describes the mature pattern: the core holds authoritative definitions, certified measures, standard dimensions, and enterprise-wide policies, changing slowly through formal review and impact analysis. The edge — per team, application, or agent — is seeded from the core and extended with local synonyms, domain filters, and experimental metrics. The architectural requirement is that useful edge knowledge can be reviewed and promoted back to the core, so the enterprise layer evolves without drifting.
What the layer does not do is enforce who holds authority. Git review controls who may merge; it does not decide whether the trading desk or finance is right about net yield. That is an organizational charter the reader has to write, and no modeling choice substitutes for it.
Core or Scoped Variant: A Decision Rule
The following decision rule is this article's proposed framework, not an empirical finding. It is meant to be applied in a short conversation, not a long one.
Step 1 — Does the term feed leadership-level reporting, external disclosure, or agent answers? If yes, it is a core metric. It gets one definition, one owner, formal review, and impact analysis before any change.
Step 2 — Do two units need different filters, grain, or inclusion rules for a legitimately different question? If yes, that is a scoped variant. Name it distinctly — "Revenue — Trading Desk View" rather than a second "Revenue" — seed it from the core, and give it its own owner. The variant inherits the core's base logic and documents only its delta.
Step 3 — Is the difference an accident of history or a tool limitation? If yes, it is neither core nor variant. Reconcile it to core and retire the duplicate. Most divergence found during a first inventory falls here.
The naming test. If a variant cannot be named without ambiguity in a single sentence, it is not a variant. It is a competing definition, and it needs an owner's ruling rather than a new entry in the model.
When Two Units Genuinely Need Different Definitions
The hard case is not sloppy modeling. It is two units asking genuinely different questions and using the same word.
The sourced anchor comes from capital markets, where the A-Team Insight review notes that identical terms such as exposure or net yield can carry differing definitions across trading desks, risk functions, and accounting units. The panel's framing is that the semantic layer provides a unified business definition, which becomes especially critical when deploying AI agents that translate natural language requests into database queries.
The resolution in practice is usually not one number. Consider the following as an illustrative composite rather than an observed case: a firm defines a core "Net Yield" with a single certified calculation and owner, then publishes two named variants — one scoped to trading-desk reporting conventions and one to accounting treatment — each with its own owner, its own certification, and lineage showing how it derives from the core. A consumer selecting "Net Yield" sees the core. A consumer selecting the desk variant sees the desk variant and the reason it exists.
That structure has a cost, and the cost is the point. Leaving divergence unresolved produces what Databricks calls decision debt — ambiguity that compounds into rework, reconciliation meetings, and missed opportunities, with teams debating definitions instead of acting on insights. A governed family of variants converts that recurring cost into a one-time modeling decision plus a maintenance obligation.
The honest limit: if two executives each prefer their own revenue number for incentive reasons, the layer documents the disagreement. It does not settle it. What it does is make the disagreement visible in the query path rather than buried in two dashboards that both look authoritative.
Does This Change for AI Agents?
Agents raise the stakes on both sides of the thesis.
Cube-conducted benchmark reported by Alation: 100 retail-analytics questions, three models, with and without a 4KB hand-authored semantic document. Bars show the reported accuracy ranges; the three models were statistically indistinguishable within each condition. Vendor-published preprint on a single domain.
On the cost of no grounding, Collate reports that GPT-4o and Claude Sonnet 4.5 scored roughly 10–11% on the Spider 2.0 benchmark against real enterprise schemas without context and semantic grounding, rising into the high 70s once governed context and semantics were added. Treat those as reported figures from a secondary summary and check the underlying benchmark before quoting them internally.
On the value of a small amount of grounding, a Cube-conducted benchmark reported by Alation found that a 4KB hand-authored semantic document added 17.2 to 23.2 percentage points of accuracy across three models on 100 retail-analytics questions, with the three models statistically indistinguishable from each other both with and without the document (67.7–68.7% and 45.5–50.5% respectively). That is a vendor-published preprint on a single domain; the interesting signal is not the absolute number but that a modest, well-authored semantic artifact moved results more than model choice did.
Cube's operational guidance for agents is a reasonable checklist regardless of vendor: do not let the model define metrics from table names or prompt examples; give it certified measures, dimensions, joins, and time behavior; enforce the user's permissions when the query is compiled rather than after; return the metric definition, filters, time range, and lineage with each result; and run evals against known answers and denied-access cases.
For the thesis, the implication is direct. Agents increase the value of unified discovery and execution, because an agent that can select from a certified menu produces the same number every time instead of re-deriving joins and grain. They also make unresolved definitions more dangerous, because an agent will confidently pick whichever definition it finds first and present it with the same fluency as a correct one. What agents do not do is adjudicate meaning. Semantic grounding reduces model error; it does not eliminate it, and unsupported narrative claims about why a metric moved still need validation.
Semantic Layer vs. Data Catalog: Complementary, Not Substitutes
The two categories get conflated because both use the words "definition" and "single source of truth." Collate draws the line sharply: a glossary entry is a static sentence for humans, while a semantic layer metric is a governed, reusable query for machines.
Dremio's comparison puts the split in operational terms. The catalog's key question is "what data exists?"; the semantic layer's is "what does this data mean?" The catalog is passive with respect to the query path; the semantic layer is active in it. The catalog documents business logic; the semantic layer executes it. Galaxy's layer table assigns the same division of labor: the catalog governs ownership, glossary, certification, and audit under a governance team, while the semantic layer governs metric logic, joins, and entity definitions under analytics engineering.
Atlan's framing is the most compact: the catalog is a system of record for what exists and who owns it — documentation, not execution — while the semantic layer is where a metric like revenue gets its calculation.
The dependency runs one way, and Alation states it plainly: the catalog is where the tables a semantic layer is built from get certified in the first place. A semantic layer built on tables nobody has certified does not create truth; it standardizes a guess and hands it to an agent.
The 2026 trend is vendors pulling both layers toward agents — catalogs exposing certified context through MCP servers, semantic layers returning lineage alongside results. That convergence is useful, but the practical implication for a buyer has not changed: purchasing one does not discharge the other's function. An organization with only a catalog gets agents that retrieve responsibly and calculate inconsistently. An organization with only a semantic layer gets consistent calculation over tables whose trustworthiness nobody has established.
Testing Whether Your Semantic Layer Is Doing Its Job
The following checks are derived from the governance mechanics above — ordinary reasoning about what a working layer should demonstrate, not measured benchmarks. Each is pass/fail and can be run this quarter.
Cross-tool consistency. Query the same metric from two different tools. Do you get identical results and identical definitions? If the numbers match but the displayed definitions differ, the model is not yet the single source.
Ownership and review path. Pick every certified metric. Does each have a named owner and a review path visible in version control? A metric with no named approver is uncertified in practice, whatever its status field says.
Impact analysis before merge. Propose a change to a core definition. Does the workflow surface downstream consumers before the change lands? Databricks frames this as the reason change management becomes safe — impact analysis is always visible.
Agent behavior on governed and ungoverned requests. Ask an agent for a certified metric. Does it return the definition, filters, and lineage? Then ask for something ungoverned. Does it fail visibly, or produce a plausible number?
Variant hygiene. List every scoped variant. Is each named distinctly, owned, and traceable to core? Any variant that fails the naming test from the decision rule is a competing definition awaiting a ruling.
Cadence reconciliation. Document how often the glossary is reviewed and how often metric logic ships. If the two are not reconciled, drift is scheduled rather than prevented.
A layer that passes all six is doing the job the title claims: unifying discovery and execution. A layer that passes four has a governance gap, not a technology gap.
Conclusion
The semantic layer's achievement is that everyone finds and runs the same governed logic. The argument about what that logic should be remains yours to govern.
MIT CISR 2024 Data Monetization Survey (N=349 executives). Left: share rating their organization's data curation practices as somewhat or very well developed. Right: share reporting effectiveness at value-realizing data and AI initiatives, by curation maturity — the briefing describes organizations with these practices as more than three times as likely to be effective.
That reframing changes what to invest in. Treat definition ownership as a named role with a written charter, not an implicit responsibility of whichever team happens to maintain the model. Treat the layer as the execution and discovery surface for decisions made elsewhere — in review, in arbitration, in the core/edge promotion path — rather than as the place where those decisions get made by default.
And measure the layer accordingly: by consistency across consumers, by visible failure on ungoverned requests, by the share of certified metrics with named owners, and by whether scoped variants are documented rather than discovered. Those are properties a team can test. The hope that configuration ends disagreement is not.
FAQ
But doesn't a semantic layer settle the definition debate by forcing one definition?
No. It forces the debate to produce an artifact. The layer makes one definition executable and visible across every consumer, and it makes changing that definition a governed, reviewable act. Choosing it in the first place, and deciding to change it later, remains a human decision with an owner. Alation's point stands: the organizational conflict sits outside the config file's reach.
What if we already have metric logic scattered across BI tools?
The layer consolidates execution without requiring a big-bang migration. Seed core metrics first — the ones feeding leadership reporting, external disclosure, and agent answers. Document existing tool-level logic as edge or legacy, with owners, and retire duplicates as consumers move. Databricks describes the platform-native pattern that makes this practical: semantics live next to the data and are exposed to existing tools through open APIs such as REST, JDBC, and GraphQL, so current dashboards can consume the governed definition rather than being rebuilt first.
How do you respond to claims that semantic layers are immature or slow to adopt?
The survey evidence supports the observation. The A-Team Insight poll found no respondent with a fully implemented layer and 44% still exploring. But the panel's diagnosis was that the hurdle is consensus on definitions, not the technology — which is consistent with this article's thesis rather than contrary to it. Slow adoption is what you would expect if the binding constraint is organizational agreement, and it is an argument for treating ownership and review as first-class design decisions rather than an afterthought.
Is a semantic layer the same as a data catalog?
No, and most enterprises need both. The catalog inventories what exists, who owns it, and whether it can be trusted, across platforms. The semantic layer defines how a metric is calculated and serves that definition into the query path. The dependency runs one way: the catalog is where the tables the semantic layer is built from get certified. See the comparison section above for the full split.