cube.dev Paid content

Cube's own site is the starting point for all three: Documentation and Guides for learning, Demos for seeing the product in action, and GitHub plus a Slack Community for peer support. All of these are linked directly from the cube.dev navigation, so you don't need to hunt through search results to reach them. The sections below cover what each entry point is for and how to pick the right one for your situation.

Learning resources: Documentation and Guides

Two separate entries appear in the site navigation under Resources:

• Documentation — the reference material for building on Cube, including the semantic layer, data modeling, and the APIs and MCP surface that agents connect through.
• Guides — task-oriented walkthroughs, better suited when you want to follow a path end to end rather than look up a specific concept.

If you are evaluating whether Cube fits your stack, start with Guides. If you already know what you're building and need exact behavior, go to Documentation.

Seeing the product: Demos

Demos is listed both in the main navigation and under Resources. The site also offers two direct paths for a live look:

The homepage also describes the embedded surfaces you'd be evaluating — Chat API, embedded iframes for Chat and Dashboards, Creator Mode, and Core Data APIs — so a demo request is most productive once you know which of those you're considering.

Community and code: GitHub and Slack

• GitHub — linked from the site's Company section, for the code itself.
• Slack Community — also under Company, for questions and discussion with other users.

Both are listed alongside About, Changelog, Customer Stories, Integrations, Security, and Partnerships, so they sit in the same place in the navigation.

Commercial and reference material

• Pricing — a dedicated page at cube.dev/pricing, linked from the main navigation. Check it directly for current commercial terms; the site's own description doesn't state plan details.
• Customer Stories — practical accounts of how teams use Cube. One example cited on the site: "Brex chose Cube over dbt Semantic Layer and LookML." These are useful for judging fit against a comparable stack.
• Changelog — what has shipped and when, worth checking before you commit to an approach that may have changed.
• Integrations — covers connections including Snowflake, Databricks, and BigQuery, plus consulting partners.

Which entry point to use

• Just heard of Cube → the homepage explanation of the semantic layer, then Customer Stories.
• Deciding whether to embed analytics in your product → Request a demo, and read the embedded analytics section first.
• Ready to build → Documentation, with Guides for the first working path.
• Stuck on something specific → Slack Community or GitHub.
• Checking cost or contract shape → the Pricing page.

Cube keeps answers consistent by making the semantic layer the single source of truth for business definitions, then routing every consumer — dashboards, embedded analytics, and AI agents — through that same model. Governance and permissions flow from the model outward, so a metric means the same thing whether a human opens a chart or an agent calls an API. This matters most when you have multiple surfaces (internal BI, customer-facing analytics, autonomous agents) that would otherwise each define "revenue" or "active user" differently.

What the semantic layer actually centralizes

The semantic layer is where you define business metrics and dimensions once, in a data model, rather than re-deriving them in each dashboard or query. Cube describes this as keeping "your definitions consistent across every surface."

In practice that means:

• Metrics and dimensions live in the model, not scattered across reports.
• Business context is attached to the model, so consumers get meaning, not just raw tables.
• Every surface reads from the same definitions, which is what prevents two teams from seeing two different numbers for the same term.

The consistency guarantee comes from centralization: there is one place a definition can change, and one place it can be wrong.

How governance and permissions stay consistent

Cube's model is that "governance flows from your model through to your customers' permissions." Two properties follow from this:

• Governance is defined at the model level, so rules apply wherever the model is consumed rather than being re-implemented per tool.
• Multi-tenancy is built in — the platform is described as "multi-tenant by construction," which matters when embedded analytics serves many customers who must not see each other's data.

Because permissions are tied to the model, an embedded dashboard, a chat interface, and an agent query all inherit the same access rules. You don't maintain a separate permission scheme for each delivery channel.

How AI agents get governed data

Cube positions itself as "BI for both humans and AI agents," with agents receiving "governed, reliable business data through MCP and APIs." The stated goal is that "every decision is grounded in trusted context."

The described flow for an agent request:

1. Understand request — the agent interprets a question or instruction.
2. Work on data model — it operates against the semantic model, not raw tables.
3. Run analysis — computation happens within the governed layer.
4. Produce result — structured results are returned for the next operation.

