Disclosure: This article is published by Upsolve AI. Where our product is mentioned alongside competitors, we aim to provide balanced coverage based on publicly available information. We encourage readers to evaluate all options independently.

The Cube semantic layer is a code-first modeling layer that defines metrics, dimensions, joins, and access rules once, then serves them to BI tools, spreadsheets, embedded analytics, and AI agents through SQL, REST, GraphQL, and MCP. Cube started as the open-source project Cube.js. Today it’s two things: Cube Core, the open-source semantic layer with about 21,000 GitHub stars, and the Cube platform, a commercial agentic analytics product built on top.

Most of what’s written about Cube is either Cube’s own marketing or out of date. This guide is an independent, current look at how Cube works, what its AI features actually do in 2026, what it costs, and how it compares with the dbt Semantic Layer. It also covers where Cube is strong and what to pressure-test before you commit.

What Is the Cube Semantic Layer?

Cube is a standalone (“headless”) semantic layer. You define cubes (usually one per table) with measures, dimensions, and joins, then publish curated views to consumers. Every tool that queries Cube gets the same definitions and the same access rules. Cube co-founder and CEO Artyom Keydunov and co-founder Pavel Tiunov built it out of Statsbot, a 2016 natural-language Slack bot, and open-sourced it in 2019.

A few reference facts:

• Open source: Cube Core uses Apache 2.0 for the backend and MIT for client libraries.

• Adoption: At its June 2024 $25M funding round, led by Databricks Ventures ($48M raised in total), Cube reported 90,000 servers, 4.9 million users, and roughly 20% of the Fortune 1000.

• Recognition: Cube was named a Representative Vendor in Gartner’s February 2026 Market Guide for Agentic Analytics.

• Customers: Brex, Webflow, Drata, Wix, and Intuit appear on Cube’s site. Brex’s case study describes an embedded AI financial analyst for 35,000+ customers.

How Cube Works: The Four Pillars

Cube’s docs organize the product around four pillars: data modeling, access control, caching, and APIs.

Data Modeling: Cubes and Views

Models are written in YAML or JavaScript. Python and Jinja can template them, but they aren’t a model language. Here’s a minimal example from Cube’s joins documentation:

cubes:
-name: orders
sql_table: orders
joins:
-name: customers
relationship: many_to_one
sql:"{CUBE}.customer_id = {customers.id}"
dimensions:
-name: id
sql: id
type: number
primary_key:true
-name: status
sql: status
type: string
measures:
-name: count
type: count

-name: customers
sql_table: customers
dimensions:
-name: id
sql: id
type: number
primary_key:true
-name: company
sql: company
type

cubes:
-name: orders
sql_table: orders
joins:
-name: customers
relationship: many_to_one
sql:"{CUBE}.customer_id = {customers.id}"
dimensions:
-name: id
sql: id
type: number
primary_key:true
-name: status
sql: status
type: string
measures:
-name: count
type: count

-name: customers
sql_table: customers
dimensions:
-name: id
sql: id
type: number
primary_key:true
-name: company
sql: company
type

cubes:
-name: orders
sql_table: orders
joins:
-name: customers
relationship: many_to_one
sql:"{CUBE}.customer_id = {customers.id}"
dimensions:
-name: id
sql: id
type: number
primary_key:true
-name: status
sql: status
type: string
measures:
-name: count
type: count

-name: customers
sql_table: customers
dimensions:
-name: id
sql: id
type: number
primary_key:true
-name: company
sql: company
type

cubes:
-name: orders
sql_table: orders
joins:
-name: customers
relationship: many_to_one
sql:"{CUBE}.customer_id = {customers.id}"
dimensions:
-name: id
sql: id
type: number
primary_key:true
-name: status
sql: status
type: string
measures:
-name: count
type: count

-name: customers
sql_table: customers
dimensions:
-name: id
sql: id
type: number
primary_key:true
-name: company
sql: company
type

Measures can carry filters (a paying_count that only counts paying customers) or be computed from other measures (paying_percentage). Views sit on top of cubes. They select the members consumers see and make join paths explicit, which matters for both BI tools and agents. Together, cubes and views form Cube’s semantic model.

Access Control

Cube enforces row-level security, member-level access (which measures and dimensions a group can see), and data masking in the semantic layer, before any SQL reaches the warehouse. Because the compiler, not the agent, enforces those policies, an agent acting for one tenant can’t construct a query that returns another tenant’s rows. This is a big reason Cube is popular for customer-facing analytics.

Caching With Pre-Aggregations

Pre-aggregations are rollups you declare in the model. Cube refreshes them in the background, stores them in Cube Store (its own caching engine), and routes matching queries to them automatically. Cube cites a query over 1.2 billion rows dropping from 12.4 seconds to 180 milliseconds on a pre-aggregation. That’s a vendor figure, but the mechanism is the main thing that separates Cube from metrics layers that rely on the warehouse alone.

APIs and Interfaces

There’s no JDBC driver; BI tools connect as if Cube were a Postgres database.

