Credible vs. Looker

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.

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.

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

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.

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.

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.

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.

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.

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.

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.