In 1799, soldiers near Rosetta, Egypt, unearthed a stone carved with the same decree in three scripts: hieroglyphs, Demotic, and Ancient Greek. Because scholars already understood Greek, it unlocked a language—and with that, a civilization’s worth of knowledge that had been dark for over a millennium.
We’re at a similar inflection point in enterprise data. Organizations sit on vast scores of unstructured data—tables, views, metrics, joins—but the systems reasoning about it don’t inherently understand what any of it means. A column named "rev_adj" could mean adjusted revenue, or something entirely different, depending on the team, the region, or the fiscal calendar.
Without a shared translation layer, agents hallucinate, leading to decisions being made on bad numbers.
The semantic model is the Rosetta Stone for this problem—encoding business definitions, security rules, join logic, and calculation semantics, so autonomous agents can interpret intent probabilistically and return deterministic results.
Spotter Semantics is ThoughtSpot’s governed, AI-native semantic foundation, enabling agentic AI to translate natural-language intent into policy-aware queries grounded in approved business definitions.
The Three Pillars of Spotter Semantics
Spotter Semantics leads the industry with three core pillars:
1. Human-Verified Definitions: Tribal knowledge is defined and verified by humans, providing human-in-the-loop validation. ThoughtSpot’s token-based approach ensures that this verification process does not require reviewing or understanding the underlying SQL. It also allows definitions to be crowd-sourced, rather than an onerous, upfront modeling exercise.
2. Built for Agents: The semantic model is stored in a format that agents can directly ingest, providing the metadata and context required to resolve the task’s intent.
3. Deterministic Query Generation: ThoughtSpot’s proprietary, database-specific query generation ensures that answers execute as deterministic, accurate, and highly performant SQL with:
guaranteed row and column-level data security,
applied modelling semantics,
query generation supporting everything from single tables to advanced galaxy and multi-star schemas,
and codified business metrics and attribute cohorts that ensure consistent results.
Why the Semantic Layer is No Longer Optional
Agentic AI has accelerated the shift from passive, human-monitored dashboards to autonomous agents that review insights and take actions. Executives want autonomous systems making decisions, product managers are embedding analytics directly into their platforms, and data teams are expected to support it all at scale.
All of this is only achievable when agents are semantically literate. The semantic layer is not just a translation layer for raw data (e.g., SQL, Parquet, Snowflake tables), but a digital definition of the business itself. We can think of this as a “working knowledge of the individual puzzle pieces of the system and how they fit together.”
For example, the semantic layer answers questions like:
What is the definition of a “churned customer?”
How does the business define cohorts of products as “High,” “Medium,” or “Low” value?
Which users and groups of users should be able to view specific rows or columns?
When joining multiple tables, such as Sales and Products, are we performing an inner join (matched data), left join (all transactions), right join (all products), or full-outer join (entire dataset)?
From Proprietary Silos to Open Standards
Historically, semantic models have been proprietary in nature and also simplistic: syntax and definition are tightly coupled to the underlying analytics platform.
In conjunction with other industry leaders, ThoughtSpot is a founding partner in the Open Semantic Interchange. The OSI charter commits its members to standardised, interoperable, extensible, and open-source semantic model definitions—designed to work across every tool in your full analytics and AI stack.
Analytics-as-Code: Operationalizing the Semantic Layer
Spotter Semantics is defined by ThoughtSpot Modelling Language (TML). This is grounded upon the philosophy of Analytics-As-Code (AaC). AaC ensures that organizations manage analytics as they would with any other software development project—including version control, automated testing, CI/CD, and collaboration.
This approach ensures organizations can:
Respond to business needs flexibly and efficiently.
Ensure consistency and reduce manual errors.
Apply version control and roll-back capabilities.
Guarantee accuracy and reliability of changes.
Ensure that the process can be automated and scaled to the needs of agents and embedded analytics.
Query Generation: Where Definitions Become Results
Open, interoperable, and rich semantic definitions are only valuable when used to meet the business’s analytical needs. ThoughtSpot’s proprietary query generation engine is the final piece in the puzzle.
While the semantic layer is the digital twin of the business, the query generation engine ensures that the analytical results are expressive, accurate, secure, and performant.
Simple to Advanced Data Models
Spotter Semantics defines how source objects or tables are joined, from simple equi joins to more advanced range or AI joins. Query generation creates the SQL plan to ensure correct results across everything from a single-table schema to advanced galaxy schemas. This plan must account for data modelling traps and attribution to ensure that the results are correct. Many semantic layers limit joins to a single fact table—Spotter Semantics doesn't.
Data Security
Data security is a non-negotiable foundational principle in ThoughtSpot. There must be a security guarantee, regardless of the method of interaction, whether it’s analytics applications, embedded analytics, or agents. ThoughtSpot can inherit security groups from upstream systems, and additionally allows security rules to be codified directly in the semantic model. Query generation guarantees that row-level and column-level security rules are always applied to every SQL query.
Analytical Expressibility
Semantic models must be able to define and execute upon a wide range of questions; there is limited value in being able to only return a sum or count of a metric. Spotter Semantics natively supports advanced analytical queries.
The following are examples of how our patented analytics expressions further enhance the definitions in the semantic layer:
Custom Calendars: Dates and calendars are the bedrock of analytics. KPIs and trends leverage comparison periods to drive anomaly reporting. Trends may compare prior comparison periods, like weeks, and these rules require a calendar definition. The definition could be simple–such as the start month of the year or the first day of the working week–or more complex, such as retail calendars variants like 4-4-5 or 4-5-4. Spotter Semantics captures the definitions, and its query generation ensures the result accuracy.
Cohort Analysis: Cohort analysis typically involves defining the cohort—for example, classifying customers as Gold, Silver, or Bronze. The semantic model must also specify how the cohort may respond to user interaction. For instance, when a user applies a filter, what rules apply? Should region or date filters be applied to change cohort values? In ThoughtSpot, these rules are defined in the semantic model as Column or Query Sets, and euery generation ensures that the appropriate SQL subqueries are created.
Level of Detail: Level of detail refers to analytical expressibility–the ability to change the grain of search. It’s most commonly used to create contribution ratios, answering questions like, “What is the % contribution of each store’s sales to the region?” Spotter Semantics captures both this definition and the interaction rules. For example, what happens if a user adds or removes a grouping column, or applies or removes filters? This semantic definition is expressed through advanced formulas and implemented via query generation.
Query Generation Nuances
Spotter Semantics enables fine-tuning of the final generated SQL to further optimize queries. For example:
ThoughtSpot is a case-insensitive search product. However, if the data is stored in lower or UPPER case, the resulting SQL does not require an additional LOWER function for string comparisons. Disabling this for specific columns can materially improve performance.
Dates are often used for indexing or clustering, and ThoughtSpot’s date constraint logic rules can be defined to ensure that a date filter is always applied, preventing full table scans.
Custom calendar filters are usually defined on dimensional tables, and date filters may not be pushed down by the underlying database query engine. ThoughtSpot ensures the resulting SQL applies a filter on the fact table to reduce full table scans and leverage indexing.
The Context That Makes Agentic AI Trustworthy
The discovery of the Rosetta Stone didn't allow only for the translation of words. Rather, it allowed scholars to understand the context of an entire civilization.
In the same manner, Spotter Semantics provides the required context for analytical expressibility for Agentic AI. It combines the semantic layer with ThoughtSpot's query generation engine to ensure every insight is grounded in trusted, accurate, and deterministic SQL.
Start building on a semantic layer designed for agents. Request your demo today.