Cube’s AI Features in 2026: From D3 to Analytics Chat

Cube launched its AI product as D3 in June 2025, with an AI data analyst and an AI data engineer. In 2026 the D3 name has faded, and the features are simply part of the Cube platform.

Analytics Chat and the Agents

Analytics Chat is Cube’s natural-language interface: business users ask questions in plain English and get answers grounded in the views you’ve published. Around it sit a Workbook Agent, a Dashboard Agent, a Slack agent, scheduled natural-language tasks, and, since October 2026, AI inside Google Sheets and Excel. The managed agent runs on Claude models, and Enterprise customers can bring their own model.

Semantic SQL: Why the Compiler Owns the Query

This is Cube’s most important design choice. Per Cube’s docs, its “AI agents don’t query the warehouse directly. They query the semantic layer using Semantic SQL”, a Postgres-compatible interface with a MEASURE() function:

SELECT DATE_TRUNC('month', created_at) AS month, MEASURE(count) AS orders_count
FROM orders
GROUP BY 1

SELECT DATE_TRUNC('month', created_at) AS month, MEASURE(count) AS orders_count
FROM orders
GROUP BY 1

SELECT DATE_TRUNC('month', created_at) AS month, MEASURE(count) AS orders_count
FROM orders
GROUP BY 1

SELECT DATE_TRUNC('month', created_at) AS month, MEASURE(count) AS orders_count
FROM orders
GROUP BY 1

The agent picks measures and dimensions; Cube’s compiler validates them against the model and access policies, then generates the warehouse SQL. The LLM never writes the joins or the metric formula. Compare that with Snowflake’s Cortex Agents, which read a semantic view and then generate SQL against base tables.

The MCP Server and Chat API

Cube’s hosted MCP server is available on all plans, uses OAuth, and is listed in Claude’s connector directory. It exposes 30 tools: searching the data model, running queries, building workbooks and dashboards, and even editing the data model on a development branch with diffs and pull requests. Some older third-party guides say MCP is limited to Premium plans; that’s no longer true. The Chat API lets other agents call Cube’s agent as a tool.

Rules, Certified Queries, and Evals

Since April 2026, agent configuration lives in an agents/ folder in your model repo:

• Rules: Markdown instructions the agent follows.

• Certified queries: A library of trusted question-and-SQL examples. The agent can use, adapt, or ignore them, so they guide rather than enforce.

• Evals: Questions with ground-truth SQL that run per branch and produce an accuracy score.

• Memories and chat history review: For learning from usage, with tenant isolation.

If you read an older review, including a previous version of this article, that said Cube has no trust loop, that’s outdated.

Cube Pricing (2026)

AI usage is metered in tokens. On-demand customers get a token grant worth half their seat price, with overage billed on top (Cube pricing).

Cube vs dbt Semantic Layer

When to Use Both

Many teams transform data with dbt and serve it through Cube. Cube’s own guidance is “model in dbt, serve through Cube.” The catch: Cube’s dbt integration converts dbt models, columns, and relationships into cubes, but dbt metrics and semantic models aren’t imported. If you already have MetricFlow metrics, you’ll redefine them in Cube or choose one tool to own metric definitions. Decide that up front.

When the dbt Semantic Layer Is Enough

If your consumers are internal BI tools that dbt already integrates with, your warehouse handles concurrency fine, and you don’t need tenant-level security in the semantic layer, the dbt Semantic Layer keeps everything in one project. Cube earns its extra moving parts when you’re serving many tenants, need sub-second dashboards, or want a built-in agent.

Cube and the Warehouse-Native Semantic Layers

Cube has added sync with the platform-native semantic layers, all in preview as of October 2026:

• **Snowflake semantic views:** Bi-directional pull and push (Enterprise).

• **Databricks metric views:** One-way publishing of Cube views as Unity Catalog metric views. Cube’s access policies don’t transfer, and views with policies are blocked from publishing.

• Apache Ossie: Import and export between Cube YAML and the Apache Ossie spec (formerly the Open Semantic Interchange).

These are useful, but notice the pattern: definitions can move between systems, but security policies mostly can’t.

Where Cube Is Strong, and What to Pressure-Test

Cube’s strengths are real: governance enforced by a compiler, fast cached queries, broad API coverage, a credible open-source core, and an agent that can’t write ungoverned SQL. Before committing (and comparing it with the alternatives in our semantic layer tools guide), test five things:

1. Modeling effort. Agents only see the views you model. Entities and relationships outside them, the territory of a data ontology, stay invisible. One r/dataengineering commenter said YAML metrics “felt janky every time we had a metric that was bit more complex.”

2. Maintenance. Someone has to keep cubes, views, rules, and certified queries current as the warehouse changes.

3. Self-hosting Core. Production needs API instances, refresh workers, and Cube Store, which is real operational work.

4. Plan gating. Power BI (DAX), Excel (MDX), and bring-your-own LLM require Enterprise.