Results are split by consumer: for humans, charts, reports, and dashboards; for agents, governed data and structured results. The key mechanism is that the agent never bypasses the semantic layer — it queries through MCP and APIs, so it inherits the same definitions and permissions as everything else.

Why this prevents inconsistent answers across surfaces

The failure mode Cube is designed against is definitional drift: the same metric computed differently in a BI tool, an embedded dashboard, and an agent's answer. Centralizing definitions in one semantic model removes the opportunity for that drift, because there is no second place to define the metric.

A concrete example of the problem this solves: a finance dashboard and a customer-facing analytics page both show "monthly revenue." If each computes it independently, a refund-handling rule or a currency conversion applied in one but not the other produces two numbers for the same question. With a shared semantic model, both read the same definition, and the agent answering "what was revenue last month?" returns the same figure.

When this approach fits

The semantic-layer model is most valuable when:

• You have more than one consumption surface (internal BI plus embedded plus agents).
• You serve multiple tenants whose data must stay separated.
• You want AI agents to act on business data without giving them ungoverned access.

It is less obviously necessary if you have a single dashboard, a single team, and no agent or embedded use case — in that setting the overhead of maintaining a semantic model may not pay off.

What to verify before committing

• Where definitions live and how changes propagate to every surface.
• How permissions map from the model to end users and tenants.
• Which interfaces agents use (Cube names MCP and APIs) and what they can and cannot reach.
• Pricing and plan limits — Cube has a pricing page, but the specific terms and any login requirements aren't established here, so check them directly rather than assuming a free tier.

For a team already feeling the pain of mismatched numbers across tools, the semantic layer is the mechanism that resolves it; for a single-surface setup, the benefit is smaller and the decision should hinge on whether agents or embedded analytics are on your roadmap.

Cube is an agentic analytics platform built on a semantic layer. It is designed to serve both AI agents and the humans who work alongside them, giving them governed, reliable business data through MCP and APIs. The core idea is that one semantic model keeps every answer consistent and governed across every surface — whether that surface is a dashboard your data team uses, an AI agent running an operation, or an analytics feature embedded inside your own product.

If you are evaluating Cube, the deciding question is usually whether you need consistent, governed metrics delivered to multiple consumers (people, agents, and customers) without rebuilding your BI stack for each one. Cube is aimed at that problem.

What problem Cube solves

As AI agents become more autonomous, they run more operations and make more decisions without waiting for a person. That creates a data problem: an agent acting on ungoverned or inconsistent numbers can make confidently wrong decisions at machine speed.

Cube's answer is to put a semantic layer underneath everything. The semantic model holds business context, definitions, governance, and permissions. Both humans and agents query through it, so a metric means the same thing whether it appears in a chart, an API response, or an agent's next operation.

The platform describes this as "BI for both humans and AI agents — for your team and your customers."

How the agentic loop works

Cube describes an autonomous loop that runs when a request or trigger arrives. A request can come from a human (a question or instruction) or from an agent (Claude, Codex, or a custom agent), and it can also be triggered by a schedule or a data change.

The loop has four stages:

1. Understand request — interpret the question or instruction.
2. Work on data model — operate against the semantic model rather than raw tables.
3. Run analysis — execute the query or computation.
4. Produce result — return output shaped for the consumer.

Results are delivered differently depending on who asked. For humans, Cube produces charts, reports, and dashboards — analytics content ready to use. For agents, it returns governed data and structured results that feed the next operation.

The semantic model, business context, and governance plus permissions sit underneath this loop, which is what keeps agent output grounded in trusted context.

Core capabilities

Semantic layer and data modeling

The semantic layer is the foundation. It keeps definitions consistent across every surface, so your data team governs metrics in one place instead of reconciling conflicting numbers across tools. Data modeling is a first-class capability, along with self-serve analytics and caching and query performance.

AI context layer

Cube provides an AI context layer that supplies agents with governed business data through MCP and APIs. This is the mechanism that lets an agent act on the same definitions your analysts use, rather than on whatever it can infer from raw data.

Embedded analytics

Cube lets you ship AI-powered analytics inside your product without rebuilding your BI stack. It is described as multi-tenant, governed, and built around the semantic layer. There are several integration paths depending on how much control you want:

