> ## 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. Looker

> Only Looker compiles LookML, and every viewer needs a seat. Credible makes the model the product: an open language you own, served to every surface.

## How Looker describes itself

Looker is Google Cloud’s enterprise BI platform: metrics and joins are defined in LookML, Explores and dashboards consume them, and Gemini answers questions grounded in the same model. Google positions the current product as agentic BI — conversational and dashboard agents, a managed MCP server, and LookML as the governed definition behind every answer.

## Credible and Looker (Google Cloud) compared

| Dimension | Credible | Looker |
| --- | --- | --- |
| Category | The AI Analytics Engine — you write down what data means, and it generates the stack under it | Enterprise BI suite. LookML is the semantic layer, and Looker is the product that compiles it |
| Who it is built for | The whole organization, not one central team — ops, finance and product; spreadsheet users through ML engineers | A central BI or analytics org serving the wider enterprise |
| 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 | Its own UI — dashboards and Explores to consume, LookML authored in-app |
| Modeling language | Malloy — a modern programming language for data: imports, inheritance, public and private members, and queries that compose into new sources | LookML — a declarative modeling format, paired with Looker’s own query generation |
| 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. LookML is text in your repository and Looker is the only thing that compiles it |
| 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 LookML in a bespoke Looker IDE |
| 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 | access_filter and access_grants in LookML, each keyed to a user attribute managed separately in Looker. Filters attach per Explore, and every user needs a value for the attribute or the Explore errors. required_access_grants can gate individual fields |
| 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 | Persistent derived tables: a derived_table block with its own SQL, a persistence strategy — persist_for, or a trigger plus the datagroup that fires it — and a scratch schema the connection may write to. Incremental refresh needs an increment_key and rules out persist_for. Mature and warehouse-native |
| 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 tour of the instance: get_models, then get_explores, then get_dimensions, get_measures, get_filters and get_parameters per Explore, with get_field_value_suggestions once the agent knows the field |
| 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 | The Looker UI, embeds and its API, plus a managed MCP server. A conversation is scoped to one Explore at a time, or five per data agent |
| 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 | Runs in a Looker instance — a dedicated server or cluster you size, with queries, PDT rebuilds and scheduled delivery all drawing on it. The LookML goes nowhere else; nothing else compiles it |
| 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 | A platform fee before a single seat, since Google publishes no list price, then per-user licences by role. Google has announced that Gemini answers meter as data tokens pooled per instance from October 2026 |

## Where Credible takes a different approach

### Everyone who wants a number needs a licence

Looker charges a platform fee before anyone logs in — Google publishes no list price — and then a licence per person, by role. So teams ration seats — and rationing does not remove the cost, it relocates it: the unlicensed majority waits on the licensed few, and somebody spends their week denying access the company is already paying for. Seats made sense when a report was one person’s job. Credible meters usage — tokens, compute time and storage — and never a person. Users are unlimited on every plan, so the hundredth colleague who wants a number adds nothing to the bill and needs nobody’s approval to ask.

### The person who wrote LookML wrote Malloy next

LookML made the model explicit, version-controlled and reviewable, and a great deal of what this category now assumes starts there. Lloyd Tabb co-founded Looker and designed it. Malloy — the language Credible models in — is what he built afterwards: imports, inheritance, and public and private members, so a definition is written once and reused rather than restated. A declarative format gets verbose as it ages, and a LookML project that has run for years tends to carry definitions nobody is certain are still live. Composition is the answer to that, and it is also what makes a large model safely extensible by an agent.

### Only Looker compiles your LookML

The definitions are the asset: years of metrics, join cardinality and curation, written down a field at a time. LookML is plain text in your own repository, and exactly one product can compile it — so the repository is worth what the licence is worth. It is also what the rest of the product is shaped around; embedding and the MCP server both arrived later, over a model designed for Looker’s own Explores. Credible’s model is Malloy: open source, MIT-licensed, served by Malloy Publisher, which we build and maintain in the open, and compiled against BigQuery, Snowflake, Postgres, MySQL, Databricks, Trino or DuckDB. Stop paying us and it keeps running.

### A question nobody has asked yet is a ticket

A field that does not exist means a LookML change, a review, and a wait on a small team. The reviewers are not slow; there is simply more drafting than a handful of people can absorb. The people who cannot wait export to a spreadsheet and redefine the metric themselves, and one number quietly becomes three. Credible separates drafting from approval: a colleague describes the change in plain language, a coding agent writes the Malloy, and the owner reviews the diff as a pull request. The same gate, without the queue in front of it.

