Slow time-to-market
A simple analytics feature expands into months of backend work — a pipeline, a serving layer, per-tenant security, caching — before a single chart reaches a customer.
Embedded analytics
Ship trusted data products. Skip the infrastructure.
Give your product the same data model your agents and analysts already trust. The engine generates the rest — pipelines, storage, and governance, with access rules and tenant isolation enforced on every query — and no warehouse is required to start.
You build the experience — the charts, the chat, the workflow your customers actually see. The engine owns everything underneath it.
The problem
Why data products stall
Internal metric drift is damaging enough. Export it into your product and it erodes your customers' trust in you.
Inflexible experiences
Static charts give customers little room to explore, and an AI chat bolted on later answers from raw tables with unfounded confidence.
Failure to scale
The solution that works for ten customers breaks at a thousand. Data apps time out and queries fail under real usage.
Skyrocketing cost
A proof-of-concept chatbot is not a multi-tenant data product. Brittle queries, prompt tuning, and a warehouse bill that grows with every customer become permanent overhead.
Across the product team
Describe the feature. Ship the data product.
Embedding analytics used to be a platform project for a specialist team. Now anyone who knows the product can start one. A product manager describes the feature in plain language in Credible; the agent writes the model and the data app; an engineer reviews the pull request in GitHub, and merging ships it inside your product. The engine owns everything underneath.
Product managers & designers
Describe the experience customers should get — the metrics that matter, the questions they'll ask, what each tenant may see — and the agent drafts the model and the first data app for review. No pipeline, no SQL.
Application engineers
Review the model like any other pull request, then build the experience against one governed API. Isolation, caching, and materialization are the engine's job, not yours.
AI agents
Draft the model from your descriptions, answer customers' questions from it, and propose improvements — a clearer definition, a missing index, a rollup worth declaring — as changes for a person to review.
How it works
A governed foundation delivered into your product
Underneath the conversation, the model is plain text — the same handful of declarations an engineer reviews in the pull request. Write down what your product's data means; the engine generates, secures, and serves everything your product needs from it.
One model for product data
Define what your data means: the metrics, dimensions, relationships, and access rules. Data apps, AI chat, and API responses all draw from that one model, so the number in a chart is the number in the chat.
Tenant isolation, declared in the model
Declare who sees what next to the data it protects. A secure given, resolved from each caller's verified identity, scopes every query tenant by tenant — enforced at the gateway, not scattered across application code. Nobody reimplements row-level security in JavaScript.
given:
#(secure)
ALLOWED_TENANTS :: string[]
#(authorize) tenant_id in $ALLOWED_TENANTS
source: tenant_analytics is app_data extend {
measure:
#(doc) Active accounts for this tenant, shown on the Usage page.
active_accounts is count(distinct account_id)
}Discoverable by meaning
At publish, the engine compresses the model into a concept index — every source, measure, and dimension, its #(doc), and the actual values of every #(index)dimension on unrestricted sources — so your product's AI matches a customer's question by meaning, not by column name. “Enterprise accounts” finds the plan tier.
dimension:
#(doc) Plan tier at the time of the event: Free, Team, or Enterprise.
#(index)
plan_tier is account.planFast and cheap, by annotation
One annotation turns an expensive source into a managed table, refreshed incrementally; another pre-computes the rollups coarser questions answer from. Results are cached. Your customers' data apps load from small tables instead of scanning a warehouse, and the bill follows.
#@ persist refresh="incremental" watermark="event_at"
source: usage_events is app_data.table('events') extend {
measure:
#@ preaggregate grain="event_at.day"
#(doc) Actions per day. Coarser questions answer from the rollup.
actions is count()
}Delivered on every surface
Serve the model through APIs, data apps, and MCP — the open protocol that connects agents to tools. A package with a public/ directory is a web app, served through the same governed path every other query takes — so a customer who opens it sees only their rows.
Built for production
A foundation for better products
Fast, trustworthy analytics for your customers — with governance and visibility over every user and every query.
Built on open-source Malloy
The open language the engine speaks. Your model is plain text in git — portable, inspectable, yours — on any warehouse, locked into none.
Enterprise-ready by design
Tenant isolation, fine-grained access rules, and a permanent audit trail, enforced at the one gateway every query passes through. SOC 2 compliant.
One releasable unit
Model, data apps, and the tables the engine builds from them ship as one versioned package — tested as one unit, promoted with zero downtime, rolled back by pointing at the previous version. Nothing drifts apart.
No warehouse required
The engine brings its own query engine and storage. Connect data where it already lives — databases, spreadsheets, flat files — and skip the months of ETL in front of a data product.
Shows its work
Every tile can open the query that produced it, and hand itself to an agent for the follow-up. Trust your customers can inspect.
Priced like infrastructure
Users, publishing, and MCP access are free. You pay for tokens, compute time, and storage, so a small feature ships without an enterprise contract.
The result
AI that answers from governed measurements
Your clients are already asking for the AI version of your data product. Ship one whose every answer is bounded by what the data supports — and stands up in the room where it gets used.
Live in four months, tested against certified reporting
VideoAmp, a media performance platform whose cross-channel solution is used to buy, sell, and measure advertising, leveled up that solution with AI — and plausible answers wouldn't be good enough. Its product, engineering, and data science teams wrote the methodology down as a governed model, more than 2,000 plain-language definitions, business rules, and warnings, and Credible delivers the relevant part to the AI on every question, so answers come back with VideoAmp's verified numbers instead of the AI's own guesses. The system refuses to answer rather than answer wrong, was tested against certified reporting before launch, and went from kickoff to a live demo at Cannes Lions in about four months — authored and owned in-house, and now extending across the platform.
Ready when you are
From proof-of-concept to production without the rewrites.
See how the AI Analytics Engine helps you ship a data product with the team you already have — no standalone ML project, no new infrastructure to stand up.