5. Eval coverage. Evals measure the questions you write, so a high score on 30 curated questions says little about the long tail real users ask.

One more point worth reading carefully. Cube’s paired benchmark showed a 17–23 point accuracy gain across Claude Opus 4.7, Claude Sonnet 4.6, and GPT-5.4. But the “semantic layer” in that test was a 4 KB markdown document of business context, not a compiled Cube model. The lesson is that business context drives accuracy, which is the idea behind a context layer. A full semantic layer is one way to provide it, not the only one.

What If You Don’t Have a Semantic Layer Yet?

Cube works best once a well-authored model exists. If yours doesn’t, the modeling project comes before any agent value. Upsolve Data Models takes the other route: no semantic layer required.

• Start from your warehouse: Register tables with descriptions, types, and primary and foreign keys, like a data dictionary built for agents.

• Encode definitions once: Canonical metrics, analysis approaches, and output formats live in a versioned system prompt.

• Know the values: Mark columns as selectable and Upsolve pre-caches their values nightly, so the agent knows every status before writing SQL.

• Grow from real gaps: Harness 2.0 traces every conversation, and the eval agent surfaces what’s missing.

If you already have a dbt project, bring it in. Either way, you add definitions as real questions expose gaps, instead of modeling everything first.

Frequently Asked Questions

What is the Cube semantic layer?

Cube is a code-first semantic layer that defines metrics, dimensions, joins, and access policies in YAML or JavaScript and serves them to BI tools, apps, and AI agents through SQL, REST, GraphQL, and MCP. The open-source version is Cube Core; the commercial Cube platform adds AI agents, workbooks, and hosting.

Is Cube open source?

Yes. Cube Core is open source, with an Apache 2.0 backend and MIT-licensed client libraries, and it has about 21,000 GitHub stars. The AI agents, workbooks, dashboards, and managed hosting are part of the commercial Cube platform.

What does Cube AI do?

Cube’s AI features let business users ask questions in plain language through Analytics Chat, Slack, or spreadsheets. The agents query the semantic layer using Semantic SQL, and Cube compiles the governed warehouse SQL. Workbook and dashboard agents build reports, and an AI data engineer helps edit the model.

Does Cube have an MCP server?

Yes. Cube offers a hosted MCP server on all plans, with OAuth and 30 tools for searching the model, running queries, building dashboards, and editing the model on development branches. It works with Claude, Cursor, Microsoft 365 Copilot, and Codex.

What is Cube.js used for?

Cube.js was the original name of Cube’s open-source project. It’s used to build a headless semantic layer and APIs for embedded analytics, customer-facing dashboards, and internal BI, with caching for fast queries. The project is now called Cube Core.

Who is the CEO of Cube Dev?

Artyom Keydunov is Cube’s co-founder and CEO. He co-founded the company with Pavel Tiunov, initially building Statsbot before open-sourcing Cube in 2019.

Should I use Cube or the dbt Semantic Layer?

Choose Cube for embedded or multi-tenant analytics, high-concurrency dashboards, and a built-in AI agent. Choose the dbt Semantic Layer if you’re dbt-centric and want metrics versioned next to transformations. If you use both, note that Cube doesn’t import dbt metrics.

Sources

1. GitHub: cube-js/cube. https://github.com/cube-js/cube

2. Cube Docs: Introduction. https://docs.cube.dev/docs/introduction

3. Cube Docs: Joins. https://docs.cube.dev/docs/data-modeling/joins

4. Cube Docs: dbt integration. https://docs.cube.dev/docs/integrations/dbt.md

5. Cube Docs: MCP server. https://docs.cube.dev/docs/integrations/mcp-server.md

6. Cube Docs: Certified queries. https://docs.cube.dev/admin/ai/certified-queries.md

7. Cube Docs: Databricks metric views integration. https://docs.cube.dev/docs/integrations/databricks-metric-views.md

8. Cube: Pricing. https://cube.dev/pricing

9. Cube: Announcing Cube D3 (Jun 2025). https://cube.dev/blog/announcing-cube-d3

10. Cube: Brex case study. https://cube.dev/case-studies/brex-embedded-ai-financial-analyst

11. Cube: Paired benchmark across three frontier models (Apr 2026). https://cube.dev/blog/why-semantic-layers-make-llm-analytics-reliable-a-paired-benchmark-across-three-frontier-models

12. DBTA: Cube Raises $25M (Jun 2024). https://www.dbta.com/Editorial/News-Flashes/Cube-Raises-25M-to-Supercharge-the-Universal-Semantic-Layer-Backed-by-Databricks-164448.aspx

13. Latent Space: Powering your Copilot for Data, with Artem Keydunov. https://www.latent.space/p/cube

14. Reddit r/dataengineering: Poll: Do you have a semantic layer? https://www.reddit.com/r/dataengineering/comments/1ne90j9/poll_do_you_have_a_semantic_layer_and_if_so_how/

15. Upsolve AI: Data Models. https://upsolve.ai/features/data-models