The data warehouse was designed for humans. It assumed people would write queries in the morning, wait for dashboards to refresh, and debate metrics in meetings. It was built for a world where analytical work happened at human pace, in human time, with humans in the loop to catch mistakes.
That world is ending. Joe Reis just showed us what comes next.
What Joe Built
In a recent prototype, Reis inverted the entire premise of centralized analytical infrastructure. Instead of routing every agent query through a shared warehouse, he gave each active agent its own embedded analytical engine — a local DuckDB instance, exposed via Quack (DuckDB's native client-server protocol) over TCP loopback. Agents don't query a central system. They each are a data system.
But the real elegance is in how they exchange data. Reis introduced a structure he calls a Data Exchange Unit: an immutable analytical "slice" identified by a versioned reference that bundles together a catalog ID, dataset name, snapshot identifier, semantic contract digest, and content digest. When one agent produces results, another agent doesn't query a shared table — it receives a cryptographically identified slice, checks the contract, and either accepts it or rejects it.
The semantic layer is built on Malloy models: typed sources with governed query definitions. Each model's hash becomes part of the slice's cryptographic identity. If you change the revenue calculation — even subtly, even from sum(qty * unit_price) to sum(qty * unit_price) * 0.9 — the contract digest changes, the slice reference changes, and every downstream consumer knows immediately that something is different. Not because a human caught it. Because the math caught it.
Why the Shared Warehouse Breaks Under Agentic Workloads
Shared warehouses were optimized for a specific access pattern: a relatively small number of humans running moderately complex queries on a regular schedule. The warehouse could be tuned around those patterns. Concurrency was manageable. Errors were caught by people who understood the domain.
Agent workloads destroy all three of those assumptions.
Agents don't take turns. In a multi-agent pipeline, dozens of agents might fan out simultaneously, each running speculative queries, generating intermediate results, passing those results to the next layer, and producing yet more queries. The concurrency model of a centralized warehouse — designed for a team of analysts — is not ready for a fleet of parallel reasoning systems.
Agents chain intermediate results rapidly. In human workflows, intermediate data often lives in someone's head or a scratch spreadsheet. In agent workflows, intermediate results are first-class artifacts that need to be passed, versioned, and consumed programmatically. A shared warehouse with mutable tables is a terrible substrate for this — you can't version a shared table, and you can't guarantee that the result one agent reads is the same one another agent wrote.
Most critically: there are no humans checking the work. The entire value proposition of agents is that they operate autonomously. But the warehouse model was built with the assumption that humans would catch semantic drift, notice when a metric definition changed, or flag when a join produced unexpected cardinality. Remove the human, and you remove the error-checking layer the warehouse was designed to rely on.
The Elegant Inversion
What Reis built isn't just a different architecture — it's a different mental model.
Traditional thinking: take the warehouse, make it agent-ready (add APIs, add rate limits, add caching, add observability).
Reis's thinking: make agents warehouse-native. Give each agent its own analytical engine. Let them exchange data peer-to-peer through contracts that are cryptographically enforced.
The inversion matters because it changes where trust lives. In the centralized warehouse model, trust is institutional — you trust the warehouse because the data team built and maintains it. In the Reis model, trust is cryptographic — you trust a data slice because its provenance DAG, semantic contract digest, and content hash are all verifiable, deterministically, without appealing to any human authority.
This is a profound shift. It means an agent receiving data from another agent doesn't have to trust the producing agent as an institution. It can verify the contract mathematically.
What Contracts Agents Need
Reis's prototype implements a three-layer contract system that deserves to become a standard pattern.
The semantic contract (Malloy models) establishes meaning — what does "revenue" mean, what does "active user" mean, what grain is this data at? The structural compatibility layer classifies any change as IDENTICAL, ADDITIVE, BREAKING, or UNRELATED, and Reis is explicit that this classification must be deterministic: using an LLM to decide whether a contract change is IDENTICAL, ADDITIVE, or BREAKING would make the compatibility boundary probabilistic. The intent contract lets consumers declare what they need, and a resolver converts that mutable request into a pinned, immutable reference.
This is what data contracts should have always been. Not documentation. Not gentleman's agreements between teams. Cryptographically enforced, machine-checkable, version-pinned, with lineage carried inside the artifact itself.
What This Means for Data Architecture
The implications are bigger than DuckDB. What Reis is pointing at is a future where analytical data architecture looks less like a central nervous system and more like a distributed ledger of immutable facts exchanged between autonomous agents.
The data team's role doesn't disappear — it shifts. Instead of owning the warehouse and managing access, data engineers become the authors of semantic contracts: the Malloy models, the provenance schemas, the trust hierarchies that define what WAREHOUSE-tier data means versus DERIVED-tier data. The warehouse becomes one authoritative principal among many, not the single source of truth.
For data architects, this is both liberating and destabilizing. Liberating because the impossible mandate — maintain a single consistent semantic layer for all possible consumers at all possible scales — finally has an escape hatch. Destabilizing because every assumption about governance, tooling, and team structure needs to be revisited.
The shared data warehouse was designed for a world where humans asked questions. The agent-native data layer Reis is prototyping is designed for a world where machines answer them.
We should start building for that world now.
Vladyslav Donchenko is a software engineer and founder of VSBD, building AI-powered platforms for PropTech. The same data-contract discipline Reis applies to analytical agents underlies the agentic orchestration layers we ship for real estate platforms — typed tool contracts, verifiable handoffs, no shared mutable state. If you're rethinking your data architecture for agentic AI, we can help.