Two properties matter for product teams. First, multi-tenancy is described as "by construction," and governance flows from your model through to your customers' permissions. Second, the embedded surfaces are designed to disappear into your product — your colors, your branding, your agent name.

Who it is for

Cube names two broad audiences:

• Data teams that need governed, AI-native BI with definitions kept consistent across every surface.
• Product teams that want to embed analytics and AI-driven answers inside their own application for their customers.

It also lists industry coverage including financial services, technology, healthcare, and media and advertising, and department coverage including finance and accounting, human resources, marketing, and IT.

Integrations and ecosystem

Cube lists integrations plus partnerships with Snowflake, Databricks, and BigQuery, along with consulting partners. The site also points to documentation, guides, demos, a changelog, customer stories, and community channels on GitHub and Slack.

One customer signal worth noting: the site states that "Brex chose Cube over dbt Semantic Layer and LookML." If you are comparing semantic layer options, that is a concrete data point to follow up on in the customer stories section rather than a general claim about superiority.

How to decide whether to look further

Cube is likely a fit if you recognize this combination:

• You need one governed definition of metrics that holds across BI, embedded analytics, and AI agents.
• You want agents to act on trusted business context rather than raw data.
• You are embedding analytics into a multi-tenant product and do not want to rebuild your BI stack to do it.
• You want to choose your integration depth, from drop-in iframes to full control at the data layer.

It is likely not the right starting point if you only need a single internal dashboard, or if you have no semantic model and no intention of building one — the semantic layer is the premise, not an add-on.

To evaluate it concretely, the useful next steps are the pricing page, the demos, and the documentation, since the integration path you pick (Chat API, iframes, Creator Mode, or Core Data APIs) determines most of the implementation work.

Cube is worth evaluating for embedded analytics if you need multi-tenant, governed analytics inside your own product without rebuilding your BI stack, and if your team can work with a semantic layer plus API- or iframe-based delivery. The main decision points are how you enforce customer-level permissions, which embedding surface matches your product's needs, how much of your own branding you want to keep, and whether your existing BI and data integrations line up with Cube's model.

Multi-tenancy and customer-level governance

Cube describes its embedded analytics as "multi-tenant by construction," with governance flowing from your semantic model through to your customers' permissions. That matters because in an embedded scenario the hard problem usually isn't rendering a chart — it's making sure each customer only sees their own data, and that a metric means the same thing everywhere it appears.

The semantic layer is the mechanism here: one semantic model keeps every answer governed and consistent across surfaces, whether the request comes from a human or an AI agent. Before committing, verify that your tenant isolation requirements (row-level rules, per-customer access, shared vs. isolated models) can be expressed in that model rather than patched in at the application layer.

Choosing an embedding surface

Cube offers several distinct paths, and they differ mainly in how much control you keep versus how fast you ship.

The trade-off is consistent across the table: lower-level surfaces (Core Data APIs, Chat API) give more control and more build work; higher-level surfaces (iframes, Creator Mode) ship faster but constrain what you can change.

Branding and product fit

Cube states that embedded surfaces can carry your colors, your branding, and your agent name, so the analytics "disappear into your product." If white-labeling is a requirement, confirm this against the specific surface you pick — a drop-in iframe and a Core Data API build will not give you the same degree of visual control.

AI-agent access as a design constraint

Cube positions itself as BI for both humans and AI agents, exposing governed business data to agents through MCP and APIs. If your roadmap includes agents that trigger or consume analytics autonomously, this is a reason to evaluate Cube early rather than bolt agents onto a traditional embedded BI tool later. If your product only needs static dashboards for human users, this capability is less of a differentiator.

What to check against your current stack

• Existing BI stack: Cube's pitch is shipping embedded analytics "without rebuilding your BI stack." Map which parts of your current stack you'd keep and which Cube would replace.
• Integrations: Cube lists integrations including Snowflake, Databricks, and BigQuery. Confirm your warehouse and data sources are covered.
• Semantic model ownership: Someone on your team has to own metric definitions in the semantic layer. Decide who that is before, not after, rollout.
• Pricing and licensing: Cube has a pricing page, but the input material doesn't state plan details, seat limits, or whether any tier is free. Check current terms directly rather than assuming.

