cs.DBMar 11, 2026
SaveQuerying Everything Everywhere All at Once: Supervaluationism for the Agentic Lakehouse
Organizations: Bauplan Labs New York, USA
Abstract
Agentic analytics is turning the lakehouse into a multi-version system: swarms of (human or AI) producers materialize competing pipelines in data branches, while (human or AI) consumers need answers without knowing the underlying data life-cycle. We demonstrate a new system that answers questions across branches rather than at a single snapshot. Our prototype focuses on a novel query path that evaluates queries under supervaluationary semantics. In the absence of comparable multi-branch querying capabilities in mainstream OLAP systems, we open source the demo code as a concrete baseline for the OLAP community.
Figures & tables
Figure 1. ACME Inc. demo scenario: three agentic pipelines run concurrently on lakehouse branches, producing divergent versions of analytical tables. When a user asks a question, can we answer it without assuming a canonical data representation?
Figure 2. Architecture of the demo system. Agentic pipelines write predictions into isolated data branches of the lakehouse. The UI translates English questions into SQL, then executes them using a modified OLAP engine that evaluates answers across branches under supervaluationary (glut-tolerant) semantics.
| ID | User-facing question | Result type |
| Q1 | How many customers are expected to buy tomorrow? | Number |
| Q2 | How many smartphone shoppers will convert tomorrow? | |
| Q3 | How many customers in the top segments are expected to buy tomorrow? | |
| Q4 | Is tomorrow’s conversion rate above ? | Boolean |
| Q5 | Is customer expected to buy tomorrow? | |
| Q6 | Which customers are expected to buy tomorrow? | List |
Table 1. Sample questions by result type
Figure 3. Speedup of the native engine over the ad hoc strategy as a function of branch count. The JOIN query with window functions (Q3) benefits from shared-table reuse; the boolean query (Q4) achieves near-constant time via short-circuit evaluation.
Appendix figures & tables2 assets
Supplementary material from the paper’s appendix.
Appendix
| Q | Engine | 1 | 2 | 4 | 8 | 16 | 32 | 50 |
|---|---|---|---|---|---|---|---|---|
| Q1 | Ad hoc | 1 | 4 | 5 | 11 | 21 | 41 | 62 |
| Q1 | Native | 3 | 13 | 15 | 25 | 44 | 88 | 136 |
| Q3 | Ad hoc | 288 | 327 | 732 | 1390 | 2537 | 5125 | 7856 |
| Q3 | Native | 366 | 389 | 392 | 412 | 461 | 562 | 657 |
| Q4 | Ad hoc | 4 | 6 | 9 | 19 | 34 | 67 | 103 |
| Q4 | Native | 4 | 5 | 8 | 9 | 11 | 10 | 11 |
Table 2. Median latency (ms) by engine and branch count.
Figure 4. Median latency (ms) vs. number of branches. Left: Q1, both engines scale linearly but the native engine’s unified plan carries coordination overhead (hash-repartitioning for GROUP BY ). Center: Q3, the ad hoc engine scales at ms/branch (recomputing window functions over the shared table), while the native engine stays nearly flat thanks to CTE reuse. Right: Q4, the native engine’s short-circuit optimization achieves near-constant ms latency.
We present GitLake, a Git-for-data design for an agent-first lakehouse. The system lifts single-table Iceberg snapshots into lakehouse-wide commits, branches, and merges, letting agents work on isolated branches while humans review and publish changes. Pipelines run on temporary branches and publish through a final merge, so all outputs become visible atomically or none do. Finally, we report production lessons as well as correctness insights from a preliminary Alloy model of our core abstractions.
LakeQuest: A Three-Domain Benchmark for Grounded Question Answering across Data Lakes
While modern question answering (QA) systems excel on clean, schema-aligned corpora, real-world knowledge is rarely so neatly packaged. Answering questions over enterprise and scientific data lakes requires systems to navigate heterogeneous, weakly structured collections of tables, passages, and linked metadata. Current benchmarks abstract away this noisy discovery process, failing to evaluate end-to-end performance. To bridge this gap, we introduce LakeQuest, a human-validated benchmark of 9,846 QA pairs designed to evaluate the end-to-end retrieve-and-synthesize pipeline over realistic data lakes. LakeQuest spans three diverse domains (AI/ML metadata, retail banking, and multimodal biomedical drug information) and pairs every question with exact, modality-aware evidence pointers. By isolating source discovery from cross-modal synthesis, LakeQuest exposes critical failure modes in modern QA systems. Our baseline evaluations, including standard Retrieval-Augmented Generation (RAG) and agentic tool-use methods, reveal that high-quality retrieval does not guarantee correct reasoning. Systems consistently struggle with relation chaining in metadata graphs, policy grounding in bank ledgers, and joint tabular QA in biomedical contexts, highlighting the need for robust discovery and faithful cross-file composition mechanisms in future agentic QA systems.
A Query Engine for the Agents
The fastest-growing data in production today is unstructured text: agent traces, chat logs, reasoning chains, model outputs. People want to analyze it, and the questions worth asking ("show me where the agent got confused") cannot be answered by SQL alone, since text is not queryable without a model in the query path. The natural place this analysis is happening is the new class of AI applications (Claude Code, Cursor, Claude Desktop, in-browser agents) that run client-side and host both a human user and an LLM agent in the same process. These applications increasingly want to work with data, but the lakehouse read path has been hard to use from a JS runtime: Spark, Trino, and managed warehouses do not fit there. To build this new kind of AI data application, three properties of the engine become first-order: a JS-native distribution that drops into the runtime the application already runs in, a bundle small enough to ship inside a cold tab or per-turn agent sandbox, and a way to interleave analytic operators with model-based interpretation of text. We present Hyperparam, three open-source JavaScript libraries (Hyparquet, Squirreling, Icebird) totaling under 70 KB, that read Parquet and Apache Iceberg directly from object storage and meet the third property with per-cell, async-native SQL execution, so expensive cells fire only when downstream operators demand them. Squirreling runs LLM-shaped async UDFs over 300x faster than DuckDB-WASM on filter-bounded queries (and 192x on sort-bounded queries) and completes a ten-task agent analyst suite at two-thirds lower cost. We argue that data engineering as a discipline needs to update for the AI-native client applications now in production and the agents that work alongside their users.