Compared to the industry

How the industry gets business context into a data-answering model, and where dst's choices sit. (Survey as of 2026-08; public sources cited inline, secondhand numbers flagged as such.)

The five patterns

Pattern	Mechanism	Exemplars	Characteristic failure
A. Compiled semantic model → prompt	curated bounded model injected deterministically	dst (whole model), Snowflake Cortex Analyst (agent-selected parts), WrenAI MDL	plausible-wrong SQL where the model is thin
B. Compiled metric layer → tool call	LLM requests metrics by name; engine compiles SQL	dbt MCP, Cube; dst's intent path; Genie UDFs	coverage cliff — uncovered question = error
C. Curated corpus → RAG	embedded DDL/docs/prose retrieved top-k	Vanna, dst context chunks, Cortex literal retrieval	retrieval misses; stale corpus
D. Agentic exploration	model forages files/search tools + execution feedback	Vercel d0, ktx, nao, the Spider 2.0 leaderboard	latency, cost, nondeterminism; needs a frontier model
E. Verified-query serving	human-certified question→SQL: verbatim on match, exemplars otherwise	dst (3 thresholds), Genie trusted assets (binary), Snowflake VQR (opaque), Vanna pairs (few-shot only)	covers the head, not the tail

Two overlays cut across the patterns: deterministic guards (dst's SQL/filter/time guards and refusals; Cube's compile-time row security; Cortex's ambiguity rejection) and the learning loop (Genie knowledge mining, VQR suggestions plus regression evals, ktx memory ingest, dst's review rail and history bootstrap — the continuous audit engine is dst's paid tier, not OSS). dst runs A + C + E with both overlays, and B partially (the intent compiler).

The players

Vercel d0 — the purest agentic-filesystem pattern. Their v1 had 15+ tools at ~80% success; v2 deleted most of the tooling down to two — bash-in-a-sandbox over mounted semantic-layer files plus ExecuteSQL, on a frontier model — and reports 80%→100% success, 3.5× faster, −37% tokens on their 5-query internal benchmark (n=5 — directional, not statistical). Public sources confirm the catalog shapes (grain, example questions, use cases, sample values, join relationships); several details circulating from their talk are publicly unverified. (vercel.com/blog/we-removed-80-percent-of-our-agents-tools)

ktx / Kaelio — Apache-2.0 context layer: a git-committed semantic-layer/ (YAML measures/joins compiled deterministically to SQL), wiki/ markdown business rules, a value dictionary, skills, and memory ingest. Consumed via MCP with four-lane hybrid search. Their own blog acknowledges no answer-correctness evaluation. Spider 2.0-Lite 73.67 (3rd). Two numbers often quoted from their reverse-engineering of an internal Anthropic analytics engine — 21%→95%+ credited to a skills layer, and raw-trace retrieval moving accuracy under one point — are secondhand and should be read as such. (github.com/Kaelio/ktx)

nao — Apache-2.0 analytics agent builder: scaffolded context folders, RULES.md, MCP integrations, and nao test — unit tests with expected SQL, the closest OSS analogue to dst's eval story. No published accuracy numbers.

Snowflake Cortex Analyst — semantic model YAML plus the Verified Query Repository. Inference is a multi-agent pipeline with an ambiguity-rejection classifier (the industry's other refuse-on-ambiguity implementation), verified-query retrieval, parallel generators, and a compiler-driven correction loop. VQR guides generation — no documented verbatim-serving tier, no published thresholds. Claims 90%+ accuracy on an internal ~150-question suite — internal, unverified.

Databricks Genie — Unity Catalog metadata, plain-text instructions, example SQL, and trusted assets: parameterized queries/UDFs served verbatim on match and labeled trusted — a binary version of dst's graduated tiers. Knowledge mining suggests reusable expressions from usage. Ambiguity handling is curator hygiene in the docs, not a runtime mechanism. No first-party accuracy numbers.

dbt Semantic Layer / Cube — pattern B in pure form: for covered questions the LLM never writes SQL; it requests metrics by name and the engine compiles. A wrong join is impossible; the failure mode is an error. dbt's benchmark: near-100% for covered queries vs 64.5% raw text-to-SQL on the same set (11 questions — small). Cube's angle is compile-time governance: a query crossing tenant rows cannot compile. dst's intent path is this pattern, with graceful escalation to guarded SQL generation instead of a cliff.

Vanna / WrenAI — Vanna: RAG over DDL, docs, and question-SQL pairs; accuracy is explicitly a function of training data. WrenAI: a JSON semantic model consulted at generation. Neither has a certification tier.

The research picture — Spider 2.0 (real enterprise schemas) collapsed GPT-4o from 86.6% on Spider 1.0 to 10.1% at launch: the enterprise cliff. The 2026 leaders are agentic loops with execution feedback. The converged findings map onto dst's stack: schema linking ≈ the bounded lens model; few-shot exemplar selection ≈ certified assist; and Tk-Boost (arXiv:2602.13521) — distilled "tribal knowledge" indexed with applicability conditions, +16.9% on Spider 2.0 across agents — is academic validation of curated-judgment-with-routing, which is what definitions, use cases, and certified answers are.

The honest delta

Where dst is ahead of published practice:

1. Graduated similarity-tiered certified serving — ≥0.95 verbatim, ≥0.90 paraphrase-gated, ≥0.83 few-shot exemplars (services/runtime/assembly.py:54). Nobody else publishes thresholds; Genie is binary, Snowflake opaque.
2. Ambiguity as a first-class governed artifact — a curated registry of ambiguous terms with deterministic clarification. Cortex rejects ambiguous questions but has no registry; Genie punts to hygiene.
3. Publish-time enforcement of definition-bound filters (sqlglot-validated) and the other deterministic guards — Genie stores expression snippets but does not enforce them.
4. Certified answers double as a regression suite, re-verified when the schema they bind to changes — VQR's regression evals are the nearest thing, and they don't re-stamp provenance.

Where dst is behind or exposed:

1. No agentic-exploration path. d0's result (n=5) and the Spider 2.0 leaderboard argue that for tail questions, a frontier model foraging with execution feedback beats single-pass generation over injected context. dst's pipeline is one generation and a bounded repair round; its one result-driven retry is deliberately narrow — a zero-row result behind a string-literal filter triggers a deterministic value investigation (committed dictionary check, else one governed DISTINCT probe) and repairs from what it learns. Free-form foraging stays unbuilt. [bet] The counterargument — cost, latency, and determinism for production traffic — is a bet, not a finding, and is held open to measurement.
2. No published accuracy numbers while Snowflake claims 90%+, dbt near-100%-covered, and the Anthropic-via-ktx figure circulates at 95%+. Deliberate: dst's internal runs are small-n and stay internal — nothing ships as a benchmark claim until there is a benchmark worth the name.
3. Serving context to any agent is the industry's default motion (ktx, dbt MCP, Cube all expose context for the agent to reason over). [bet] dst's answer-path stance — serve governed answers, not context — is a deliberate difference, not parity, and is argued rather than assumed.
4. Retrieval is blunt: fixed-window chunking, no similarity floor, no reranking — below current practice for the RAG lane of the product's class.