### A conversation covers one Explore

Conversational Analytics is grounded in LookML rather than pointed at raw tables, and Looker composes the query so joins, filters and permissions hold. It is also scoped to the Explore it was aimed at: Google’s documentation puts a standard conversation at one Explore at a time, a data agent at up to five, and any query at 50,000 rows. That fits a question sitting inside an Explore someone already built for it. A question that crosses two does not, and the answer is to go build the Explore that spans them. Credible searches an index of the whole published model, so the scope of a question is the model rather than a choice somebody made in advance, and a cross-domain question is answered by running a few targeted queries.

### How an agent finds a field

Looker’s MCP tools are its API: get_models, then get_explores for a model, then get_dimensions, get_measures, get_filters and get_parameters for an Explore, with get_field_value_suggestions once the agent already knows which field it wants. The agent tours the instance to build a map before it can ask anything, and pays for the tour in tokens every session. Credible compresses the model into a concept index at publish and searches it: typed targets — source, dimension, measure, view, and the actual values of indexed dimensions — come back ranked. A question about “sports gear” finds Running Shoes and Athletic Apparel without anyone naming a column first. Small request in, small context out.

### Who writes the dashboard, and where it lands

Ask Looker’s MCP server for a dashboard and it calls make_dashboard and add_dashboard_element: the result is content created inside the instance, reviewed by whoever happens to notice it. Credible writes a dashboard as a data app on the governed model — text, in your repository, arriving as a pull request, with the query behind every tile one click away. The difference shows up the first time somebody asks who changed a tile and why.

### The AI arrives with its own meter

Google has announced that Gemini answers in Looker meter as data tokens pooled at the instance level, with overage from October 2026, on top of the platform fee and the per-role seats. Input covers the prompt, the session history and the context sent with it; output covers the reply, the generated SQL and the reasoning. So the conversational surface lands as a third meter over a licence model that already charges per person. Credible has one bill and no seats, your agent’s own LLM tokens are never billed to you, and a query that runs on your own warehouse is metered on the result it hands back rather than the compute to produce it.

### One annotation, or the parts you assemble

Persisting a table in Looker is an assembly job: a derived_table block carrying its own SQL, a persistence strategy, the datagroup defined elsewhere that fires it, and a scratch schema the connection may write to. Credible persists a source with one annotation, in the file that already holds the logic. Access rules repeat the pattern. Both are code in a repository, so that was never the difference: an access_filter attaches to an Explore, and Looker’s docs say to apply it to every relevant Explore or that data stays unrestricted. One annotation on the source covers everything that reads it — though Looker is ahead in one place, since required_access_grants gates individual fields and Malloy has none.

### You can read how your LookML gets converted

Migration tooling is usually a black box: you hand over a project and get a model back. The adapter that reads LookML here is `malloy-lookml-review`, MIT-licensed in Malloy Publisher, and every phase of it is a markdown file you can read before you run it — how a `hidden: yes` field is told apart from a `fields` exclusion, when a derived table is performance-only rather than a real transformation, which patterns are flagged for a person instead of converted. That distinction is not cosmetic: `hidden` mapped to an access modifier over a few hundred fields is the difference between a model an agent can use and one it quietly misreads.

### What a migration actually keeps

A LookML project that has run for years exposes far more than anyone queries. On one certified dashboard migration — 28 tiles over three explores — the explores exposed roughly 6,500 fields and the rebuilt model kept 377 of them, with every supported tile reproduced and validated row by row against live data. The trim is the work, and Looker is what makes it defensible: System Activity already records what people actually ran, so the set that matters is established from query history rather than argued about. Recreating tile for tile ports the old ceiling across with the content.

Capability claims about Looker were checked against public sources in September 2026. Sources: Looker-managed MCP server and its tool list — Google Cloud documentation and MCP Toolbox; Conversational Analytics scope, Explore limits and grounding — Google Cloud documentation; Looker editions, per-role licensing and Conversational Analytics token overage — Google Cloud pricing; Persistent derived tables, access_filter and access_grants — Google Cloud documentation; Lloyd Tabb — Looker co-founder, author of LookML, creator of Malloy; malloy-lookml-review, MIT-licensed — Malloy Publisher on GitHub; Field counts and parity results — Credible customer migration, 2026.