A practical evaluation sequence

1. Define your tenant and permission model in writing, then test whether it can be expressed in a semantic model.
2. Pick the embedding surface that matches your build capacity — iframe for speed, Chat API or Core Data APIs for control.
3. Prototype one customer-facing analytics flow end to end, including a permission boundary case.
4. Confirm integration coverage for your warehouse and review pricing terms for your expected usage.
5. Only then decide between Cube and alternatives; the input notes that Brex chose Cube over dbt Semantic Layer and LookML, which is a useful signal but not a substitute for testing your own requirements.

Cube fits two primary buyers: data teams that need one governed semantic model behind AI-native BI, and product teams that want to embed analytics inside a multi-tenant application without rebuilding their BI stack. If your problem is inconsistent metrics across dashboards and AI agents, or shipping customer-facing analytics with per-tenant permissions, Cube is built for that. If you only need a single internal dashboard with no reuse or embedding requirement, a lighter BI tool is usually enough.

The two core use cases

Cube's own framing is "BI for both humans and AI agents — for your team and your customers." That splits into two distinct buying motions.

1. Data teams: governed, AI-native BI

The semantic layer is the center of the product. You define business logic once in a semantic model, and every surface — dashboards, reports, and AI agents — reads from the same definitions. Cube describes this as keeping "your definitions consistent across every surface."

This matters most when:

• Multiple tools (BI dashboards, notebooks, embedded apps, AI agents) currently produce different numbers for the same metric.
• You are adding AI agents that need governed, reliable business data rather than raw table access. Cube exposes data to agents through MCP and APIs, so agent decisions are grounded in the semantic model rather than ad-hoc queries.
• You want self-serve analytics without letting each consumer redefine metrics.

The agentic loop Cube describes is: understand request → work on data model → run analysis → produce result, with the semantic model, business context, and governance/permissions applied at each step. Humans get charts, reports, and dashboards; agents get structured, governed results.

2. Product teams: embedded analytics

Cube positions embedding as "ship AI-powered analytics inside your product without rebuilding your BI stack," and emphasizes three properties: multi-tenant, governed, and built around the semantic layer.

There are four embedding paths, and the right one depends on how much control you need:

Two details matter for product buyers. First, multi-tenancy is "by construction," and governance flows from your model through to your customers' permissions — so tenant isolation and access rules come from the semantic model rather than being bolted on per integration. Second, embedded surfaces are designed to be white-labeled: "your colors, your branding, your agent name."

Who this is not for

• Single-dashboard internal reporting. If one team needs one dashboard and nothing is reused elsewhere, the semantic layer's value is limited.
• Teams without a defined data model. Cube's governance depends on a semantic model existing. If metric definitions are still unsettled, that work comes first.
• Anyone expecting a no-setup tool. Embedding paths like Core Data APIs assume engineering capacity to build UI on top.

Industry fit

Cube lists solutions for Financial Services, Technology, Healthcare, and Media and Advertising, and notes customers across departments including Finance & Accounting, HR, Marketing, and IT. The common thread is not the vertical itself but the pattern: regulated or high-stakes environments where a wrong number is costly, and product companies that want analytics as a feature rather than an internal tool.

One concrete signal: the site quotes "Brex chose Cube over dbt Semantic Layer and LookML" — a comparison worth noting if you are already evaluating those alternatives, though you should verify the specifics of that evaluation against your own stack.

How to decide

Work through these in order:

1. Do you have (or need) a single source of metric definitions? If yes, the semantic layer is the reason to look at Cube.
2. Are AI agents part of your roadmap? If agents need governed business data via MCP/APIs, this is a stated core capability.
3. Are you embedding analytics in a product with multiple tenants? If yes, check the four embedding paths against your build capacity.
4. Do your integrations match? Cube lists integrations including Snowflake, Databricks, and BigQuery — confirm yours is covered before committing.
5. Check pricing and access terms directly. Cube has a pricing page, but the available material does not state plan details, free tiers, or login requirements. Do not assume free access; verify at cube.dev/pricing.

If steps 1–3 all point yes, Cube is aimed squarely at your situation. If only step 1 applies and you are not embedding or using agents, evaluate whether a simpler semantic layer or BI tool covers the same need with less setup.