Why AI Makes the Semantic Layer More Important, Not Less

A customer opens your SaaS dashboard and checks their annual recurring revenue. Then they ask an AI assistant for the same number, only to receive a slightly different answer. Both results look plausible, and neither explains why the numbers disagree.
It's an uncomfortable situation for any product team, especially when customers increasingly expect to analyze business data with AI without checking every result against a traditional report.
Natural language interfaces have made analytics more accessible, but they haven't made business definitions any simpler. An AI model still needs to know what counts as revenue, which customers qualify as active and how metrics should be calculated.
That responsibility becomes harder to manage when analytics is available through your product, external assistants and automated workflows. A governed semantic layer gives those different experiences a shared understanding of the data, so customers can trust the answers regardless of where they ask.
What does a semantic layer actually do?
A semantic layer translates technical data structures into definitions that people and applications can use consistently. It connects the underlying data to business concepts such as revenue, retention or customer activity, including the calculations and relationships needed to produce those metrics.
Without that shared definition, two analysts can query the same database and arrive at different results. One might include refunded orders in revenue, while another excludes them. Both calculations may be technically valid, but the business needs an agreed definition before either number becomes part of an official report.
A semantic layer provides a place to manage that analytical logic. Depending on the architecture, it can define approved metrics, reusable calculations, dimensional relationships and the terminology used across reports.
The work starts with understanding the underlying data. A well-designed data model establishes how entities relate to each other, while the semantic layer makes the relevant business interpretation available to downstream applications.
Take a subscription platform that stores customers, contracts and payments in separate tables. Its analytics experience needs to know how those records connect before it can calculate recurring revenue or customer retention. Getting those relationships wrong can lead to duplicated records or misleading aggregations, which is why dimensional modeling for embedded analytics deserves attention before teams start building more reporting interfaces.
A semantic layer also depends on reliable inputs. If a payment record is missing or customer identifiers don't match, a perfectly defined formula can still produce an inaccurate result. Data quality and analytical consistency need to be addressed together, particularly when AI makes questionable numbers look convincing.
AI creates more places to ask the same question
Traditional analytics experiences offered a relatively controlled environment. Someone opened a dashboard, selected a reporting period and worked with metrics that had already been configured for that particular report.
AI changes how people interact with those metrics. A customer might ask a question in your product's AI chat, connect their account to ChatGPT or use an automated agent to generate a weekly performance summary.
The growth of AI-driven analytics makes these interactions increasingly practical, but each new interface introduces another place where business definitions can be interpreted differently.
Take a logistics platform that reports on-time delivery performance. Its dashboard might calculate the percentage of orders delivered within the agreed delivery window, allowing a 30-minute grace period.
A customer then asks an AI assistant, "What percentage of our orders arrived on time last quarter?"
The assistant needs to understand what "on time" means for that customer, whether canceled deliveries should count and which reporting calendar applies. If it writes its own query based on column names alone, the resulting percentage may disagree with the dashboard.
The problem becomes particularly visible when companies start connecting analytical systems through the Model Context Protocol (MCP). An external assistant can request data from a connected service, but the connection itself doesn't guarantee that the assistant understands the business rules behind each metric.
A consistent result depends on the analytical service applying those rules whenever the metric is requested.
There's also a product experience issue here. When analytics becomes part of the surrounding application, customers expect the information to behave consistently across different interactions. They shouldn't have to learn separate definitions for the dashboard and the AI assistant.
Where AI gets business metrics wrong
The difficulty becomes clearer with a metric such as annual recurring revenue (ARR).
ARR sounds straightforward, yet subscription businesses may have different rules for calculating it. Some include contracted revenue that hasn't started billing. Others distinguish committed ARR from live ARR, or handle discounts and contract upgrades differently.
Those decisions affect how finance teams interpret revenue performance and how product teams present it to customers.
Imagine a subscription management platform with two reporting interfaces. Its dashboard calculates ARR using active, recurring contracts and excludes one-time implementation fees. An AI assistant has access to the underlying billing tables but no approved definition of ARR.
When the customer asks for ARR, the assistant might annualize recent invoice totals, which could include those implementation fees. The answer would be based on real data, but it would represent a different calculation.
The model may have followed a reasonable interpretation of the available information. Unfortunately, the customer has no reason to know that the two interfaces are measuring different things.
A properly configured semantic layer addresses the calculation itself. Once ARR is defined through a governed expression, the reporting system can reuse it instead of creating another interpretation for each interface.
The AI still needs context to understand which metric the customer is requesting. "How much recurring revenue do we have?" might refer to ARR, MRR or another contractual measure depending on the product.
That's where additional business context becomes valuable. Luzmo's approach to embedded AI analytics combines governed analytical definitions with a Knowledge Layer that gives agents instructions about the data they're using.
Such context can explain what a field represents, how a reporting period should be interpreted or which definition applies to a particular question. The underlying metric calculation remains governed separately.
The distinction is worth preserving because a language model can interpret a user's question without becoming responsible for inventing the organization's financial definitions.
What belongs in the semantic layer?
A semantic layer works best when it centralizes definitions that should remain stable across analytical experiences. That doesn't require moving every transformation or business rule out of the existing data infrastructure.
In practice, teams should identify the metrics that appear across multiple reports and determine which calculations need a single approved definition.
An ARR metric, for example, needs an agreed calculation and a clear relationship to the relevant subscription records. A customer retention metric needs rules about which customers qualify for the reporting population and how the observation period is handled.
Other elements may include approved dimension names, filters and relationships that prevent downstream applications from interpreting the same dataset differently.
The complexity increases in SaaS platforms serving multiple organizations. One customer might use calendar quarters while another follows a fiscal calendar. Their underlying schemas may also differ, even when the product offers comparable reporting functionality.
A shared semantic layer across different customer schemas can provide common analytical definitions while allowing carefully controlled customer-specific variations.
That requires a deliberate separation between shared calculations and tenant-specific configuration. If one customer defines an active account as a user who logged in within 30 days, that definition shouldn't silently change the meaning of active accounts for every other customer.
The implementation also needs to respect the wider multi-tenant analytics architecture. Consistent metric definitions are valuable, but a query must still retrieve data from the correct customer's environment.
A semantic layer can contribute to reliable analytics across tenants, while authentication and access controls determine which records each user is allowed to retrieve.
What should an LLM be responsible for?
Language models are good at interpreting natural-language questions, recognizing related concepts and making analytics accessible to people who don't know SQL.
Those capabilities make AI-powered analytics attractive for customer-facing software. Someone can ask why revenue declined instead of manually selecting metrics and filters from a dashboard.
Still, some decisions require a level of control that a language model shouldn't independently determine.
An LLM shouldn't invent a revenue formula because the original query was ambiguous. It shouldn't decide which customer records are accessible or assume that two similarly named columns can be joined safely.
Those decisions belong to governed analytical logic and the surrounding security architecture.
The practical division of responsibilities is fairly straightforward. The AI interprets what the user wants to know and requests the appropriate analysis. The governed data model provides approved metrics and relationships, while access controls restrict the request to authorized information. The final answer can then be presented conversationally.
Of course, implementing this requires more than connecting an LLM to a database. Product teams need to decide which queries are permitted, how authorization is enforced and how answers can be reviewed when something goes wrong.
Luzmo's guide to AI analytics governance explores those decisions in customer-facing deployments, including the boundaries between agent behavior and data access.
Security deserves separate attention because even a correctly defined metric can expose information when query permissions are too broad. Embedded analytics security covers the mechanisms involved in protecting customer data, including tenant isolation and row-level restrictions.
An AI assistant should operate within those boundaries regardless of how confidently it phrases a request.
Semantic layer, knowledge layer and context layer: what's the difference?
The terminology around AI analytics is still evolving, and different vendors use these terms in overlapping ways.
A semantic layer generally focuses on defining how data should be interpreted analytically. It connects business metrics to the underlying data model and makes those definitions reusable.
A knowledge or context layer may extend that information with descriptions and instructions that help an AI system interpret user requests. The exact responsibilities depend on the platform's architecture.
Luzmo provides a useful example of how these concepts can work together.
Its semantic layer supports governed metric definitions through formulas, derived columns and SQL views. The Knowledge Layer adds information that helps AI agents understand the business context behind the data.
Using AI Context in Luzmo (opens in new tab), teams can provide descriptions and interpretation notes for datasets, columns and dashboards. An internal field name that means little to a language model can be accompanied by a business explanation.
Luzmo also supports Rules, which provide instructions to agents working with the data. As explained in the October 2026 product update, these mechanisms can help teams manage how agents interpret information across their analytical workflows.
Returning to the logistics example, the metric calculation can define the on-time delivery percentage, while contextual instructions explain the relevant reporting calendar or business terminology.
The two layers complement each other because the agent needs both an accurate analytical calculation and enough context to select and explain it appropriately.
What changes for SaaS product teams?
Product teams building AI analytics features face a practical architectural decision: how much analytical logic should each new interface be allowed to implement independently?
It's tempting to build a conversational experience by giving an LLM access to available tables and letting it generate queries. That can work for early experiments, particularly when a technical user is available to review the results.
The approach becomes harder to maintain once customers depend on the answers.
An analytics feature may eventually support in-app chat, automated reports and external AI assistants. If every implementation has its own metric descriptions or query logic, product teams have to maintain several versions of the same business rules.
Changes become difficult to coordinate. Updating the definition of active customers in one report could leave the AI assistant using an older definition until someone remembers to update its instructions.
The problem is familiar to teams that have already struggled with duplicated dashboard calculations. Luzmo's article on building analytics from the dashboard backward explores the value of designing metrics around the reporting experience customers need.
With AI, those definitions also have to work beyond the original dashboard.
Test the same question across different interfaces
A practical starting point is to select several business questions that customers regularly ask and compare the answers returned by every supported analytics interface.
Use questions that expose differences in interpretation, such as "What was our ARR at the end of September?" or "Which customers were active last quarter?"
Check the actual metric definition, reporting period and filters behind each result. Matching numbers are reassuring, but they don't necessarily prove that both interfaces applied the same logic.
When the answers disagree, trace the discrepancy to the calculation or context that produced it. The underlying issue might be an ambiguous metric name, an incorrectly applied filter or a different reporting period.
The same testing approach should cover permissions. An agent answering questions for one customer must never retrieve another customer's records, even when the question explicitly requests them.
Keep business definitions maintainable
Product teams also need a practical way to update definitions when business requirements change.
If a customer changes its fiscal year, the relevant configuration should be manageable without searching through several application prompts. If a metric changes, the updated calculation should reach every interface that uses it.
Centralizing the definition reduces duplication, although teams still need versioning, validation and a process for communicating material changes to customers.
The operational benefits extend to engineering time. As Luzmo discusses in its guide to scaling analytics without increasing engineering workload, reusable analytical components and governed data models can reduce repeated implementation work.
The same principle becomes valuable when adding AI features. Product teams can build new ways to interact with existing analytics without recreating the business logic behind every answer.
How Luzmo brings semantic consistency into AI analytics
Luzmo's approach combines the analytical capabilities of its platform with AI context and agent-based access.
Teams can define governed metrics within Luzmo, then provide additional business knowledge that helps AI interpret those metrics. Agents can use the configured data and instructions to answer questions across supported interfaces.
Through Luzmo AI, product teams can offer conversational analytics inside their applications and extend analytical capabilities to supported external agent workflows.
That makes it possible to design customer-facing experiences around a shared analytical foundation, although consistency still depends on the quality of the underlying model, the definitions provided and the configuration of each agent.
It's also worth checking how these systems behave under real usage. Questions that work perfectly during development may reveal ambiguous definitions once customers start using their own terminology.
Reviewing failed queries and unexpected answers can help teams identify missing context and improve the analytical experience over time.
Conclusion
AI has made it much easier for customers to ask questions about their data. Keeping the answers consistent requires more deliberate work, especially when those questions move beyond a single dashboard.
A semantic layer gives product teams a way to define business metrics once and reuse their meaning across analytical experiences. Combined with appropriate AI context and access controls, it can support more flexible interactions without allowing each interface to invent its own interpretation.
Before expanding AI analytics into another application or agent, take a metric customers already rely on and ask the same question through every interface you support.
If the results disagree, investigate which definition each system used. That exercise will tell you much more about the readiness of your AI analytics architecture than another impressive conversational demo.
Written by

Ship the future of your data
Let us show you what Luzmo can do for your product.

Book your session with our analytics expert.