Skip to content
Stop Token

Blog · 25 October 2026 · Max Ivanov

Centralize Meaning, Not Data.

Why the core of an agent-ready data platform is the control plane, not the warehouse

Centralize meaning, not data. Yesterday, meaning was spread across dashboards, a BI semantic layer and warehouse layers. Today, with agents: BI tools and AI agents ask through one policy model; a control plane holds canonical definitions, catalog, policies and placement rules; execution applies the same rules on every path; data lives in one open lakehouse copy; every answer carries evidence, and gaps and usage feed back into definitions and placement.Centralize meaning, not data. Yesterday, meaning was spread across dashboards, a BI semantic layer and warehouse layers. Today, with agents: BI tools and AI agents ask through one policy model; a control plane holds canonical definitions, catalog, policies and placement rules; execution applies the same rules on every path; data lives in one open lakehouse copy; every answer carries evidence, and gaps and usage feed back into definitions and placement.

Why are we still moving data through so many layers just to make it queryable?

We ingest it, transform it, copy it into another layer, aggregate it, and build yet another serving layer on top. Much of this architecture exists for good reasons: dashboards need predictable response times, analytical queries must not overload production, and business users need stable, curated datasets. But not every layer earns its cost.

What changes when the consumer is an AI agent: one that can discover data, write SQL, join sources and investigate a question step by step?

My working answer: less than the "warehouse is dead" crowd claims, and more than the "just put a chat interface on the warehouse" crowd assumes. The physical layers can get thinner. The layer that holds meaning and control has to get much stronger. And the order of design may shift: instead of deciding up front which definitions and shortcuts to build, we can use real questions to reveal what the platform is missing.

What the warehouse was actually for

It is tempting to say warehouses exist for dashboard latency. That is only part of the story.

Bill Inmon defined a data warehouse as subject-oriented, integrated, time-variant and non-volatile. Look at the last two. Source systems are often neither: a CRM overwrites a customer's segment; a billing system updates a subscription's status in place. If nobody captured the previous state, no query engine, however clever, can tell you what was true six months ago.

The warehouse also does jobs we rarely list:

  • Isolation

    Analytical queries do not run against production databases.

  • Integration

    Someone established that customer 4812 in the CRM and account A-77 in billing are the same entity.

  • Stability

    When a source renames a column, the change is absorbed in one pipeline, not in every report.

None of this disappears because the consumer is an agent. Any honest version of "query in place" has to say where history, isolation and integration live instead.

Open table formats are not federation

Arguments for "stop copying data" often mix two different ideas.

Open table formats

Apache Iceberg and Delta Lake separate table metadata and storage from the query engine. Data is ingested into an open format, and multiple engines can query the same managed tables. This can remove the need for a separate proprietary warehouse copy for each engine. It is still a copy of the source data, but it can be a stable, isolated, versioned analytical copy rather than one more proprietary serving layer.

Federation

Engines such as Trino can query across systems through connectors without first copying every source into a central store. How well that works depends on the execution plan. Which filters, aggregations and joins can be pushed down varies by connector and operation. When an operation cannot be pushed down, data may still move over the network at query time instead of at load time.

The trade-offs are different. An open lakehouse gives you a managed analytical environment where history and isolation can be designed in. Federation can provide fresher data and avoid ingestion, but it inherits the source's limits and can make cross-source consistency and performance harder.

For agent analytics, I would make the lakehouse the default execution environment: land data in an open format, isolated from production, with history and versions where required. Use federation selectively when freshness matters, the queried volume is small enough, and the execution plan can run efficiently. Add materialized tables when measured workload justifies them.

The claim is not "zero copies." It is fewer mandatory layers by default.

Isn't a lakehouse just centralizing data again? Partly, and it's worth saying so. But it's one open copy that many engines can read, not a chain of proprietary serving layers, and it's a default for agent-facing data, not a rule for every source. What has to be centralized without exception is meaning and policy.

We have been here before: data virtualization

"Query data where it lives" is not a new idea. Data virtualization vendors have promised a logical layer over many sources for well over a decade: one place to define business views, with less ETL and fewer copies.

It ran into real constraints:

  • Cross-source joins could pull large volumes of data over the network.
  • Analytical queries could overload operational systems.
  • There was no consistent snapshot across unrelated sources: two systems queried seconds apart could disagree.
  • BI dashboards often required predictable, low latency.

Mature virtualization platforms responded with caching, pre-aggregated summaries and query acceleration. Virtualization did not struggle because nobody had thought of materialization. It ran into the physics of serving analytical workloads from operational systems.

Some constraints are easier to manage now. "In place" can mean in an isolated lake, not in a production database. Open table snapshots can pin reads to specific versions, as long as those snapshots are retained. Elastic compute can make some on-demand queries practical. And some agentic tasks, such as background investigations or scheduled analyses, can trade latency for flexibility in ways an interactive dashboard cannot.

