AI on enterprise data starts with context

Every executive team wants to be AI-first this year, and for good reason. Wherever AI works, it pays off quickly. But look closely at where it works and a pattern shows up: AI delivers value in the places where context already exists.

Enterprise data is mostly not one of those places. You can labour through building a semantic layer, and it will cover perhaps 10% of your assets, but everything else is federated across warehouses, pipelines and BI tools, built by different teams over many years, overlapping and often contradicting itself.

The demos vendors show run on clean data with carefully crafted definitions, and the truth is that real enterprise companies don't have any, at least not at the scale they operate.

At dbt Summit, I presented with Brad Levy, Director of Analytics at AlphaSense, one of our customers. His team runs AI and achieves strong results from exactly that kind of messy data today. Their results are the best evidence I have that context is the problem to solve first, and that you can start solving it now.

A table has none of the context a file has

Enterprise search took off because files are machine-ready. A file carries its own context: who created it and when, who owns it, who can open it, its revision history, its content. An agent that opens a file gets all of it before it even has to consider the contents.

A warehouse table carries almost none. To use it correctly, an agent needs its lineage and the transformations it went through along the way, the code, the owner, and who uses it for what purpose. It needs to know whether the data is healthy, whether it contains confidential information, who has access, and whether anyone certified it. Those facts are scattered across the data platform, the ELT tools, the BI layer, security and DSPM tools, identity systems and observability tools.

As counterintuitive as it sounds, agents that can explore entire warehouses are doing so in complete blindness.

That is why agents struggle on enterprise data, and it sets three requirements for the context they get.

Context has to be automated. An agent that assembles context at runtime is slow, expensive and often wrong. The context has to exist before the question is asked and stay current as the organization changes, without anyone triggering a lineage run, ingesting new information or stitching systems together. It also has to self-improve rather than rely on human intervention in order keep up with usage and expectation

Context has to be governed. The most common reason security and governance teams block agents from data platforms is fear that agents will reach what they shouldn't. Governance can't be bolted on afterward. Whether a persona or an agent may access an asset, whether it touches PII, whether it follows logic that role should use: all of that belongs inside the context.

Context has to be scoped. Today everyone is focused on making AI work. Once it works at scale, the conversation turns to cost, and context is one of the largest contributors to the bill. An agent that queries 20 MCP servers and then reconciles their answers pays for it in tokens every time. It should get the slice of context its task and role require.

We built Euno to meet those requirements. It integrates with every system that holds information about your data and crawls their metadata continuously. It assembles that metadata into a context graph that records relationships: which dashboards depend on a table, who uses them, and who will object if it changes. On top of the metadata, Euno captures the institutional knowledge that lives in people's heads.

Start with the engineering, then the chat window

"To build agentic analytics, the engineering work has to be agentic as well."
‍
Brad Levy, Director of Analytics, AlphaSense

When teams think about AI for data, they go straight to conversational analytics. I think that order is backwards. An organization that creates and consumes data at the speed of AI can't maintain its pipelines, metrics and models at the speed of people. If the foundation is hand-built, it falls behind the agents running on top of it.

AlphaSense is a good test of this. It's an AI-first company whose product works because its content is curated and traceable before AI touches it, and every answer is cited. Brad's team holds its internal data to the same standard, with dbt as the governance layer and Euno supplying context. They proved the approach on their own analytics engineering first, and only then opened it up to the business.

Context removes the slowest part of building models

Writing SQL was never the bottleneck in analytics engineering. The slow part is finding out what the existing logic does and what depends on it. With that context in hand, a coding agent can do weeks of work in hours.

Brad's team had the kind of legacy model every data team avoids: a reporting table with 287 fields, feeding 12 dashboards and 41 views through one datasource used by 303 people. It sat on 68 dbt models, but the metric logic that mattered lived in the BI layer. That had been acceptable when only the BI tool needed it. Agents changed the requirement, because definitions now had to be reachable from every platform.

Brad worked in Cursor, with Euno supplying what the repo can't show: the BI logic, usage and downstream dependencies. Before writing any SQL, he asked Euno to measure how far the BI layer reached into base tables and which reporting tables were actually used. In about 15 prompts in a single session, the agent rebuilt the table as a clean and governed Kimball star schema of 13 models, delivered as pull requests through the normal review into dbt Cloud. Brad estimated the manual version at 3 to 5 weeks.

"The hard part was never writing the SQL. It's uncovering the legacy logic across the data stack and the blast radius of this change."

Brad Levy, Director of Analytics, AlphaSense

Context didn't remove the need for a human. Brad's job was to supply what no system held. Two content types in the data were one concept to the business, a fact too new to be written down anywhere, so he told the agent to model the business concept instead of the column names. He also cut scope to reach an MVP. Then he had the agent run a parity reconciliation against the legacy model, the check teams usually skip for lack of time, which is why legacy models so rarely get retired.

Roughly half of the final diff was tests and documentation. The model came out governed, and its documentation is now context that Euno serves to the next agent working on it. That is how engineering work compounds. Once a team has run a workflow like this a few times, it can encode it as a skill and let it run with less supervision, because the agent is working from what exists instead of guessing.

