“Only when the tide goes out do you discover who’s been swimming naked.“ – Warren Buffet
AI is not the tide. It is the flood that exposes the gap that humans have quietly been papering over for decades. Unlike humans, AI can’t ask a colleague, call a meeting, or force two teams to resolve a conflicting business definition. All AI can do is hallucinate, with confidence, through your leaky data model (or lack thereof).
At Snowflake Summit, I gave a talk titled “Onboarding AI”, focusing on the night/day difference in accuracy between an LLM that simply has access to data and one that has access to context (i.e., a semantic model). The title emphasizes treating AI as a new team member by providing documentation and explanations, and by grounding it in the shared knowledge of the company. Put plainly: the data model is your AI’s worldview, and the quality of its answers is bounded by the context it receives.
Unfortunately, context is not achieved by a determined leap of effort. It is a ladder of competency and maturity that an organization must learn to operate on at every rung it ascends. This article will explore the levels of data modeling that organizations need to achieve accurate operational insights in the AI era and provide self-assessments for each to determine where you stand and what needs improvement. Let’s start at the bottom.
Level 0: No model is still a model
…albeit a crappy one. Shout out Joe Reis. Many engineers know the quote, yet many organizations don’t know the lesson. Just because you have data does not mean you have a data model. At level zero, structure is the byproduct of data pipelines, one-off updates, and tribal knowledge. Here, business logic is spread across the ETL process, the reporting layer, and often, siloed spreadsheets that masquerade as master data.
At this level, AI doesn’t even enter the conversation. It doesn’t know which tables serve as definitive sources of truth, how to join them, or how to apply the business rules that were once canonized in a Slack thread and now live in a nightly stored procedure. No, at this level, AI is not even discussed because the data team is spending most of its time putting out fires and fielding questions that should live as part of documentation.
Self-assessment: ask AI to query your data, and instead of returning answers, it burns tokens querying the information schema, and ultimately, comes back with a plausible yet incorrect answer.
Don’t despair, the journey to a well-modeled enterprise begins with a single domain. Working top-down by identifying the biggest inconsistencies, we can isolate a slice of the data landscape and begin to add the context that will take us to the next level.
Level 1: Model-as-code
When dbt called a SELECT statement a “model,” they led a whole generation of data engineers astray. In a level-one organization, business logic is maintained with the rigor of code because it is code. Business logic is embedded in the pipelines, is auditable and version-controlled, and allows an engineer to track a detail from the dashboard to the source system by working backward through the code.
When models live as code—whether in dbt, airflow, or Dynamic Tables—organizations have the advantage of seeing the how behind the business rules governing their data, but not the why. Code gives the illusion of order because it provides backward auditability but not the blueprint that determines if the path taken was the right one or how to get to the next place you’re going.
There are no definitions, no defined relationships, and certainly no holistic view of how things fit together across domains.
Self-assessment: if anyone on the team says “we model in dbt,” you know where you stand. Anything that isn’t already part of your pipeline is as nebulous to your developers as it would be to AI. Consistency is enforced through PR reviews, and comments count as “documentation,” which is a big step up from the chaos of level-zero.
However, without a comprehensive map of the source data, where all entities are named, their grain is known, and their relationships are established, getting to the next level will be tricky.
Level 2: Curated Domain Models
At some point, the data team realized that the only way to support a data model of sufficient scale is to standardize. To stop the ongoing confusion, they had to align on a pattern: dimensional for data marts, Data Vault for the integration layer, 3NF, or whatever the flavor their business required. Now, keys are declared, relationships are defined, and every table has a known grain. The model lives in a modeling tool alongside the warehouse, and, by a small miracle, the ERDs mostly match what’s actually deployed.
For AI, this is the first level where the conversation gets interesting. Point an agent at a curated domain, and it finally has something to stand on: it knows the facts from the dimensions, how they join, and at what grain to aggregate. Ask it a question inside the sales mart, and it answers with accuracy. Ask it a question that spans sales and marketing, and watch the confidence stay while the accuracy evaporates. The structure is reliable, but the meaning is absent. Business definitions still live in BI-tool semantic layers and, worse, in people’s heads. Moreover, each domain is maintaining the same shared business rules (e.g., active customer) to mixed success.
That’s the level two trap: a collection of local optima. Each domain is modeled well, in isolation, by a team that solved for its own stakeholders.
Self-assessment: every team has a good model, but the models disagree. customer_id means three different things across three marts, and each is defensible on its own terms. Your architecture looks like a federation, yet your definitions behave like rival nations.
Achieving unity requires changing levels: moving from physical to logical to achieve a global perspective. Define each business entity once (e.g., customer, order, product) and map that single definition to its many physical implementations. The physical models don’t need to be rebuilt; they need to be reconciled under a shared vocabulary.
Sounds simple because the challenge isn’t technical, but this is the rung that most organizations stumble on because they lack the required people skills to navigate it.
Level 3: Connected Logical and Conceptual
Levels one and two are technical problems, and data teams are good at technical problems. Level three is an organizational one: getting sales, marketing, and finance into a room to agree on what a customer is (and keeping them agreed after they leave it).
To succeed at this level, organizations must model business entities and relationships in platform-independent terms, then map each one to its many physical implementations. Naming and design standards stop being preferences and become formalized. All of it lives in a governed modeling layer that links conceptual to logical to physical—so a change in business meaning can be traced down to every table it touches, and every table can be traced up to the meaning it serves.
For AI, the payoff is navigation. The agent no longer needs the question phrased in the language of the schema; it can start from a business concept and walk the map down to the right physical table in the right mart. Ask about customers, and it knows which of the three customer_ids you mean, because there is finally one customer definition. But ask it to compute churn, and you hit a ceiling: it can find the tables, but the metric itself still lives in a wiki page or somebody’s dashboard.
Self-assessment: one definition of customer, many implementations, all traceable. When a definition changes, you know the blast radius before the change, not after.
The last climb is to encode meaning itself: metrics, filters, synonyms, and groupings in machine-readable form. Not documentation about the logic but the actual logic, expressed as something the agent can execute rather than interpret.
For this, we need to go beyond what traditional database modeling was designed to handle.
Level 4: Semantic Models
At level four, meaning finally becomes a first-class citizen. Metrics, dimensions, definitions, synonyms, and aggregation logic get encoded in a semantic layer: machine-readable, executable, and versioned. “Churn” stops being a paragraph on a wiki page and becomes a definition the agent can run: the filter, the time window, the denominator, and the exception finance fought for, defined as code.
For AI, this is the level where “talk to your data” finally delivers. Ask “what was churn last quarter” and the agent doesn’t reverse-engineer the metric from table names—it resolves the question against a centralized definition and returns the same number. Deterministic, auditable, correct.
Correct inside one tool, that is.
Semantic layers are usually bound to a specific tool: dbt has one standard while Power BI has another, and they don’t reconcile. Two semantic layers can still give two answers to the same question, and suddenly you’ve recreated the level-two problem one floor up: local optima, semantic edition. And the layer that knows what churn means still doesn’t know where the data came from, who owns it, or what upstream change will break it, because rules and lineage live somewhere else.
Self-assessment: natural language works beautifully in the BI tool and fails everywhere else. Your agent is competent in one domain, but can’t extrapolate to the rest of your data estate.
The climb from here is consolidation: unify semantics with structure, business rules, lineage, and ownership in one common format—a single place where meaning, mechanics, and accountability describe the same world. Anything less, and your AI’s worldview is still a collection of translations.
Get consolidation right, and you’re one rung from what this whole ladder has been climbing toward: comprehensive unified context.
Level 5: The Enterprise AI Context Layer
At level five, the distinction between the model, the documentation, and the governance policy disappears because they’re the same artifact. Structure, semantics, business rules, modeling patterns, naming standards, data lineage, ownership, and policies are all combined into a single format that is both machine-readable and human-readable. This information is accessible through open interfaces, such as MCP and API—available to systems and agents—and is supported by an auditable platform accessible to everyone in the enterprise.
This is not another tool bolted onto the stack; it’s the format the stack answers to.
Here, the AI test inverts. At every level below, the question was whether the agent could find its way to your data. At level five, the model is the interface: agents query it before touching a single table, and guardrails come from the model rather than from prompt engineering. An agent can’t join across an undeclared relationship or ignore an access policy, because the worldview it operates in doesn’t contain that possibility.
And the traffic flows both ways. With level-five maturity, agents don’t just consume the model, they help maintain it: detecting drift between model and warehouse, proposing changes when a new source lands, and enforcing naming standards on every edit.
Self-assessment: governance stops being a document and becomes the model itself. New data products conform by default, because building inside the model is easier than building around it.
But don’t forget: level five is a state, not a summit. The business will keep changing, and the model earns its keep only as a living contract between humans, systems, and agents. The model is renegotiated as the business evolves and enforced as it runs. But an enterprise that operates here has nothing left to fear from the flood. There are no gaps to hallucinate through. The water arrives and is channeled into the right pipelines.
Conclusion: don’t stop climbing
From no model to enterprise context layer, the climb is the same repeating motion: capture what your data means, then make that meaning readable. Every rung moves business rules out of heads, Slack threads, and dashboards and into something declared, connected, and eventually, executable.
AI didn’t create this problem, it just exposed the humans who papered over it. The flood doesn’t punish organizations for lacking a semantic layer; it hoses them for decades of letting understanding live everywhere except the model.
So take an honest self-assessment, and wherever you land, don’t dismay because it’s never too late to start climbing. The rungs pay for themselves as you go: better data quality, less friction between teams, fewer hours lost to troubleshooting numbers that should have matched in the first place. Those returns arrive long before an agent ever touches your warehouse.
Your organization does not have to be at level five today; many aren’t. But you should be climbing that ladder with urgency. The tide is rising fast.
