Today we are launching Embedded Agentic Analytics — a complete set of building blocks for embedding AI-first analytics into your product, all built on the Cube semantic layer.

Embedded analytics is not a new category. Hundreds of software companies already ship dashboards, charts, and reports inside their products to give their customers a way to work with data. What is new is what those customers now expect. After two years of using AI in everything else they touch, they expect to ask questions of their data in plain language and get useful answers, inside the same product they're already in. The teams that built embedded analytics two or three years ago are now looking at their stack and realizing it wasn't designed for any of this.

We've spent the past year building for that gap. Embedded Agentic Analytics is what we're shipping today.

Why now

Embedded analytics used to mean dashboards. A vendor would offer chart components, a dashboarding UI, maybe a query builder, and you'd wire it into your product. That worked for a long time. The bar for what feels like a usable analytics experience has moved.

Customers don't want to learn another dashboard tool. They want to ask "why is marketing 23% over budget this quarter?" and get an answer that's grounded in their actual data. They want their AI agents — the ones that already help them write code, draft emails, schedule meetings — to be able to answer questions about their numbers too. And they want all of that without leaving the product they're already paying for.

Most existing embedded analytics stacks treat AI as a feature to bolt on: a chat widget on top of a dashboard, a natural-language input on top of a query builder. Those work fine in a demo. In production they tend to produce confident, plausible-sounding answers that don't match how the business actually defines its metrics, because the underlying data layer was never designed to give an AI agent the context it needs to answer correctly.

If you ship embedded analytics today, your customers are already asking for this. The harder question is what infrastructure to build it on.

The semantic layer is the foundation

Agentic analytics needs a context layer. Without one, an AI agent connected to a warehouse can write SQL that runs and returns numbers, but those numbers might not match how your business actually defines the metric. The agent has no idea that "spend" excludes refunds, that "active customer" requires a transaction in the last 90 days, that some departments roll up and others don't. It confidently produces results that are subtly wrong. Point an AI agent at a raw warehouse and most of what you get is wrong analytics, produced faster.

Give that same agent a semantic layer and it stops guessing. It answers the way a domain-specific analyst would — using your definition of spend, your rule for an active customer, the rollups your finance team actually uses — because those definitions are encoded where the agent can read them before it writes a single query.

The semantic layer is where that context lives. Measures, dimensions, joins, and access policies sit in one place, version-controlled, and any consumer of the data — a dashboard, a notebook, an embedded chart, an AI agent — uses the same definitions.

Semantic layers have been around for a while, and historically they've forced a tradeoff between governance and flexibility. Lock the model down so nothing breaks, and people stop using it. Open it up so people can extend it, and you end up with fifteen versions of "churn." Cube's approach is to keep the core model governed and let agents construct ad-hoc calculations on top of it at query time, in SQL. The agent stays inside the governed model while still having the flexibility to answer questions that weren't pre-built into it.

We've been doing embedded analytics from day one

Cube started as a headless BI platform. The thesis was that the analytics layer — the part that defines metrics, runs queries, handles caching, and enforces access — should live separately from any specific UI. Build that layer well, and any number of UIs can sit on top of it: your own dashboards, your customer's dashboards, a chart in a Slack message, an AI agent in a chat box.

Thousands of companies have used Cube's APIs to build custom embedded analytics into their products. Some of the most sophisticated multi-tenant analytics experiences I've seen run on Cube. That work isn't going anywhere; the same Core Data APIs remain a first-class option in what we're announcing today.

What's changed is the surface area. APIs alone are no longer enough to ship a modern embedded analytics experience, because the experience now includes natural-language chat, AI-driven exploration, and agent-to-agent communication. So we're shipping a fuller set of building blocks alongside the APIs, all sharing the same semantic layer underneath.

What we built

Embedded Agentic Analytics ships four embedding options. Pick the one that fits your team and your product, and move between them as you go — there's no lock-in across them, because they all run on the same semantic layer.

  • Analytics Chat API. A streaming API for building a fully custom analytics chat experience. You bring the UI; we handle the agent, the queries against the semantic layer, and the streaming of results. The same API supports agent-to-agent communication: other AI agents — your customer's coding assistant, sales assistant, or any LLM client speaking the Model Context Protocol (MCP), the open standard for connecting agents to tools and data — can call your analytics agent and get a structured answer back. Best for teams that want full UX control or are building agent-to-agent workflows.
  • Chat and Dashboard iframes. Drop-in embeds for analytics chat and dashboards. If you want to ship something to customers in days rather than months, this is the path. Theming, single sign-on, and access controls work out of the box.
  • Creator Mode. Embed the full workbook and dashboard creation experience inside your product. Your customers don't only consume dashboards you built — they build and share their own, with the agent helping them along the way. This option is for teams that want their customers to do exploration, dashboard creation, and sharing entirely inside the product, without sending them to a separate BI tool.
  • Core Data APIs. Direct access to the data layer — JSON, GraphQL, SQL. The same APIs Cube has shipped for years. For teams that want to build everything from scratch and just need a reliable, multi-tenant query layer with a semantic model behind it.

Because every option sits on the same semantic layer, you can start with iframes for a fast launch, move to the Analytics Chat API once you want a more custom UX, and bring in Creator Mode when you're ready to give customers their own building experience. You don't rebuild the data model when you change embedding options.

Multi-tenancy and caching apply across all four options. If you serve a thousand customers, the same model can be parameterized per tenant; pre-aggregations keep query latencies predictable as you scale. Both have been running production embedded workloads on Cube for years and apply equally to every new option above.

Brex

Brex is a good example of what this looks like in production. They built Spaces, an AI-powered financial reporting workspace embedded inside the Brex product. Their finance customers ask questions like "why is marketing 23% over budget this quarter?" and get answers in seconds, grounded in their own spend data.

Before writing any product code, the Brex team evaluated several semantic layer and embedded analytics options with one question front and center: which one is built for AI? They picked Cube because the semantic layer is what makes the agent useful. It encodes the financial domain — the rollups, the spend definitions, the policies that determine who can see what — so the agent reasons over a model that already knows the business, rather than guessing at column names in a warehouse.

The other half of the decision was operational. Spaces serves many Brex customers, which means multi-tenant architecture and production-scale caching aren't nice-to-haves; they're table stakes. Both are part of Cube already, and the Brex team didn't have to build either.

What the Brex team took away from the project — and what we hear from a lot of teams now — is that in agentic analytics, the semantic layer is a product feature. The context you encode into it is what makes the AI experience feel native to your product, instead of like a generic chatbot pointed at a database.

Get started

Embedded Agentic Analytics is available now to all Cube customers. If you're already on Cube, you can try the new embedding options today; the docs walk through each path. If you're new to Cube and thinking about what AI looks like inside your product's analytics, request a demo and we'll go through the options that fit your stack.

We have more coming on this — deeper agent customization, more theming and brand controls, and additional A2A integrations. If you're shipping embedded analytics this year and any of those would change how you'd use this, tell us, and we'll factor it in.