diff --git a/README.md b/README.md
index 86d8ba317aca6..736b2222f5e70 100644
--- a/README.md
+++ b/README.md
@@ -10,9 +10,9 @@
[](https://github.com/cube-js/cube/actions?query=workflow%3ABuild+branch%3Amaster)
[](https://app.fossa.io/projects/git%2Bgithub.com%2Fcube-js%2Fcube.js?ref=badge_shield)
-__Cube Core is an open-source semantic layer.__ Cube Core can be used to build embedded analytics in your applications, create your own business intelligence tool or provide context about data to AI agents. Cube Core is headless and comes with multiple APIs for embedded analytics and BI: REST, GraphQL, and SQL.
+__Cube Core is the open-source semantic layer.__ Define metrics, dimensions, joins, and access rules once in code, then expose them through SQL, REST, and GraphQL APIs to anything downstream — BI tools, custom applications, or AI agents. Cube Core is headless: it doesn't ship a UI, so you can build the analytics experience that fits your product.
-If you are looking for a fully integrated platform, check out [Cube](https://cube.dev), a modern AI-first business intelligence platform. We use Cube Core to power it.
+Cube Core works with all SQL data sources, including cloud data warehouses like Snowflake, Databricks, and BigQuery; query engines like Presto and Amazon Athena; and application databases like Postgres. It has a built-in relational caching engine to provide sub-second latency and high concurrency for API requests.
Learn more about connecting Cube to data sources and analytics & visualization tools.
-Cube Core was designed to work with all SQL data sources, including cloud data warehouses like Snowflake, Databricks, and BigQuery; query engines like Presto and Amazon Athena; and application databases like Postgres. Cube Core has a built-in relational caching engine to provide sub-second latency and high concurrency for API requests.
-
## Why Cube Core?
-Every business intelligence tool relies on a semantic layer as its core engine—a critical component that defines metrics, dimensions, and business logic while abstracting the complexity of underlying data sources. However, most semantic layers are proprietary, tightly coupled to specific BI platforms, and cannot be reused across different applications.
+Every BI tool relies on a semantic layer as its core engine — the component that defines metrics, dimensions, and business logic and hides the complexity of the underlying data sources. Most semantic layers are proprietary, tightly coupled to a single BI platform, and can't be reused across other tools.
-Cube Core is an open-source project that aims to create an open, modern semantic layer that can be used to power any analytics applications and AI agents. By decoupling the semantic layer from specific tools and making it accessible through standard APIs, Cube Core enables organizations to define their metrics once and use them everywhere—from BI tools to embedded analytics to AI agents.
+Cube Core is an open, standalone semantic layer that any analytics application or AI agent can consume through standard APIs. Define your metrics once and use them everywhere — internal BI, embedded analytics, AI agents — without re-implementing the model in each place.
-## Getting Started 🚀
+## Getting Started
-You can get started with Cube locally or self-host it with [Docker](https://www.docker.com/).
+You can run Cube Core locally or self-host it with [Docker](https://www.docker.com/).
-Once Docker is installed, in a new folder for your project, run the following command:
+Once Docker is installed, in a new folder for your project, run:
```bash
docker run -p 4000:4000 \
@@ -46,15 +44,28 @@ docker run -p 4000:4000 \
cubejs/cube
```
-Then, open http://localhost:4000 in your browser to continue setup.
+Then open http://localhost:4000 in your browser to continue setup.
For a step-by-step guide, [see the docs](https://cube.dev/cube-core/getting-started/create-a-project?ref=github-readme).
-### Cube — Complete Modern BI Tool from Cube Core Creators
+## Cube Core vs. Cube
+
+[Cube](https://cube.dev?ref=github-readme) is our commercial product — an agentic analytics platform built on Cube Core. Same semantic layer underneath, plus the rest of what makes it a full BI platform: Analytics Chat, workbooks and dashboards, embedded analytics surfaces, managed deployment, RBAC, multi-tenancy, and integrations with Tableau, Power BI, Excel, and Google Sheets.
+
+The data model is fully compatible both ways: a model you build in Cube Core runs unchanged in Cube, and vice versa. Cube Core stays open-source and is what we run inside Cube ourselves.
+
+- **Use Cube Core** when you want to own the stack — a custom BI experience, deeply integrated embedded analytics, or AI agents that need a governed semantic foundation.
+- **Use Cube** when you want a managed, full-featured BI platform out of the box — internal analytics or customer-facing embedded analytics without building the surrounding platform yourself.
+
+For more on how we think about the split, see [The Future of Cube Core and Cube](https://cube.dev/blog/cube-core-and-cube).
+
+For a tour of what's in Cube today, watch the workshop:
-[Cube](https://cube.dev?ref=github-readme) is a complete modern agentic analytics platform built on Cube Core. It provides a fully integrated solution with a user-friendly interface, advanced analytics capabilities, and managed infrastructure.
+
+
+
-
+Or [try Cube for free](https://cubecloud.dev/auth/signup?ref=github-readme).
## Resources
diff --git a/docs-mintlify/admin/account-billing/pricing.mdx b/docs-mintlify/admin/account-billing/pricing.mdx
index a199e1d34f15d..6bb6262938ebf 100644
--- a/docs-mintlify/admin/account-billing/pricing.mdx
+++ b/docs-mintlify/admin/account-billing/pricing.mdx
@@ -96,7 +96,7 @@ of deployments within a Cube Cloud account. The consumption is measured in 5-min
| Cube Store Worker | 1..2 | Depends on a [chosen tier](#cube-store-worker-tiers) |
| [Semantic Catalog][ref-semantic-catalog] | 2..4 | Depends on a [chosen tier](#semantic-catalog-tiers) |
| [Query History][ref-query-history] | 0..20 | Depends on a [chosen tier](#query-history-tiers) |
-| [Monitoring Integrations][ref-monitoring-integrations] | 1..4 | Depends on a [chosen tier](#monitoring-integrations-tiers) |
+| [Monitoring Integrations][ref-monitoring-integrations] | — | Available as an [add-on](#monitoring-integrations) on the Enterprise plan |
The following resource types incur CCU consumption and apply to the _whole Cube Cloud
account_:
@@ -169,18 +169,11 @@ features analyze and visualize the data available under the following tiers:
You can upgrade to a chosen tier in the
**Settings** of your deployment.
-### Monitoring Integrations tiers
+### Monitoring Integrations
-[Monitoring Integrations][ref-monitoring-integrations] feature has the following tiers:
-
-| Tier | CCUs per hour | Exported data | Dependent features |
-| ---- | :-----------: | -------------- | --- |
-| XS | 1 | Up to 10 GB/mo | — |
-| S | 2 | Up to 25 GB/mo | — |
-| M | 4 | Up to 50 GB/mo | [Query History export][ref-query-history-export] |
-
-You can [upgrade][ref-monitoring-integrations-config] to a chosen tier in the
-**Settings** of your deployment.
+[Monitoring Integrations][ref-monitoring-integrations], including [Query History
+export][ref-query-history-export], are available as an add-on on the Enterprise
+plan. [Contact us][cube-contact-us] for pricing.
### Audit Log tiers
@@ -330,7 +323,6 @@ for the AI token consumption at the **Billing** page of their Cube Cloud account
[ref-cloud-deployment-prod-cluster]: /docs/deployment/cloud/deployment-types#dedicated
[ref-cloud-limits]: /docs/deployment/cloud/limits
[ref-monitoring-integrations]: /docs/monitoring/integrations
-[ref-monitoring-integrations-config]: /admin/deployment/monitoring-integrations#configuration
[ref-cloud-acl]: /admin/users-and-permissions/custom-roles
[ref-cloud-deployment-prod-multicluster]: /docs/deployment/cloud/deployment-types#multi-cluster
[ref-cloud-custom-domains]: /docs/deployment/cloud/custom-domains
diff --git a/docs-mintlify/admin/deployment/limits.mdx b/docs-mintlify/admin/deployment/limits.mdx
index 69c2729b4af04..601e6fceca401 100644
--- a/docs-mintlify/admin/deployment/limits.mdx
+++ b/docs-mintlify/admin/deployment/limits.mdx
@@ -35,7 +35,7 @@ types][ref-deployment-types] and [product tiers][ref-pricing]:
| [Query History][ref-query-history] — queries processed per day for each deployment | 1,000 | Depends on the [tier][ref-query-history-tiers] | Depends on the [tier][ref-query-history-tiers] | Depends on the [tier][ref-query-history-tiers] |
| [Audit Log][ref-audit-log] — retention period | — | — | — | 30 days |
| [Audit Log][ref-audit-log] — events collected | — | — | — | 10,000 |
-| [Monitoring Integrations][ref-monitoring-integrations] — exported data | — | Depends on the [tier][ref-monitoring-integrations-tiers] | Depends on the [tier][ref-monitoring-integrations-tiers] | Depends on the [tier][ref-monitoring-integrations-tiers] |
+| [Monitoring Integrations][ref-monitoring-integrations] — exported data | — | — | — | Available as an [add-on][ref-monitoring-integrations] |
### Number of deployments
@@ -82,8 +82,8 @@ support][cube-contact-us] for further assistance.
### Data exported via Monitoring Integrations
-This is a hard limit. Consider upgrading to the next [Monitoring Integrations tier][ref-monitoring-integrations-tiers].
-Usage is calculated per Cube Cloud deployment.
+This is a hard limit. Usage is calculated per Cube Cloud deployment. [Contact
+support][cube-contact-us] for higher quotas.
## Quotas
@@ -105,5 +105,4 @@ response.
[ref-prod-cluster]: /docs/deployment/cloud/deployment-types#dedicated
[cube-contact-us]: https://cube.dev/contact
[ref-query-history-tiers]: /admin/account-billing/pricing#query-history-tiers
-[ref-audit-log]: /admin/monitoring/audit-log
-[ref-monitoring-integrations-tiers]: /admin/account-billing/pricing#monitoring-integrations-tiers
\ No newline at end of file
+[ref-audit-log]: /admin/monitoring/audit-log
\ No newline at end of file
diff --git a/docs-mintlify/admin/monitoring/monitoring-integrations/index.mdx b/docs-mintlify/admin/monitoring/monitoring-integrations/index.mdx
index ad857b0bc5cc5..8a4c5771eb43e 100644
--- a/docs-mintlify/admin/monitoring/monitoring-integrations/index.mdx
+++ b/docs-mintlify/admin/monitoring/monitoring-integrations/index.mdx
@@ -1,18 +1,15 @@
---
-title: Strategy, credentials, etc.
+title: Overview
description: Export Cube Cloud logs and metrics to external monitoring tools like Datadog, Grafana Cloud, and New Relic.
---
- Monitoring Integrations
-
Cube Cloud allows exporting logs and metrics to external monitoring tools so you
can leverage your existing monitoring stack and retain logs and metrics for the
long term.
-Available on [Enterprise plan](https://cube.dev/pricing).
-You can also choose a [Monitoring Integrations tier](/admin/account-billing/pricing#monitoring-integrations-tiers).
+Available as an add-on on the [Enterprise plan](https://cube.dev/pricing).
@@ -47,16 +44,21 @@ destinations][vector-docs-sinks], also known as _sinks_.
Monitoring integrations work with various popular monitoring tools. Check the
following guides and configuration examples to get tool-specific instructions:
-
-
+
+
+ Export logs and metrics to Amazon CloudWatch.
-
+
+ Archive logs to an Amazon S3 bucket.
-
+
+ Export logs and metrics to Datadog.
-
+
+ Export logs and metrics to Grafana Cloud.
-
+
+ Export logs and metrics to New Relic.
@@ -64,8 +66,7 @@ following guides and configuration examples to get tool-specific instructions:
To enable monitoring integrations, navigate to **Settings → Monitoring
Integrations** and click **Enable Vector** to add a Vector agent to
-your deployment. You can use the dropdown to select a [Monitoring Integrations
-tier](/admin/account-billing/pricing#monitoring-integrations-tiers).
+your deployment.
@@ -283,12 +284,12 @@ external monitoring solution for further analysis, for example:
* Set up alerts for queries that exceed a certain duration.
* Attribute usage to specific users and implement chargebacks.
-
+
-Requires the [M tier](/admin/account-billing/pricing#monitoring-integrations-tiers)
-of Monitoring Integrations.
+Query History export is part of the Monitoring Integrations add-on,
+available on the [Enterprise plan](https://cube.dev/pricing).
-
+
-Cube is an AI analytics platform for the whole organization — built to be used by both humans and AI agents. It combines self-serve conversational analytics, governed data modeling, and embedded analytics experiences, all on top of an open-source semantic layer. It empowers different personas across your organization:
+For internal BI, data teams and business users explore data with workbooks, dashboards, and Analytics Chat — natural-language analysis grounded in a governed data model. For embedded analytics, software companies ship the same surfaces, and the underlying APIs, inside their own products to deliver customer-facing experiences.
-- **Data Engineers** can quickly curate data models with AI assistance, accelerating development and reducing time-to-insight for the whole organization
-- **Data Analysts** can perform deep analysis with AI assistance, getting trusted answers without writing ad-hoc SQL
-- **Business Users** can self-serve with natural language questions, workbooks, and dashboards — no tickets to the data team required
+Cube is built for both humans and AI agents:
+
+- **Data engineers** build and maintain semantic models in code, with AI assistance.
+- **Data analysts** explore deeply and get trusted answers without writing ad-hoc SQL.
+- **Business users** ask questions in natural language and get answers grounded in the same data model the data team owns.
+- **AI agents** like Claude, ChatGPT, or your own connect through the MCP server or Chat API to get analytics answers grounded in the same governed data model.
## How is Cube different?
-At the foundation of Cube's agentic analytics platform is an [open-source semantic layer](https://github.com/cube-js/cube) — the shared context that enables both AI agents and humans to work with trusted, consistent data.
+At the foundation of Cube is an [open-source semantic layer](https://github.com/cube-js/cube) — **Cube Core** — that provides the shared context every consumer works from. It centralizes metric definitions, joins, access rules, and caching upstream of every BI tool, application, and AI agent that queries the data. The same Cube Core that powers Cube is what we maintain as open-source; data models port unchanged between the two.
-The semantic layer provides the governed data foundation that makes agentic analytics possible. It organizes data from your cloud data warehouses into centralized, consistent definitions that AI agents can reliably query, explore, and reason about. Without a semantic layer, AI agents would struggle with inconsistent metrics, scattered business logic, and ungoverned data access—making their outputs unreliable and potentially dangerous.
+The semantic layer is what makes AI useful. Without one, agents writing SQL against a warehouse end up with inconsistent metrics and ungoverned access — numbers that don't match how your business defines them. With one, agents get a stable, governed surface to reason over.
### Semantic SQL
-Unlike other tools, Cube AI agents don't query the data warehouse directly. Instead, they query the semantic layer using Semantic SQL, creating a trusted proxy architecture. The semantic layer runtime acts as guardrails between AI agents and your warehouse—all queries must pass through this deterministic runtime, which validates every request and prevents incorrect queries from reaching your data.
-
-Semantic SQL extends Postgres-compatible SQL with the MEASURE function. This architecture lets AI leverage the full power of SQL to build ad-hoc derived calculations on top of existing semantic model calculations, combining flexibility with governance.
+Cube AI agents don't query the warehouse directly. They query the semantic layer using Semantic SQL — a Postgres-compatible interface that extends SQL with the `MEASURE` function. Every query passes through the semantic layer runtime, where it's validated against the data model and has access policies applied deterministically before reaching the warehouse.
-Security policies are enforced deterministically at the semantic layer runtime, ensuring consistent access control across all queries.
+Semantic SQL gives agents the full expressiveness of SQL to build ad-hoc derived calculations on top of governed metrics — flexibility on a stable foundation, instead of one or the other.
@@ -42,64 +43,41 @@ Security policies are enforced deterministically at the semantic layer runtime,
### Semantic layer architecture
-#### Code-first
-
-A code-first approach is essential for both traditional data engineering and agentic analytics. Managing data models, configurations, and policies as code enables the same proven practices that power modern software development: version control for collaboration and code reviews, automated testing and documentation, and established patterns for reusability and maintainability.
+The semantic layer is built on four pillars: data modeling, access control, caching, and APIs.
-For agentic analytics specifically, a code-first semantic layer creates new possibilities. AI agents can help curate and maintain data models themselves, accelerating development while maintaining quality through git workflows. The structured, version-controlled nature of code makes it easier for agents to understand changes, suggest improvements, and even implement modifications autonomously.
-
-Everything within Cube—from configurations to data models to access control policies—is managed through code. This foundation enables both human data engineers and AI agents to collaborate on building and maintaining the semantic layer that powers agentic analytics.
-
-The semantic layer that powers Cube's agentic analytics platform is built on four essential pillars: data modeling, access control, caching, and APIs. Each pillar plays a critical role in enabling AI agents and users to work with data reliably, securely, and efficiently.
-
-#### Data Modeling
+#### Code-first
-**The data model provides the knowledge graph that AI agents use to understand your business.** It centralizes metric definitions, entity relationships, and business logic upstream from all consumption tools—whether those are AI agents, BI tools, or custom applications. This centralization is critical for agentic analytics: AI agents need a structured understanding of what metrics mean, how entities relate, and what calculations are valid.
+Everything in Cube — data models, configurations, access control policies — is managed as code. That brings version control, code review, CI, and isolated environments to the semantic layer, the same way modern software teams already manage application code.
-When an AI agent analyzes sales performance or answers questions about customer behavior, it relies on the semantic layer's data model to understand that "revenue" is calculated consistently, that customers have orders, and that orders contain line items. This structured knowledge enables agents to generate reliable insights and navigate complex data relationships autonomously.
+Code-first also makes AI assistance practical: agents can read, propose, and edit the model through normal git workflows. Humans review the change before it lands.
-**Cube's data model is code-first.** Data teams define data models with YAML or JavaScript code, managed through version control systems. This enables AI-assisted development where agents can help curate and maintain the semantic layer itself, accelerating model development while maintaining quality through git workflows and multiple isolated environments.
+#### Data modeling
-**Cube's data model is dataset-centric**, inspired by and expanding upon dimensional modeling. You work with two types of objects:
+The data model is the knowledge graph the platform — and any AI agent — uses to understand your business. It defines metrics, entities, joins, and how they relate, upstream of any consumer.
-**Cubes** represent business entities such as customers, line items, and orders. They define all calculations within measures and dimensions, as well as relationships between entities. These relationships form the knowledge graph that AI agents traverse when exploring data and generating insights.
+Cube's model is **dataset-centric**, expanding on dimensional modeling. You work with two object types:
-**Views** sit on top of the data graph of cubes, creating facades that data consumers interact with. Think of views as the final data products for AI agents, BI users, and applications. Views select measures and dimensions from connected cubes and present them as unified datasets, providing AI agents with the right context and scope for specific analytical tasks.
+- **Cubes** represent business entities — customers, orders, line items. They define measures, dimensions, and joins between entities.
+- **Views** sit on top of cubes and present curated, query-ready datasets. Views are what data consumers — humans and agents — interact with.
-#### Access Control
+Models are written in YAML or JavaScript and managed in version control.
-**Access control ensures that AI agents respect the same data security policies as human users.** This is critical for agentic analytics: when AI agents autonomously query and analyze data, they must enforce the same governance rules that apply to human users—whether that's row-level security, column-level restrictions, or data masking.
+#### Access control
-By centralizing access control in the semantic layer, you ensure that all data consumption—whether by AI agents, BI tools, or custom applications—goes through a single governed checkpoint. This provides comprehensive oversight and prevents agents from inadvertently exposing sensitive data or violating security policies.
+Access control runs at the semantic layer, so the same policies apply to every consumer: AI agents, BI tools, embedded applications. Define the rule once; it's enforced everywhere.
-Cube's code-first approach enables data teams to **define access control policies with Python or JavaScript**, ranging from simple row-level access rules to completely custom data models per tenant backed by different data sources. These policies apply uniformly to all consumers of the semantic layer, ensuring AI agents operate within the same security boundaries as human users.
+Policies are code (Python or JavaScript) and range from row-level rules to fully tenant-aware models backed by different data sources.
#### Caching
-**Caching enables AI agents to deliver fast, interactive experiences without overwhelming your data infrastructure.** For agentic analytics to be effective, AI agents must respond quickly to user questions, iteratively explore data, and generate insights in real-time. Without caching, every agent query would hit your data warehouse directly, creating latency issues and potentially significant costs.
+Cube's caching is built on **pre-aggregations** — rollup tables declared in the data model and refreshed in the background, stored in Cube Store (Cube's distributed caching engine).
-The semantic layer acts as a performance buffer between AI agents and your data sources. Through intelligent caching, it ensures agents can work interactively while protecting your cloud data warehouse from unnecessary and redundant load.
-
-Cube implements caching through an **aggregate awareness framework called pre-aggregations.** Data teams define pre-aggregates in the data model as rollup tables, including measures and dimensions. Cube builds and refreshes these pre-aggregates in the background by querying your cloud data warehouse and storing results in Cube Store, Cube's purpose-built caching engine backed by distributed file storage such as S3. Pre-aggregations can be refreshed on schedule or as part of workflow orchestration.
-
-When an AI agent sends a query to Cube, the aggregate awareness engine determines if an existing and fresh pre-aggregate can serve that query. This significantly accelerates agent responses and reduces both latency and data warehouse costs—essential for enabling the iterative, exploratory workflows that characterize agentic analytics.
+When a query comes in, Cube's aggregate awareness engine routes it to a matching pre-aggregation when one exists. This is what keeps interactive workflows fast and warehouse costs predictable.
#### APIs
-**APIs enable AI agents, applications, and tools to interact with the semantic layer through standard protocols.** For agentic analytics to work across diverse use cases—from AI-powered workbooks to embedded analytics to traditional BI—the semantic layer must provide universal interoperability. AI agents need to query data, introspect the data model, and integrate with other systems without requiring custom integrations for every tool or framework.
-
-Rather than inventing proprietary protocols, Cube implements widely adopted standards: **REST (JSON), GraphQL, and SQL.**
-
-**REST (JSON) and GraphQL** provide modern API interfaces for building custom applications and enabling programmatic access. These APIs power agentic workflows, allowing AI agents to query data, retrieve results, and build interactive experiences.
-
-**SQL** is universally adopted across the data stack. Every BI tool, visualization platform, and data application can query a SQL data source. Cube implements Postgres-compatible SQL and extends it to support semantic layer concepts like measures—special types that know how to evaluate themselves based on data model definitions. Any tool that can connect to Postgres or Redshift can connect to Cube, making the semantic layer accessible to both AI agents and traditional analytics tools.
-
-**Data model introspection through the meta API** is essential for agentic analytics. It enables AI agents to discover available metrics, understand entity relationships, and determine valid queries—providing the context agents need to navigate the semantic layer autonomously. This same introspection capability allows BI tools to automatically map to data model objects and helps applications build dynamic interfaces.
-
+The semantic layer exposes standard APIs so any consumer can plug in:
-[ref-workbooks]: /docs/workspace/workbooks
-[ref-embedding]: /reference/embedding
-[ref-chat-api]: /reference/chat-api
-[ref-mcp-server]: /docs/integrations/mcp-server
-[ref-agent-rules]: /admin/ai/rules
-[ref-agent-memories]: /admin/ai/memory-isolation
\ No newline at end of file
+- **SQL** — Postgres-compatible, with `MEASURE` and related extensions. Any tool that talks to Postgres or Redshift can talk to Cube.
+- **REST (JSON)** and **GraphQL** — for custom applications and programmatic access.
+- **Meta API** — model introspection. Lets AI agents discover what's queryable, and lets BI tools auto-map to the data model.
diff --git a/docs-mintlify/introduction.mdx b/docs-mintlify/introduction.mdx
deleted file mode 100644
index 769389c12f135..0000000000000
--- a/docs-mintlify/introduction.mdx
+++ /dev/null
@@ -1,66 +0,0 @@
----
-title: Introduction
-description: Cube is the business intelligence platform powered by the open-source semantic layer.
----
-
- Introduction
-
-Cube is the business intelligence platform powered by the open-source semantic layer.
-
-Cube uses AI agents to build data models and enable data consumers to perform analysis. Use AI to quickly build semantic layer and fully control the analytics context.
-
-
-
-Cube is a new generation of a business intelligence and embedded analytics platform built to be used by both humans and AI agents. It empowers different personas across your organization:
-
-- **Data Engineers** can quickly curate data models with AI assistance, accelerating the development and maintenance of semantic layers
-- **Data Analysts** can perform deep analysis with AI assistance, diving into complex data relationships and patterns
-- **Business Users** benefit from workbooks and dashboards that Cube can automatically build and maintain
-
-## How is Cube different?
-
-At the foundation of Cube's agentic analytics platform is an [open-source semantic layer](https://github.com/cube-js/cube) — the critical infrastructure that enables both AI agents and humans to work with trusted, consistent data.
-
-### Semantic SQL
-
-Unlike other tools, Cube AI agents don't query the data warehouse directly. Instead, they query the semantic layer using Semantic SQL, creating a trusted proxy architecture.
-
-
-
-### Semantic layer architecture
-
-#### Code-first
-
-A code-first approach is essential for both traditional data engineering and agentic analytics. Managing data models, configurations, and policies as code enables the same proven practices that power modern software development.
-
-Everything within Cube — from configurations to data models to access control policies — is managed through code.
-
-#### Data Modeling
-
-The data model provides the knowledge graph that AI agents use to understand your business. Cube's data model is **code-first** and **dataset-centric**, inspired by dimensional modeling. You work with two types of objects:
-
-- **Cubes** represent business entities such as customers, line items, and orders
-- **Views** sit on top of the data graph of cubes, creating facades that data consumers interact with
-
-#### Access Control
-
-Access control ensures that AI agents respect the same data security policies as human users. Cube's code-first approach enables data teams to define access control policies with Python or JavaScript.
-
-#### Caching
-
-Caching enables AI agents to deliver fast, interactive experiences without overwhelming your data infrastructure. Cube implements caching through **pre-aggregations** — rollup tables that accelerate query responses and reduce data warehouse costs.
-
-#### APIs
-
-APIs enable AI agents, applications, and tools to interact with the semantic layer through standard protocols: **REST (JSON)**, **GraphQL**, and **SQL**.
diff --git a/docs-mintlify/recipes/ai/agent-to-agent.mdx b/docs-mintlify/recipes/ai/agent-to-agent.mdx
index c521c57ac09cc..6e79763036629 100644
--- a/docs-mintlify/recipes/ai/agent-to-agent.mdx
+++ b/docs-mintlify/recipes/ai/agent-to-agent.mdx
@@ -364,6 +364,111 @@ With this approach, the second question — *"Now break that down by
product line"* — is understood in the context of the first, just like a
human conversation.
+### Orchestrating multiple Cube agents
+
+If your deployment uses [multi-agent][ref-multi-agent] — with specialized
+Cube agents like a Sales Assistant and a Marketing Analyst living in the
+same deployment — your orchestrating agent can choose the right Cube
+agent for each question and route to it.
+
+The [Chat API URL](#endpoint) embeds an `agentId`, so every agent in
+your deployment has its own Chat API URL. Copy each one from **Admin →
+Agents** for the corresponding agent. Switching between Cube agents
+from your code is then just a matter of POSTing to a different URL —
+the request shape is identical.
+
+How your orchestrating agent learns which Cube agents exist is up to
+you. Two common patterns:
+
+- **List them in the system prompt.** Hardcode the agents (name,
+ description, the domain each one covers) in your orchestrator's
+ system prompt. Simple, and works well when the set of agents rarely
+ changes.
+- **Expose a discovery tool.** Add a `list_cube_agents` tool that
+ returns the available agents at runtime. Useful when agents come and
+ go, or when you want the orchestrator to pick them up without a code
+ change.
+
+The example below combines both: a `list_cube_agents` tool for
+discovery and a single `ask_cube_agent` tool that takes an agent name
+plus the question and routes the request to the matching Chat API URL.
+It builds on the `query_cube_agent` helper from above, extended to
+accept a `chat_api_url` argument instead of using a single hardcoded
+URL.
+
+```python
+import json
+import os
+from langchain_core.tools import tool
+
+
+CUBE_AGENTS = {
+ "sales-assistant": {
+ "url": os.environ["CUBE_SALES_AGENT_URL"],
+ "description": (
+ "Sales pipeline, deals, reps, quotas, and revenue by territory."
+ ),
+ },
+ "marketing-analyst": {
+ "url": os.environ["CUBE_MARKETING_AGENT_URL"],
+ "description": (
+ "Campaigns, channel attribution, traffic sources, and funnel "
+ "conversion."
+ ),
+ },
+}
+
+
+@tool
+def list_cube_agents() -> str:
+ """List the available Cube agents and the domain each one covers.
+ Call this first when you need data, then pick the most relevant
+ agent for the user's question."""
+
+ return json.dumps(
+ {name: agent["description"] for name, agent in CUBE_AGENTS.items()}
+ )
+
+
+@tool
+def ask_cube_agent(agent_name: str, question: str) -> str:
+ """Ask a data analytics question to a specific Cube agent.
+
+ Call `list_cube_agents` first to see which agents are available and
+ which domain each one covers, then pass the chosen `agent_name`
+ along with a focused, self-contained question."""
+
+ agent = CUBE_AGENTS.get(agent_name)
+ if agent is None:
+ available = ", ".join(CUBE_AGENTS.keys())
+ return (
+ f"Unknown Cube agent '{agent_name}'. "
+ f"Available agents: {available}."
+ )
+
+ return query_cube_agent(question, chat_api_url=agent["url"])
+```
+
+
+
+Alternatively, skip the discovery tool entirely and inline the list of
+agents and their domains in your orchestrator's system prompt. The
+orchestrator will then pass an `agent_name` directly to `ask_cube_agent`
+without an extra round trip.
+
+
+
+This pattern gives your orchestrating agent a clean routing layer: it
+picks the right Cube agent for each question, and each Cube agent
+answers using the rules, certified queries, and accessible views
+configured for its [space][ref-spaces]. A sales question is routed to
+the Sales Assistant and answered against the sales views; a marketing
+question is routed to the Marketing Analyst and answered against the
+marketing views — without your orchestrator needing to know any of
+those details.
+
[ref-chat-api]: /reference/embed-apis/chat-api
[ref-api-keys]: /admin/account-billing/api-keys
+[ref-multi-agent]: /admin/ai/multi-agent
+[ref-spaces]: /admin/ai/multi-agent#spaces
diff --git a/packages/cubejs-playground/src/pages/CubeBI/CubeBiPage.tsx b/packages/cubejs-playground/src/pages/CubeBI/CubeBiPage.tsx
index 5a89e81d6c38f..04c0052fd5087 100644
--- a/packages/cubejs-playground/src/pages/CubeBI/CubeBiPage.tsx
+++ b/packages/cubejs-playground/src/pages/CubeBI/CubeBiPage.tsx
@@ -58,7 +58,7 @@ export function CubeBiPage() {
+
-