Gaur
Now in early access

The Default Backend
for Data Applications.

Connect your data. Define your metrics, dimensions and access rules once. Serve them to every dashboard, app and AI agent, with the same numbers everywhere.

Try it liveBook a demo
contract.json
{
  "name": "revenue_by_plan",
  "sources": [
    { "name": "subscriptions", "alias": "s" }
  ],
  "dimensions": { "plan": { "sql": "s.plan" } },
  "measures":   { "mrr":  { "sql": "SUM(s.amount)" } },
  "rls": {
    "sql": "s.tenant_id = {{ tenant_id }}",
    "parameters": { "tenant_id": "string" }
  }
}
Dashboard
GET /query · revenue_by_plan
Chat
POST /chat · same contract
AI agent
MCP · same access rules
The old way

Analytics today is a tangle of brittle pipes and disagreed numbers.

Every new consumer of your data ships its own queries and access checks. The numbers drift and the rules diverge.

A new pipeline for every consumer

Every dashboard, internal tool and AI feature ends up rebuilding the same queries against raw tables. Different filters, different joins, no shared access rules.

Twelve definitions of MRR

Finance, growth and product each ship their own SQL. Numbers diverge, trust erodes, every meeting starts with reconciliation.

AI on top of chaos

Plugging an LLM into a warehouse with no governance turns hallucinations into business decisions.

What Gaur is

The governed backend for everything that queries your analytical data.

Ingest from your warehouses, lakes and files. Define your metrics, dimensions and contracts once. Serve them to dashboards, apps, APIs and AI agents, consistently and safely.

Your sources
SnowflakeWarehouse
BigQueryWarehouse
S3 / R2Lake
Parquet · CSV · ExcelFiles
Stripe, Salesforce…Apps

+ Postgres, Redshift, DuckDB, GCS, HubSpot, Segment, NetSuite

Your consumers
Dashboards
Internal tools
AI agents
Serve · Chat with data

Ask your data like you'd ask a teammate.

Pick a question to see Gaur run it against a sample 20-store cafe chain. Natural language in, governed answers out.

  • Questions answered through your contracts, never raw SQL
  • Answers grounded in your metrics and access rules
  • Audit trail of every question and result
Explore the sample dataset
sample · jaffle_shop
preview
Or try
Busiest hours across all storesTop products by gross marginNew vs returning revenue mixSales tax collected per store
Define once

One definition. One correct answer.

Every contract carries the access rules and the audit trail. Adding a new consumer doesn't mean writing another query.

  • Access rules travel with every query
  • Every call audited, including agent calls
  • Add a new consumer without writing another query
question: revenue by plan
one contract
1+one contract defines "revenue by plan"
2+the dashboard, the app and the AI agent all call the same contract
3+each caller only sees the rows their access rules allow
4+one API key per consumer, audited end-to-end
5✓→ one answer. Same numbers everywhere.
Capabilities

One platform. Every data interface your team needs.

Chat with data

Natural-language questions resolved against your governed metrics and access rules.

Contracts & semantic layer

Define metrics, dimensions and access rules in one governed interface. Every consumer queries through it.

Connect any source

Ingest from Postgres, MySQL, SQLite, Cloudflare D1, Amazon S3, Cloudflare R2, Stripe, webhooks and file formats (CSV, Parquet, Excel, JSON). Snowflake and BigQuery in the build pipeline.

Embedded analytics

Ship charts and dashboards inside your product with row-level security and tenant isolation.

Governance

Row, column and tenant policies. Audit logs of every query, by every human and agent.

APIs for every consumer

A query API for apps, a chat endpoint for natural language, and an MCP server for AI agents. One API key per consumer.

The old way vs Gaur

Same questions. Fewer fires. Less custom plumbing.

Source of truth for metrics
Traditional BI / DIYScattered across SQL files and dashboards
With GaurOne semantic layer, versioned
When a query goes wrong
Traditional BI / DIYReturns a number anyway
With GaurReturns a clear error
Adding a new consumer (app, agent)
Traditional BI / DIYWrite a new pipeline
With GaurCall the API, governed by default
Natural-language questions
Traditional BI / DIYBolt-on LLM, ungrounded answers
With GaurAsk Gaur, grounded in your metrics
Time to first dashboard
Traditional BI / DIY2–6 weeks
With GaurSame afternoon
Who it's for

Built for the people who own the numbers.

For data teams

Stop writing the same query twice.

Define each metric once. Hand every team a contract instead of another ad-hoc SQL request.

Build · Define · PublishRead the workflow
For product teams

Customer-facing analytics, governed.

Ship charts, usage meters and AI features into your product, with tenant isolation handled before the query runs.

For founders

One number, every meeting.

The board deck, the investor update and Monday standup all pull from the same governed contracts.

For engineers

An API surface your team actually wants to build on.

A single API for every consumer: a query endpoint for apps, a chat endpoint for natural language, and an MCP server for AI agents. Tenant context built in.

  • One API key per consumer, scoped at creation
  • Tenant context passed per request, enforced by the contract
  • Same response shape for every protocol
app/api/revenue-by-plan.ts
// REST query against a contract.
const res = await fetch(
  "https://api.gaur.run/v1/api/<consumer>/query",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${apiKey}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      contract_name: "orders",
      query: {
        measures: ["revenue"],
        dimensions: [{ name: "plan" }],
      },
      context: { tenant_id: req.tenantId },
    }),
  },
);
const { data } = await res.json();
FAQ

Questions teams ask before they book.

If you don't see yours, the demo call is the fastest way to get a straight answer.

No. Gaur is the governed backend your dashboards, apps, APIs, BI tools and AI agents all query. You define your metrics and dimensions once and serve them to every consumer, so every chart and every agent speaks the same numbers.
No. Gaur ingests data from your sources (Postgres, MySQL, Amazon S3, Cloudflare R2, Stripe, plus CSV, Parquet, Excel and JSON today, with Snowflake and BigQuery in the build pipeline) and runs queries on its own engine. Your warehouse stays the system of record. Gaur is the serving layer your apps and agents talk to.
Three ways, one API key. A structured query API for apps, a chat endpoint for natural-language questions, and an MCP server for AI agents. All three go through your contracts, never raw SQL.
Gaur is in early access. Pricing is usage-based, scoped to active contracts and query volume. There's no free tier today.
Yes. Every contract carries row-level access rules, so each caller only sees the rows they're allowed to. Your backend sets the context, not the end user. Audit logs capture every query and result. SOC 2 Type II is in progress.
A self-hosted option is available for design partners on annual contracts. The managed cloud is the default and is what most teams choose.
A contract is the named, governed way to ask a question. It defines which data it draws from, the metrics you can ask for, the dimensions you can group by, and the access rules that decide what each caller is allowed to see. Gaur checks each contract for the common mistakes that quietly produce wrong numbers, both when you define it and when it runs. Every query returns a correct answer, or a clear error.
Ready when you are

You run your business.
We run your analytics.

Hop on a 30-minute call. We'll connect a sandbox to your warehouse and show you Gaur on your numbers.

Try it liveBook a demo