Cube is a mature semantic layer with a deep pre-aggregation system and an agentic platform on top, and it is open core like us. Credible differs on where the model comes from — a coding agent builds it from context already in your stack — and on what travels with it: the definitions, edge cases and access rules, not the metric value alone.
Already decided? Migrate from Cube walks through what carries over.
How Cube describes itself
Cube is a universal semantic layer for humans and AI agents, now an agentic analytics platform: one definition served through four APIs plus MCP and A2A, with Cube D3 adding Workbooks, analytics chat and a Semantic Model Agent.
Credible and Cube compared across 12 dimensions.
| Credible | Cube | |
|---|---|---|
| Category | The AI Analytics Engine — you write down what data means, and it generates the stack under it | Semantic layer, now an agentic analytics platform with its own UI |
| Who it is built for | The whole organization, not one central team — ops, finance and product; spreadsheet users through ML engineers | Platform and application engineers embedding metrics |
| Primary interface | The agent you already use, over MCP — plus Credible Workspaces, dashboards, notebooks and reports for the people who want a UI. Every one of them reads the same model, and the model lives in your repository | Code, and now a UI — cubes authored in YAML, JavaScript or Python; Workbooks and chat in Cube D3 |
| Modeling language | Malloy — a modern programming language for data: imports, inheritance, public and private members, and queries that compose into new sources | YAML configuration, with JavaScript or Python for dynamic cases |
| What is open | Open core. Malloy is open source, and we build and maintain Malloy Publisher — the open-source server for Malloy models, and where our agent skills and MCP retrieval tools are open source too, runnable in any agent with no Credible account. Your model is code in your repository, and Credible is in the Apache Ossie ecosystem for semantic interchange | Open core — Cube Core is open source and self-hostable; Cube Cloud and D3 are commercial |
| How the model gets built | Model first: you write down what data means, and the engine derives the pipelines, storage and serving from it. Open-source MCP tools and agent skills help you capture that meaning from where it already lives, running in your coding agent | Hand-authored cubes, with a Semantic Model Agent proposing and editing them in Cube D3 |
| Governance | One annotation on the source, in the same file as the logic it governs — no grant objects to declare, no rule to re-attach on every surface that exposes the data, no attribute table kept in step by hand. A row filter or an authorize gate over attributes the server resolves from verified identity, and everything reading that source inherits it: dashboards, notebooks and agents alike | Row-level and member-level security defined in configuration |
| Materialization and caching | One annotation on the source, in the same file as the logic it materializes — no derived-table block, no rollup definitions, no refresh triggers, no orchestration run to schedule. Optional per source: query your own warehouse directly, or hold a source hot in Credible’s own storage, which is how you get fast serving without buying or banging your head against a warehouse to get it | Pre-aggregations — materialized rollups the query planner selects automatically, refreshed incrementally, each one defined by hand |
| How an agent finds the right data | Search. Typed targets — source, dimension, measure, view, even a dimensional value — are matched against an index of the model and come back ranked, so an agent asks for what it needs instead of picking a model and touring it | A discovery tool finds cubes by topic or intent as the agent’s first call, then describe_data for the detail |
| Where the model can be used | One model served to every surface — agents over MCP, plus APIs, an SDK, embedded dashboards, notebooks and HTML data apps. Results carry an interactive UI resource (MCP Apps, the official extension), so a client that supports it renders a real chart or table instead of the model re-narrating rows | Four APIs (SQL, REST, GraphQL, MDX), an MCP server and A2A, plus its own BI interface |
| Scale and portability | Globally distributed, high-availability serving that scales horizontally — workers scale out under load rather than being sized in advance. Warehouse-agnostic on open-source Malloy, and the model is portable because the language is | Warehouse-agnostic, but scaling is tied to Cube Cloud compute |
| What you pay for | Usage, not seats — unlimited users on every plan, so adding people never changes the bill. Three meters, pooled per organization and starting free: tokens, compute time and storage. Your agent’s own LLM tokens are never billed to you, and a query that runs on your own warehouse is not metered for the compute — only for the result it hands back | Per-developer seats plus consumption in Cube Compute Units, over a monthly minimum |
A different premise
These are differences in what each product set out to be, not faults in Cube. Credible was built the other way around from a BI tool: collect what your data means, write it down as a data model in open-source Malloy, and serve that meaning over MCP to the agent you already use — with a UI of our own available, but never assumed.
Cube’s agent helps you author cubes inside Cube. Credible’s agent builds the model from context that already exists across your stack — query history, documentation, knowledge stores reachable over MCP. Both are agent-era answers; they differ on whether the starting point is an empty file with an assistant or the material your organization has already written down.
Cube’s pre-aggregations are powerful, and a query planner that picks a rollup automatically is genuinely good engineering. The trade is that every rollup is a definition you write and then own — measures, dimensions, a time dimension, a granularity, a refresh key — a second description of logic the cubes already state. In Credible, materializing a source is one annotation on that source, in the same file as the logic, and it runs in production today. The materialized result is held hot in the engine’s own storage, and it is optional per source — anything you would rather leave in your own warehouse is queried there. Same intent, far less to write and keep in step.
Cube routes metric queries extremely well, and for a product embedding metrics that is the whole requirement. An agent needs more than a number: the definition behind it, the edge cases, which source is trusted, what it must not show this user. Credible captures that context and serves it alongside the value, which is a wider job than routing the query.
Cubes are YAML with JavaScript or Python for dynamic cases — quick to pick up and easy to diff. Malloy is a modeling and query language with imports, inheritance, and public and private members, so a definition is written once and composed rather than repeated. That composition is what keeps a large model comprehensible to people and safely extensible by agents.
Cube is built to serve metrics to applications, and it does that through four APIs plus MCP and A2A. Credible takes on the upstream half as well — capturing what things mean and writing it down as a governed model — because in practice most of the work, and most of the risk, sits before the API rather than at it.
Other comparisons
Capability claims about Cube were checked against public sources in August 2026. Products in this category change quickly — confirm anything decision-critical with the vendor. Sources: Cube D3 and its agents — Cube blog, datus.ai; Pre-aggregations versus PDTs — Cube docs, pipecode.ai; Cube Core licensing and APIs — Cube documentation.
Ready when you are
See what a governed model looks like when agents, not dashboards, are the primary consumer.