Other constraints remain. If source systems overwrite state, history still has to be captured through CDC or snapshots. A snapshot of one lake table does not create a consistent snapshot across unrelated live sources. Unrestricted exploratory joins should not run against production OLTP systems. Entity matching across systems is still real engineering. And latency compounds: ten sequential 20-second queries make for a long wait in a live conversation.

The opportunity is not simply better virtualization. Virtualization made operational systems look like one database for BI tools. An agent-ready platform provides a governed environment for consumers that formulate their own queries. It can also use what those queries reveal to improve the platform itself.

Agents raise the bar for meaning

Agents can inspect schemas and write SQL, but that does not mean they know what the data means.

A typical failure looks like this. An agent is asked for revenue last month. It finds a payments table with payment_id, amount, status and created_at, filters by month and sums amount.

The SQL is valid and the number looks plausible. But the table is a change log: each payment appears once per status change (created, authorized, captured, sometimes refunded). Most payments were counted three times, and refunds were counted as revenue.

Could a careful agent catch this? Possibly. It could check whether payment_id is unique and investigate the duplicates. But then it still has to decide which status counts as revenue, whether refunds are subtracted, whether test accounts are excluded, and which time zone defines "last month". None of that is in the schema. These are business decisions.

Ask the same question twice, or ask two agents, and you can get different numbers, each backed by perfectly valid SQL.

This is an information problem, not a reasoning problem that a smarter model will reliably solve. Human analysts face it too, but they bring context, prior checks, reviewers and shared conventions. An agent producing answers at scale has none of that unless the platform provides it.

A canonical definition of revenue can prevent this particular failure, but only if it is tested against the data and kept in sync with source changes. Semantics does not remove the problem in general; it moves it. Definitions cover the questions someone anticipated, while agents are most useful precisely where no one did. On those questions, the agent is back at the raw tables. That is why semantics has to describe the data, not just the metrics: grain, keys, status meaning, exclusions and relationships between entities. Answers should also show whether they use canonical definitions or logic improvised by the agent.

Inmon's integration and history, and Kimball's conformed dimensions and declared grain, still matter. Their approaches to building a warehouse differed, but neither principle requires every analytical query to run against one physically centralized system.

Control, execution, evidence

What if the core of the next data platform is not the warehouse, but the control plane around it?

The term needs precision. A control plane decides and configures; an execution plane does the work. For an agent-ready platform, I would separate three responsibilities:

  • Control plane:

    catalog, canonical definitions, access policies, budgets and rules for where computation should happen.

  • Execution plane:

    query engines, federation and pushdown, caches and materialized tables. It enforces the control plane's policies but does not own them.

  • Evidence layer:

    records how an answer was produced, so it can be traced and, where the inputs permit, replayed.

These are not three new products. They are responsibilities that existing components must cover. The point is to centralize policy, not necessarily to force all compute through one central service. Every execution path must enforce the same rules.

The control plane: meaning and policy

Discovery

Agents need to find the right data before they can query it: a catalog with descriptions, owners, freshness, grain and relevant definitions. Without that context, an agent may choose a table whose name looks right but whose rows represent status changes rather than payments.

Canonical definitions

Metrics and entities should be defined once, in code, versioned and reviewed: what counts as "active", how revenue is calculated, the grain of each fact table, and how keys map across systems. Definitions need tests against the data, not just review. A migration that turns a current-state table into a change log can silently break every definition built on it.

Policies and budgets

Who may read what, and on whose behalf? How much may a query, a question or an agent spend? An agent investigating one question can issue dozens of queries. Budgets keep exploration from quietly becoming the platform's most expensive workload.

Placement rules

Where should a computation run: in the lake, pushed down to a source, or against a materialized table? The decision depends on execution plans, statistics, network traffic, source load, freshness and cost. The fact that federation is possible does not make it the right choice for a given query.

The execution plane: the same rules on every path

Every agent query must run under the same policy model, whichever tool, MCP server or interface it came through:

  • Fail-closed authorization

    If the platform cannot establish that this agent, acting for this user, may read a table, the query is denied. Unknown means no.

  • Read-only validation

    Parse the query rather than pattern-match it. Allow only reads; reject DDL and DML, multiple statements, and table functions that reach outside the governed data environment.

  • Bounded results

    Row and byte limits, plus timeouts, prevent a single question from dumping a table into a context window.

  • Budget enforcement

    A query that would exceed its budget is stopped or escalated, not merely logged.

Execution identity matters. A common shortcut is a platform service account with broad access, with user permissions re-implemented in the platform. That creates a confused-deputy risk: one policy bug and an agent may see data its user cannot. Where supported, delegated identity lets the source enforce its own permissions and audit the actual user rather than a shared service account. The effective permission should be the intersection of what the user may see and what the agent is allowed to do. An agent should never see more than the user it acts for, and often less.

Delegation is not available everywhere and must use a proper token-exchange flow, not simply forward the user's token. Materialization complicates this: a shared table no longer automatically carries source-level permissions, so equivalent access policies must be preserved or explicitly re-enforced on the materialized data.