Impact analysis should cost seconds

Every team I talk to is in the middle of some migration, and the hardest part of a migration is knowing the starting point: what is used, what is valuable, what can go. Everyone agrees that impact analysis should come before any change. In practice it gets skipped because it costs a day, or it drags on for days and nothing ships.

"At seconds, it stops being a discipline and becomes a default."

Brad Levy, Director of Analytics, AlphaSense

A recent refactor of AlphaSense billing model shows how analyst and engineering work changes when impact analysis is cheap. The team had modeled usage-based billing as a single fact table. A second product line arrived with a process that looked similar and wasn't, and the one fact ended up full of nullable columns that users could only query correctly with three to five filters. Billing feeds invoicing and is used across BI, so the redesign couldn't break anything.

Brad started by asking the agent to trace what the live dashboards depended on, from workbook to datasource to views to dbt models to warehouse tables, at the column level. Euno mapped the current state in seconds, accurately on the first pass. Usage data showed which models nobody used and could be simplified. The resulting design, a conformed core of dimensions with one fact per business process, kept the BI-facing views stable so no Tableau datasource had to change. The full proposal took about 10 prompts and two hours, against Brad's estimate of a day and a half by hand.

The most important input came from Brad, not the stack. Only he knew more product lines were coming, and that shaped the whole design.

"Nothing in the stack said that a second product line was coming. And that was the judgment that ended up shaping and informing the whole design."
‍
Brad Levy, Director of Analytics, AlphaSense

The output was built for people as well as agents. Brad had the agent write a Notion design doc with Mermaid diagrams that his data architect could comment on, and a prompt summarizing the approach for the next session. The proposal went through two or three review rounds, with the agent addressing the architect's comments in each. All because Euno could map the current state in a single pass within seconds, allowing review to be productive rather than remedial.

Reconcile once and serve every agent

No data team controls how many agents the business adopts. Marketing, finance, RevOps and operations each have good reasons to bring in Claude, Gemini, ChatGPT, Cursor or whatever arrives next. The data team can control where those agents get their context.

"If each agent reconciles on its own, they will disagree. It's not a question of might. They will."

Brad Levy, Director of Analytics, AlphaSense

The answer is to reconcile once, centrally, and serve the result to every agent. At AlphaSense, agents connect to the Euno MCP server for context and query BigQuery and Snowflake directly. A new agent inherits everything the team has already built as soon as it connects. None of them has to call ten MCP servers and spend its context window stitching the answers together.

This is also why Euno doesn't gather context through MCP at query time. That approach would cost customers the same time and tokens it claims to save. Euno integrates with each system's APIs and query logs, crawls metadata continuously, and computes the context graph ahead of time. Reconciling means reconstructing lineage and joining it with usage, ownership, and trust signals.

Rules instead of a finished semantic layer

The data team's knowledge goes in as rules, which Euno turns into live labels that stay current without scripts or manual tagging and propagate instantly across the context graph. A rule might assign a set of assets to the customer success domain, mark a Tableau asset as trusted when it queries only gold-layer dbt models, or flag anything that depends on a PII column upstream as not AI-ready. AlphaSense uses a simple one: a green check mark emoji in a Tableau workbook's name means it is certified.

You read that right: an emoji.

Rules don't eliminate conflicting definitions, because organizations will always create them. What rules change is how an agent handles them. Ask for last quarter's churn and the agent can report that it found two definitions: product measures churn in active users, finance measures it in paying customers. It can say who built each, which dashboards expose it and who relies on it, and let the person choose. Nobody has to chase an analyst on Slack.

Accuracy has to be measured continuously

A proof of concept that scores 95% says little about next month. Euno generates benchmark questions, checks the agents' answers against them, and suggests missing rules and glossary terms from the gaps. Rerunning that loop is the governance process, and it lets context evolve without breaking what already worked.

Brad tested this with a certified product usage dashboard. He gave an agent a screenshot and asked it to find the certified asset through Euno, work out how the workbook was built and filtered, and rebuild it in dbt charts. After two or three rounds it hadn't reproduced everything, but the headline numbers matched client by client. That is the pattern for trusting agents: anchor them to a ground truth you already know.

Don't wait for the semantic layer

Most teams assume AI has to wait until the refactor is finished, the migration is done and the semantic layer covers everything. That can take 18 months, and the organization will have changed again by then. A context platform already maps everything that exists, so the data team only has to encode the rules it already knows. Cleanup and AI adoption can then run in parallel, with agents consuming only what the rules mark as trusted.

AlphaSense built models, changed its architecture and began serving business users from one context. Brad's summary of the results was that the work came out more accurate, because the models were governed and tested, and faster, taking hours instead of weeks. He didn't expect it to be more enjoyable too.

"My time went to judgment and design, not spending time tracing what already exists."

Brad Levy, Director of Analytics, AlphaSense

Start with context, cover governance, lineage and cataloging along the way, and put AI to work on day one.

‍