Datus Blog
Evan Paul·

Cube.dev: From Semantic Layer Pioneer to Agentic Analytics Platform ​

In 2019, Cube was an open-source framework for building analytics dashboards — a React component library with a caching layer. By 2022, it had repositioned as a headless semantic layer — the dashboards were still there, but the real product was the API that served governed metrics to any frontend. In June 2025, it launched D3, a platform built around AI agents that consume those metrics — not as an add-on feature, but as the primary interface. That arc — from dashboard framework to semantic infrastructure to agentic platform — is not a pivot. It is a thesis playing out in three acts: the dashboard is a commodity, the semantic layer is the durable asset, and AI agents are its natural consumers. This article traces Cube's evolution, examines its architecture, and explains what its trajectory toward agentic analytics means for the data engineering agent category — including where Cube and Datus converge and where they make fundamentally different architectural bets.

TL;DR ​

  • Cube started as Cube.js (2019), an open-source dashboard framework. It evolved into a universal headless semantic layer — defining metrics, dimensions, and relationships in code (JS/YAML/Python), serving them through SQL, REST, and GraphQL APIs.
  • D3 (June 2025) is Cube's agentic analytics platform: AI Data Analyst and AI Data Engineer agents that generate semantic models, answer analytical questions, and create data apps — all grounded in the semantic layer.
  • Cube's core architecture: cube data models define data sources (measures, dimensions, joins) → CubeSQL (Postgres-compatible SQL) + REST/GraphQL APIs serve them → CubeStore (Rust-based OLAP engine) caches hot queries to <50ms → D3 agents orchestrate on top of the entire stack.
  • Cube and Datus are directionally convergent — both moving toward "semantic layer + agent" — but from opposite starting points: Cube from the consumption/API side upward, Datus from the engineering/context side downward.
  • The key architectural difference: Cube embeds agents as consumers of the semantic layer (agents query Cube's API). Datus treats agents as producers and evolvers of context (agents build and refine the semantic layer itself).

1. Cube's evolution: three eras ​

Era 1: Cube.js — the open-source dashboard framework (2019–2022) ​

Cube started as Cube.js, an open-source framework for building analytics dashboards. The core insight: every analytics application re-implements the same infrastructure — a metrics layer, a caching layer, a query API, a charting library. Cube.js bundled those into a framework and let developers build custom analytics applications faster.

This era established Cube's technical DNA: API-first design, multi-database support (20+ data sources), and pre-aggregation caching — the CubeStore OLAP engine that materializes hot queries for sub-50ms response times. It also built Cube's open-source community: 20K+ GitHub stars, 90K+ server installs, thousands of contributors.

Era 2: The universal semantic layer (2022–2025) ​

Around 2022, Cube repositioned from "dashboard framework" to "headless BI" and then to "universal semantic layer." The shift was architectural: Cube's metrics layer — previously the plumbing for dashboard applications — became the product. Teams could define metrics in Cube, govern them centrally, and consume them through any frontend: Cube's own dashboards, embedded analytics, custom React apps, BI tools, or machine learning pipelines.

Key architectural decisions from this era:

  • Multi-protocol API: CubeSQL (Postgres-compatible SQL), REST, and GraphQL — so any tool that speaks SQL or HTTP can consume Cube metrics.
  • Cube data models: JavaScript or YAML definitions that map physical tables to business concepts — measures, dimensions, segments, joins, pre-aggregations.
  • Cube Store rewritten in Rust: The caching engine was rewritten in Rust for orders-of-magnitude performance gains — reflecting Cube's bet that query caching is the hardest problem in headless analytics at scale.
  • Dresner #1 ranking: Cube was ranked #1 in Dresner Advisory's 2025 Semantic Layer Market Study, validating the category and Cube's leadership position.

Era 3: D3 and agentic analytics (2025–present) ​

On June 2, 2025, Cube launched D3 — an agentic analytics platform that introduces AI data co-workers as first-class platform features:

  • AI Data Analyst: Natural-language analytics grounded in the semantic layer. Generates trusted Semantic SQL, auto-generates visualizations, and builds interactive data apps — all constrained by governed metric definitions.
  • AI Data Engineer: Automates semantic model creation from cloud data sources. Continuously optimizes definitions based on query patterns and usage.

The core architectural bet: LLMs query through the semantic layer, not around it. Instead of giving an AI agent raw database access and hoping it generates correct SQL, Cube routes every agent query through its semantic API. The semantic layer acts as a trusted data proxy — enforcing metric definitions, access controls, and query governance automatically. Cube calls this "the Cursor moment for data analytics."

2. Cube's architecture: how the pieces fit together ​

┌─────────────────────────────────────────────────┐
│                 D3 AGENT LAYER                    │
│  AI Data Analyst  ·  AI Data Engineer            │
│  Natural-language → semantic-grounded analytics  │
├─────────────────────────────────────────────────┤
│              SEMANTIC API LAYER                   │
│  CubeSQL (Postgres)  ·  REST  ·  GraphQL         │
│  "One API for all metrics, all tools"            │
├─────────────────────────────────────────────────┤
│            SEMANTIC MODEL LAYER                   │
│  Cube data models (JS/YAML/Python)               │
│  Measures · Dimensions · Joins · Pre-aggregations │
├─────────────────────────────────────────────────┤
│              QUERY EXECUTION LAYER                │
│  CubeStore (Rust OLAP cache)  ·  Multi-DB SQL    │
│  27+ data sources: Snowflake, BigQuery, etc.     │
└─────────────────────────────────────────────────┘

The critical design principle: the semantic layer sits between every consumer and the database. No consumer — human analyst, BI tool, embedded dashboard, AI agent — accesses raw tables directly. Every query passes through Cube's semantic API, which resolves metric definitions, enforces access control, applies pre-aggregation caching, and generates optimized SQL. For AI agents specifically, this means the model never sees raw schema — it sees governed business objects, and the semantic layer handles the translation to physical SQL.

Cube's competitive framing: "LLMs should not query databases. LLMs should query semantic layers that query databases." This is the argument that a semantic layer is mandatory infrastructure in the AI era — not optional governance, but the only safe path to AI-powered analytics.

3. Cube and Datus: convergent trajectories, different starting points ​

Cube and Datus are moving toward the same destination — a world where AI agents work reliably on top of governed data context — from opposite directions:

DimensionCubeDatus
Starting pointConsumption: "How do we serve metrics to any tool?"Engineering: "How do we build and evolve data context?"
Core abstractionCube data models — define a data source, serve it through APIsContext Engine — dual-dimension tree (Physical Catalog × Logical Subject)
Agent roleAgents consume the semantic layer — they query Cube's APIAgents produce and evolve context — they build semantic models, generate metrics, capture validated SQL
Delivery modelCloud platform + open-source core (MIT)Open-source core (Apache 2.0) + Cloud Personal + Enterprise
Primary userAnalytics developers, BI teams building data productsData engineers building agent infrastructure
Caching strategyCubeStore (Rust OLAP) — materialized pre-aggregationContext caching — validated SQL and semantic models reused across queries
Feedback loopQuery-level — agent-generated SQL validated by semantic constraintsContinuous — user upvotes, issue reports, and corrections feed back into context evolution

The two are not direct competitors — they occupy different tiers of the data agent stack (see what is a data agent). Cube is the consumer tier: a platform for serving governed metrics to any tool, including AI agents. Datus is the producer tier: a system for building and continuously evolving the context that both human analysts and AI agents consume.

In a fully realized architecture, they are complementary: Datus generates and evolves semantic models and metrics; Cube serves them through APIs with caching, access control, and multi-tool distribution. An organization could use both — Datus for context creation and evolution, Cube for context distribution and consumption.

4. What Cube's trajectory signals about the market ​

Cube's evolution from dashboard framework → headless semantic layer → agentic analytics platform is not a unique path — it reflects a broader market pattern:

Signal 1: The semantic layer is infrastructure, not a feature. Cube bet its entire product on this thesis years ago, and the market has validated it. When Databricks Ventures invested $25M in Cube, they were investing in semantic infrastructure — not dashboard tooling. The OSI standard (see Open Semantic Interchange explained) further validates this: metrics are becoming portable infrastructure, not tool-specific features.

Signal 2: AI agents need a governed semantic layer to be trustworthy. Cube's "LLMs query semantic layers, not databases" argument is increasingly the consensus. Giving an AI agent raw database access produces confident wrong answers. Routing agent queries through a governed semantic layer produces answers grounded in certified business logic. This is not a Cube-specific insight — it is an architectural requirement for any production AI analytics deployment.

Signal 3: Agentic analytics is the next battleground. Cube's D3 launch signals that the semantic layer is not the end state — it is the foundation for an agentic layer on top. The question is not "do you have a semantic layer?" but "what agents operate on top of it, and how do they improve it over time?" This is where Datus's approach — agents as producers and evolvers of context, not just consumers — represents a different architectural bet.

Signal 4: Consolidation is likely. With Cube, MetricFlow, OSI, and multiple BI-native semantic layers converging on the same problem space, the semantic layer market is heading toward consolidation. The players that survive will be the ones that either own the consumption surface (Cube, Looker) or the creation/evolution surface (Datus, Altimate) — and ideally, those surfaces interoperate through standards like OSI.

5. What data engineers should watch ​

Cube's Rust rewrite. CubeStore and the Tesseract query optimizer are now predominantly Rust (52.2% of the repo). This is not a cosmetic change — it reflects a bet that query caching and pre-aggregation at scale require systems-level performance that JavaScript/TypeScript cannot deliver. Data engineering teams evaluating Cube should understand the caching architecture in detail: pre-aggregation works beautifully for predictable workloads and can struggle with highly ad-hoc query patterns.

D3 agent reliability. The AI Data Analyst and AI Data Engineer agents are new (June 2025). The core question for production adoption: how often do they generate wrong answers, and what is the correction path? Cube's semantic layer grounding should reduce hallucination relative to raw-schema agents, but the feedback loop — when an agent gets something wrong, how does the correction propagate — is the metric that separates demo-ready from production-trustworthy.

Cube + dbt integration. Cube can read dbt models and metadata, but the integration is not as deep as MetricFlow's native dbt integration. Teams using dbt for transformations and Cube for semantics should validate that the two systems stay synchronized — particularly around model changes, column renames, and deprecation.

OSI compatibility as an exit strategy. Cube's participation in OSI is a strong signal that they are committed to open standards. Teams adopting Cube should explicitly validate that their metric definitions can be exported in OSI format — ensuring portability if the semantic layer landscape shifts.

Conclusion ​

Cube's arc — dashboard framework → headless semantic layer → agentic analytics — is the industry's arc in miniature. The semantic layer, once a feature of the BI tool, has become the platform's center of gravity. The consumption surface, once the product, has become a commodity. And the question that Cube's D3 raises — "what agents operate on top of the semantic layer, and who builds the context they consume?" — is the question every data team will need to answer within the next two years. Cube's answer is that agents should consume the semantic layer through governed APIs, with the semantic layer acting as a trusted proxy that constrains what agents can query and how. This is the right answer for the consumption tier. The complementary question — who builds and continuously evolves the semantic layer that Cube's agents consume — is where the producer tier operates. Cube provides excellent distribution. The creation and evolution of what gets distributed is a separate problem, and the organizations that treat it as such — investing in both the consumption surface and the context-creation pipeline — will field agents that are not only well-served but continuously improving.

Frequently asked questions ​

What is Cube.dev? ​

Cube.dev is an open-source universal semantic layer and, since June 2025, an agentic analytics platform (D3). It lets teams define metrics, dimensions, and relationships in code (JS/YAML/Python), serve them through SQL, REST, and GraphQL APIs, and now deploy AI agents (AI Data Analyst, AI Data Engineer) that operate on top of the governed semantic layer. ~20K GitHub stars, used by 5M+ users, $46.7M funding.

What is Cube D3? ​

D3 is Cube's agentic analytics platform, launched June 2025. It introduces AI Data Analyst (natural-language analytics grounded in semantics) and AI Data Engineer (automated semantic model creation) as first-class platform features, with the semantic layer acting as a trusted proxy that constrains AI agent queries to governed definitions.

How is Cube different from dbt Semantic Layer / MetricFlow? ​

Cube is API-centric — metrics served through SQL, REST, and GraphQL APIs for any tool to consume. MetricFlow is Git-centric — metrics defined in YAML in a dbt project, governed through PRs and CI/CD. Cube is strongest in embedded analytics and multi-tool distribution; MetricFlow is strongest in dbt-native transformation environments. Both participate in OSI and are moving toward agentic analytics.

Is Cube a competitor to Datus? ​

Not directly — they occupy different tiers of the data agent stack. Cube is the consumer/distribution tier: serve governed metrics to any tool, including AI agents. Datus is the producer/evolution tier: build and continuously refine the context (semantic models, metrics, reference SQL) that both humans and agents consume. They are architecturally complementary: Datus generates context; Cube distributes it.

Built with VitePress

Copyright © 2025 Datus.ai