This is why MCP is the interface, not the security boundary. MCP standardizes how an agent discovers and calls tools. It does not decide what the agent may read, which queries are safe or how much a question may cost. If every MCP server implements its own checks, you end up with as many security models as servers, and they can drift. The policy model must be shared and enforced wherever queries actually run.

The evidence layer: traceable, replayable, reproducible

An answer should carry its provenance: which data it used, which metric definitions and versions, which queries, which table snapshots, how fresh the data was, which agent acted on whose behalf, and whether each number came from a canonical definition or logic the agent improvised.

Three levels are easy to conflate:

  • Traceability:

    you can see how the answer was produced. This should be the baseline for every answer.

  • Replayability:

    you can rerun the same queries with the same definitions and inputs, if those inputs remain available.

  • Reproducibility:

    rerunning gives the same result. That requires versioned definitions, retained data snapshots and deterministic queries. A federated query against live operational systems usually cannot meet this bar; sources can change between queries in the same investigation.

For exploratory questions, traceability may be enough. For financial and regulatory numbers, the gap between replayable and reproducible is the whole point. That is where frozen, materialized data still wins.

A plausible answer is not necessarily a trustworthy one. Evidence lets a human, or another agent, tell the difference.

Semantics first, workload observed

This is the idea I find most promising, and the one I am least ready to call proven.

Good dimensional modeling never depended on predicting every question. Kimball's approach starts by modeling business processes at an atomic grain, so the model can answer questions nobody anticipated. Interviews help decide which processes to model first, not which questions the model must answer forever. What did depend more on prediction was what we built on top: aggregates, marts, reports and business definitions. Some get used every day; others quietly rot.

Usage-driven optimization is not new either. OLAP engines have offered aggregation design from workload statistics for decades, and database advisors can recommend materialized views from query logs. The potential change is the link between intent and execution.

For each agent answer, the platform can record the natural-language question, the SQL, the canonical definitions used, and the logic the agent improvised. That makes it possible to observe not only which queries are slow or repeated, but also where the semantic layer failed to cover the question. Failed or abandoned questions matter too: observed workload is biased toward what the platform already handles well.

An iterative loop could look like this:

  1. Define core semantics and safe query capabilities first.
  2. Let the platform serve real questions against the isolated analytical environment.
  3. Measure cost, latency, repetition, failures and semantic improvisation.
  4. Improve definitions and materialize recurring expensive paths when the economics justify it.

Usage-driven materialization, as a first step

A practical first implementation is straightforward:

  1. Log each query with cost, latency, the definitions used and whether the agent improvised logic.
  2. Identify repeated joins and aggregations, consistently slow queries and costly investigations.
  3. Propose a materialization with expected savings, refresh cost and freshness implications; start with human approval.
  4. Register it as an implementation of a canonical definition, with lineage back to the underlying data. Preserve or re-enforce access policies. Retire it when usage no longer justifies the cost.

This is a process, not yet an optimizer. Repetition alone does not prove that materialization will pay off. A real decision must weigh refresh cost against query savings, freshness, invalidation when sources or definitions change, competing workloads and how many queries would actually benefit. A human in the loop is a reasonable starting point; a cost model is the next step.

The same loop for semantics

When agents repeatedly improvise a definition, that is evidence of a gap, not permission to turn the most frequent answer into business truth. Prioritize gaps by frequency and consequence, then have the owners define and approve them. Because the evidence layer records which definitions each answer used, finding those gaps becomes a query rather than a manual audit.

I would treat "semantics first, workload observed" as an architectural principle to test, not a proven replacement for traditional modeling. If it holds, it changes the order in which we evolve the platform, not the need to model business processes carefully.

When the warehouse still wins

None of this makes classic modeling obsolete. Keep or build warehouse structures when:

  • Many users need predictable, low-latency dashboards at high concurrency.
  • Numbers must be frozen and reproducible, as in financial close or regulatory reporting.
  • History needs explicit modeling: slowly changing dimensions, snapshots or bitemporal data.
  • Entity resolution is too expensive or ambiguous to do at query time.
  • Repeated workloads make materialized models cheaper and more reliable than on-demand execution.

The shift is not from warehouse to no warehouse. It is from "the warehouse is the default place every query must run" to "the platform chooses where computation belongs, with explicit evidence for that choice."

If I were starting today

I would start with three things:

  1. Land agent-facing data in an isolated open lakehouse by default; use federation selectively when freshness and query economics justify it.
  2. Define canonical metrics, entity relationships and access policies before giving agents broad SQL access; enforce the same policies on every execution path.
  3. Record the intent, query, definitions and evidence for every answer. Use that record to identify semantic gaps and materialize only the workloads that justify it.

The hard problem has moved

The hard problem shifts from where to copy the data to how to let agents find, query and combine the right data safely and economically, and how to learn from the questions they ask.

Aggregations are not dead. Neither is data engineering. But the default can change:

Query the lake first. Let usage decide what to define and materialize. Centralize meaning and control.

Are we designing the next generation of data platforms, or automating the architecture of the previous one?

Max Ivanov

Author

Max Ivanov

Comments and objections are welcome on LinkedIn or at info@stop-token.com.