Executive summary
AtScale built a real category: a universal semantic layer that sits between cloud warehouses and BI tools, providing OLAP-style virtual cubes, hierarchies, aggregations, and aggregate-aware query rewriting. For enterprises with mature Tableau, Power BI, or Excel deployments who want consistent metric definitions and accelerated query performance against the warehouse, AtScale solves a real problem and solves it well.
Colrows solves a different problem. It is a semantic execution layer built for the AI-agent layer of the enterprise - autonomously building a typed semantic graph across the data estate, then compiling every agent intent into governed, deterministic, dialect-perfect SQL. Where AtScale models the data as cubes and accelerates BI consumption, Colrows models the data as a graph and compiles agent intent into governed SQL with policy injected at compile time.
In short:
- AtScale helps BI tools consume cube-shaped semantics fast.
- Colrows enables AI agents to compile graph-shaped intent into governed SQL.
For organisations whose AI ambitions extend beyond accelerated BI, the two architectures address different layers of the stack.
Two philosophies, two outcomes
AtScale assumes meaning is cube-shaped and consumed by BI tools. Modellers define virtual cubes, hierarchies, calculated measures, and dimensional relationships. AtScale's query engine receives MDX, DAX, or SQL from BI tools, rewrites queries to hit pre-computed aggregates where possible, and returns results. The semantic layer is rich within the OLAP vocabulary - measures, hierarchies, calculated members, role-playing dimensions - and its primary value is performance and consistency for the BI ecosystem.
Colrows assumes meaning is graph-shaped and consumed by autonomous agents. Definitions live in catalogues, BI tools (including AtScale), dbt models, runbooks, Confluence, and historical query usage. Colrows ingests these sources and constructs a typed semantic graph autonomously. The graph is multi-scope (global, datastore, persona, user) and uses multi-vector embeddings (definition, usage, combined per concept). The consumer is an AI agent generating intent in natural language that needs deterministic compilation with policy injected at compile time.
The downstream consequence: AtScale optimises BI-tool experience against a manually-modelled cube. Colrows optimises agent-execution correctness against an autonomously-maintained graph.
OLAP cube vs. semantic graph
The most important architectural distinction is the data model the layer assumes.
AtScale models the data as cubes. Dimensions, hierarchies, measures, aggregate tables. The mental model is multi-dimensional analysis: revenue by product by region by quarter. The query engine is built to slice, dice, and accelerate that pattern.
Colrows models the data as a typed graph. Concepts (Customer, Order, Subscription), typed edges between them (Customer has Order, Order belongs to Subscription), governance predicates attached at every node and edge, multi-scope resolution per persona and tenant, and proven join paths an AI agent traverses to answer multi-hop questions.
Many BI questions fit a cube model. Many AI agent questions do not - they require traversal across entities, relationships, and governance scopes that a cube cannot represent without flattening.
A concrete scenario: pharmaceutical compliance investigation
A global pharmaceutical company runs AtScale to power its sales-performance dashboards. Tableau and Excel users get fast, consistent answers to questions like quarterly product sales by region by therapeutic area. The cube is well-modelled, the aggregate-aware query rewriting reduces warehouse cost, and the BI team is rightly proud of the work.
Now the compliance team wants an AI agent that can investigate: "For the last three quarters, identify any field-force interactions in Region X that exceeded our promotional-spend policy thresholds for that therapeutic area, cross-checked against the prescribing physician's specialty and current speaker programme participation, and explain why each flagged interaction is or is not a compliance issue."
This is not a cube question. The agent must reason across:
- FieldRep, PhysicianContact, PromotionalSpend, SpeakerProgramme, TherapeuticArea, and ComplianceRule entities and the typed relationships between them.
- The compliance officer persona's permission to see specific PII columns, but only when scoped to active enforcement files.
- Predicates that vary per region, therapeutic area, and time period (because internal policies and external regulations both change).
- An audit trail proving exactly which definitions and policies were in force when the agent reached its conclusion.
AtScale can deliver fast cube slices for the underlying spend data. But the agent reasoning is graph traversal, the governance is multi-scope and time-variant, and the audit must be defensible. None of that lives in the cube.
With Colrows, the agent compiles its intent through a typed semantic graph that already encodes those entities, relationships, and policies. Compile-time governance injects the right predicates per persona, per scope, per date. The audit trail is point-in-time reproducible. New policies ingested as documentation update the graph without an OLAP modelling deploy.
Why OLAP semantic layers cannot do this
AtScale is excellent at one thing: accelerated, governed BI consumption from a multi-dimensional model. It is not designed to:
- Model entity-and-relationship graphs for multi-hop agent reasoning.
- Compile free-text agent intent deterministically into governed SQL.
- Inject row/column-level predicates at compile time across persona, tenant, and regulatory scope.
- Build or maintain itself from documentation, runbooks, and usage signals.
- Produce machine-readable compile traces for AI audit.
Each of those is foundational for putting AI agents into production. Adding them on top of AtScale is not a configuration change - it is a different architecture layered above OLAP.
What evaluators actually compare
Pricing
Credit where due: AtScale now publishes its pricing, which most of this category does not. The published model (June 2026) is consumption-based on deployed semantic objects (DSOs) - the dimensions, hierarchies, measures, and calculated measures visible in consumption tools - with unlimited users, queries, and data sizes: Growth at $10/DSO/month starting at $2,500/month (a $30K/year floor), Standard at $28/DSO/month starting at $7,000/month ($84K/year floor), and custom Enterprise. AtScale's own pricing explainer notes the average semantic model runs roughly 250 semantic objects - useful for sizing where on those meters a real deployment lands. The meter to understand before you commit: cost scales with how richly you model, which is also the thing you are buying the product to do.
Colrows has a free tier - unlimited datasources, users, and access policies with metered compute - and custom Enterprise pricing. Because the semantic graph is built autonomously, richer modeling does not carry a per-object price.
Modeling effort and SML
AtScale's models are hand-authored - historically in its design tools, now also in SML (Semantic Modeling Language), which AtScale open-sourced under the Apache license in September 2024, complete with converters for Snowflake Cortex semantic models, Databricks UC Metrics, and Power BI. That is genuine ecosystem progress, and it does not change the labour equation: someone authors and maintains the objects, and the DSO meter prices each one. On setup, the small Gartner Peer Insights review base (~4.2 stars across 16-17 reviews) is candid in both directions - reviewers praise query optimization on large data but report the product is "complex to set up and configure" and note integration restrictions that make it "a costly solution." Colrows builds the graph autonomously and maintains it with drift detection; modeling effort does not scale with concepts.
AtScale's AI positioning, addressed head-on
AtScale's current messaging will sound familiar to readers of this site: it now positions for agentic AI, stating that agents should "execute analytics deterministically through semantic models and MCP" and that "LLMs and agents cannot safely infer joins, metric definitions, or time intelligence from raw schemas." We agree - that is the compile-don't-generate thesis, and it is healthy that the category is converging on it. The evaluation then moves one level down: what is being compiled against, and who maintains it? AtScale's artifact is a hand-authored, OLAP-shaped model priced per deployed object, designed first for BI-tool consumption. Colrows' artifact is a typed, multi-scope semantic graph - entities, relationships, policies, examples - built and maintained autonomously, designed first for agent execution with join path proof and compile-time governance. Same thesis; different altitude, data model, and labour curve.
Migration and coexistence
AtScale cube definitions - and now SML files - can seed the Colrows semantic graph, and the two coexist where AtScale accelerates BI-tool consumption while Colrows serves agents and governed conversational workloads above the same warehouses.
Pricing, positioning statements, and review summaries reflect atscale.com, GitHub, and Gartner Peer Insights as of June 2026; they are the sources' claims, reported with attribution.
Reframing the comparison
AtScale and Colrows operate on different data models and serve different consumers.
AtScale = universal semantic layer, OLAP-shaped, BI-tool-facing. Optimised for accelerated, consistent multi-dimensional analytics. Modelling is manual. Resolution happens inside AtScale's query engine, often hitting pre-computed aggregates.
Colrows = semantic execution layer, graph-shaped, agent-facing. Optimised for governed, deterministic compilation of AI agent intent. The graph is built and maintained autonomously. Resolution happens at compile time, with policy injected before any SQL touches the warehouse.
The two coexist cleanly: keep AtScale powering your BI ecosystem; add Colrows as the agent-execution surface that compiles intent into governed SQL.
The bottom line
If your goal is accelerated, governed BI consumption from Tableau, Power BI, or Excel - and your team has invested in a multi-dimensional cube model - AtScale is a capable choice and a sensible default for OLAP-style analytics.
If your goal is to put AI agents into production - to compile their intent into governed SQL with proven joins, compile-time policy enforcement, and a continuously maintained semantic graph that evolves with your business - the data model AtScale assumes is too narrow. The semantic execution layer above it is what matters, and that is what Colrows provides.
At the core
| AtScale | Colrows | |
|---|---|---|
| Built for | BI consumption from cubes | Semantic execution for AI agents |
| Primary consumer | Tableau, Power BI, Excel, BI users | AI agents, autonomous workflows |
| Core strength | Aggregate awareness and BI-tool integration | Governed compilation of agent intent |
| Intelligence lives in | OLAP cube definitions | Typed semantic graph |
Semantic and intelligence handling
| Capability | AtScale | Colrows |
|---|---|---|
| Data model | Multi-dimensional cube | Typed semantic graph |
| Authoring model | Manual modelling and aggregate design | Autonomous, continuously maintained |
| Multi-hop reasoning | Limited - cube traversal only | Native - graph traversal across entities |
| Multi-scope resolution | Role-based dimensions | Global, datastore, persona, user scopes |
| AI readiness | Indirect - via SQL/MDX/DAX endpoints | Agent-native by design |
| Explainability | Query rewrite trace | End-to-end (intent → semantics → SQL → source data) |
Engineering and operational reality
| Dimension | AtScale | Colrows |
|---|---|---|
| Compile-time governance | Partial - role-based row filters | Yes - RBAC/ABAC injected into generated SQL |
| Aggregate awareness | Yes - core feature | Compile-level, dialect-perfect SQL with optimised joins |
| Drift handling | Manual cube redesign | Autonomous detection plus proposed mappings |
| Data replication | Sometimes required for aggregate tables | None - compiles SQL that runs on the warehouse |
| Audit trail | Query history | Point-in-time reproducible compilation trace |
| Coexistence | - | Ingests AtScale cube definitions; AtScale continues for BI |
Frequently asked questions
Is Colrows a replacement for AtScale?
For BI-tool consumption (Tableau, Power BI, Excel) of OLAP-shaped semantics, AtScale is purpose-built. Colrows replaces AtScale only when the consumer is AI agents instead of BI tools - then the agent-native compile pipeline, autonomous graph, and compile-time governance matter more than OLAP query acceleration.
Can Colrows ingest AtScale virtual cubes?
Yes. Cube definitions, dimensions, hierarchies, and aggregations modelled in AtScale can seed the Colrows semantic graph as a starting point. Colrows then maintains the graph autonomously and exposes it to AI agents via an agent-native compile surface that AtScale was not designed to provide.
Why is OLAP-shaped semantics not enough for AI agents?
AI agents reason across entities and relationships, not multi-dimensional cubes. A cube is optimised for slice-and-dice questions: revenue by region by quarter. An agent investigating a fraud spike has to traverse Customer to Transaction to Merchant to RiskEvent to ComplianceScope - that is graph traversal, not cube slicing. The data model itself is different.
How does aggregate awareness compare to compile-time governance?
AtScale's aggregate awareness rewrites queries to hit pre-computed aggregates for performance. That solves a query-acceleration problem. Compile-time governance solves a different problem: injecting RBAC, ABAC, and row/column-level predicates into the generated SQL before any byte is fetched. Both are valid - they address different pain points.
Is Colrows positioned as a BI semantic layer like AtScale?
No. AtScale targets the BI-tool ecosystem - Tableau, Power BI, Excel, and similar. Colrows targets AI agents and autonomous workflows. The architectures, the consumer assumptions, and the runtime patterns are different.
Can I run AtScale and Colrows together?
Yes. They serve different consumer audiences. AtScale powers your BI-tool experience; Colrows powers your AI agents. They share the underlying warehouse and can both compile to dialect-perfect SQL against it.
How much does AtScale cost?
AtScale publishes consumption pricing based on deployed semantic objects (DSOs): Growth at $10/DSO/month from $2,500/month ($30K/year floor), Standard at $28/DSO/month from $7,000/month ($84K/year floor), Enterprise custom - with unlimited users, queries, and data sizes. AtScale notes an average semantic model runs about 250 semantic objects, so size the meter against how richly you intend to model.
Is AtScale hard to set up?
The small public review base cuts both ways: Gartner Peer Insights reviewers praise query optimization on large datasets and report the product is "complex to set up and configure," with integration restrictions adding cost. Plan a real implementation phase with specialist modeling skills, and validate your BI-tool integration list early.
What is SML?
Semantic Modeling Language - AtScale's YAML-based modeling spec, open-sourced under the Apache license in September 2024 (github.com/semanticdatalayer/SML), with converters for Snowflake Cortex, Databricks UC Metrics, and Power BI semantic models. It makes AtScale models portable code; it does not change who writes them. Colrows can ingest SML definitions to seed its semantic graph.
Doesn't AtScale also claim deterministic AI execution?
Yes - AtScale now positions for agentic AI through semantic models and MCP, and argues LLMs cannot safely infer joins or metric definitions from raw schemas. We agree with the thesis. The difference is one level down: AtScale compiles against a hand-authored, per-object-priced, OLAP-shaped model built for BI tools; Colrows compiles against an autonomously built and maintained typed semantic graph with join path proof and compile-time governance, built for agents.
Further reading
- Deterministic vs Probabilistic Text-to-SQL: A Buyer's Framework - the accuracy evidence and the seven evaluation questions.
- Semantic layer platforms compared - the capability matrix across the category.
- What is a semantic layer? (Pillar guide) - the definitive 2,000-word guide to the category.
- Colrows vs Cube.js, vs dbt Semantic Layer, vs Looker, vs ThoughtSpot - other competitor comparisons.
- Snowflake, Databricks & the Semantic Layer - how warehouse-native and platform-native semantic layers compare.