> ## Site Index
> Fetch the site index at: https://www.credibledata.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Credible vs. Snowflake Cortex

> Snowflake is the right home for the central data team. Credible is built for the work happening outside it, on every source the business runs on.

## How Snowflake Cortex describes itself

Cortex is the AI layer of the Snowflake data cloud. Cortex Agents plan, call tools and answer over semantic views, with Cortex Analyst as the tool that writes the SQL — Snowflake now points you at Agents rather than the standalone Analyst API. CoWork, formerly Snowflake Intelligence, is the surface most people meet it through. All of it is native to Snowflake, with its access control and its billing.

## Credible and Snowflake Cortex compared

| Dimension | Credible | Snowflake Cortex |
| --- | --- | --- |
| Category | The AI Analytics Engine — you write down what data means, and it generates the stack under it | Warehouse-native agentic AI — Cortex Agents over Snowflake semantic views, with CoWork as the front end |
| Who it is built for | The whole organization, not one central team — ops, finance and product; spreadsheet users through ML engineers | Data teams already standardized on Snowflake |
| 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 | Ask in English in CoWork, or call an agent over REST or MCP; semantic views authored in SQL DDL, YAML or Snowsight |
| Modeling language | Malloy — a modern programming language for data: imports, inheritance, public and private members, and queries that compose into new sources | Semantic views — SQL DDL or a YAML spec, native to Snowflake, scoped to the schema they are declared in |
| 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 | Vendor-owned. Snowflake started Open Semantic Interchange, now incubating as Apache Ossie — though no product ships native support for the spec yet |
| 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 | Autopilot drafts a semantic view from your tables, dashboards or query history, hand-tuned afterwards |
| 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 | Snowflake’s own role-based access control, inherited — and granted again, tool by tool, on an MCP server |
| 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 | Whatever Snowflake gives you — result cache, dynamic tables, materialized views. Not a Cortex concern |
| 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 | Cortex Search retrieves dimension values by hybrid keyword and vector search, re-ranked, and an agent routes across the semantic views it is given — Snowflake’s guidance is many small views rather than one large one |
| 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 | A REST API, CoWork, and a Snowflake-managed MCP server external clients reach over OAuth — carrying tools, but not the rest of the protocol |
| 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 | Scales with Snowflake, over data Snowflake can reach — its own tables, plus Iceberg and external tables |
| 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 | Snowflake credits — AI credits for an agent, additive across every tool it calls, on top of the platform credits the account already burns |

## Where Credible takes a different approach

### Model first, pipeline second

A semantic view describes physical objects a pipeline already built. That is the inherited order of the last decade — land the raw tables, transform them layer by layer, and write down what any of it means at the end, if the sprint allows. It was a rational answer when dashboards were the consumer and a person stood between the model and the decision. Agents removed that person. Credible flips the order: the data model is the input, written once in Malloy — entities, metrics, relationships and their cardinality, the business rules and the edge cases — and the engine derives the transformations, the materialized tables, the access enforcement and the context every agent reads. Meaning stops being documentation of the pipeline and becomes the specification for it.

### Where the work is actually happening

Snowflake is a good answer for the central data team, and that is who a warehouse is built for: centralized, curated, governed by specialists. The work has been moving the other way. Coding agents have put data work in the hands of domain teams — ops, finance, product — who own questions the central backlog was never going to reach. A warehouse is the wrong shape for that: it asks the business domain to land its data centrally first, then wait for someone to model it. Credible inverts the order. The domain writes the data model against the data it already has, and the engine builds and serves everything under it. Centralize the definitions and the access policy; decentralize the rest.

### Every source the business runs on

A central warehouse holds what someone decided to load into it. The business domain runs on more than that — the Postgres behind the product, a spreadsheet finance maintains, Parquet sitting in object storage, the second warehouse that arrived with an acquisition. Cortex reaches what Snowflake can reach, which Iceberg and external tables have widened considerably, but the pattern still begins with getting the data in. Credible connects to BigQuery, Snowflake, Postgres, MySQL, Databricks, Trino, DuckDB and MotherDuck, reads CSV, Parquet and JSON in place from S3, GCS or Azure Data Lake, and takes spreadsheets shipped inside a package. One data model spans all of it, and none of it requires a warehouse to start.

### What it costs once agents are the ones asking

Warehouse economics were set when humans asked the questions. Agents ask far more of them, in bursts, and every one is a scan. A warehouse bills a minimum window every time it resumes, so a trickle of small agent queries against an idle one pays that minimum again and again — and Cortex adds AI credits on top, additive across every tool an agent calls. Credible attacks both bills. One annotation materializes a source into the engine’s own storage, another makes a dimension’s values searchable, a third answers coarse questions from a rollup — so queries stop re-scanning the warehouse. And retrieval returns only the slice of the model a question needs, rather than carrying the whole thing in every prompt.

### Embedded analytics, and the warehouse underneath it

A dashboard tolerates a slow query. A product feature does not. A warehouse gives you variable latency by design: queries queue once concurrency runs out, and a warehouse that has gone idle has to resume before it answers — precisely the traffic shape an embedded feature has. Snowflake’s answer is interactive warehouses, which are genuinely fast and built for exactly this shape of traffic. Credible’s is to serve from materialized storage the engine controls rather than from a warehouse scan, so the latency your customers see does not track your warehouse’s mood. What comes back matters too: results are served over MCP carrying an interactive UI resource, so a chart renders in the client rather than being described to it — where Snowflake’s managed MCP server, real and general as it is, documents no support for MCP resources, prompts or notifications.

### One package, or a release cycle per tool

Snowflake has built a real lifecycle story, and it deserves saying plainly: Workspaces is a Git-backed IDE, dbt Projects on Snowflake is generally available, a dbt package manages semantic views as models in your repository, and the CLI validates a pull request in an isolated environment before it merges. What it does not have is one unit of release. The transforms version in the dbt project, the semantic view in its own package, the agent is configured apart from both, and the app ships somewhere else again — each with its own cycle, and nothing that makes them true of each other. In Credible the model, its metadata, its access rules, its data apps and its embedded data are one package, published as an immutable version, promoted only once its indexes and materialized tables are actually built, and rolled back by pointing at the previous version.

### What survives the relationship

A semantic view is an object inside a Snowflake account. An agent built in Cortex is configured there, reasons with Snowflake’s orchestration, and bills in Snowflake credits. That is coherent, and worth it if the whole estate is Snowflake and intends to stay. The question worth asking of any vendor here, ourselves included, is what you would still have if you stopped paying tomorrow. Credible’s answer is a Malloy model: an open-source language, in your own repository, served by Malloy Publisher, which we build and maintain in the open, and compiled against seven dialects. Snowflake started Open Semantic Interchange, now incubating as Apache Ossie — a real commitment to portability and worth watching, though no product ships native support for the spec yet.

Capability claims about Snowflake Cortex were checked against public sources in September 2026. Sources: Cortex Agents, Cortex Analyst, and the August 2026 note recommending the move from Analyst to Agents — Snowflake documentation; Semantic views: overview, YAML specification, and best practices for Cortex Analyst — Snowflake documentation; Snowflake-managed MCP server, generally available August 2026, including its documented limits — Snowflake documentation; Warehouse billing, concurrency and queuing, and interactive analytics — Snowflake documentation; dbt Projects on Snowflake, Workspaces and CI/CD, and the dbt package for semantic views — Snowflake documentation and engineering blog; Snowflake Intelligence renamed CoWork — Snowflake, June 2026; Apache Ossie (incubating), formerly Open Semantic Interchange — Apache Software Foundation, July 2026.