The context layer your agents run on.

Introspection builds a model of your warehouse. Curation refines it. The agent fills a typed query against it, and never writes SQL from memory.

Semantic model

4 models · 3 relationships · derived from foreign keys

customers48.2K
  • PKcustomer_iduuid
  • FKregion_idint
  •  first_order_attimestamptz
  •  channeltext
orders12.8K
  • PKorder_iduuid
  • FKcustomer_iduuid
  •  placed_attimestamptz
  •  net_revenuenumeric
products1.4K
  • PKproduct_idint
  •  categorytext
  •  unit_costnumeric
order_items43.7K
  • PKitem_iduuid
  • FKorder_iduuid
  • FKproduct_idint
  •  quantityint
  • customers1:Norders
  • orders1:Norder_items
  • products1:Norder_items

What sits between question and warehouse.

A schema tells you which columns exist. A model tells an agent what they mean, how they connect, and how they may be counted.

Models, not tables

Each table becomes a model with typed columns, a primary key and labels in your team's words. The agent selects from models, never from a remembered schema.

Relationships from your keys

Every foreign key becomes a relationship carrying a direction and a cardinality. Questions resolve across that graph, so a join path is looked up rather than guessed at.

Metrics defined once

Revenue carries its filters and its grain in the model. Every question that mentions it resolves to the same calculation, whoever asked and from whichever surface.

A typed query

The agent fills a query object: model, aggregations, dimensions, filters, order, limit. There is no SQL string in its hands to get subtly wrong.

Why you can trust it

Why an agent here can be trusted.

A text to SQL agent is trusted to remember your warehouse correctly. An agent on a semantic layer is not trusted with that at all.

  • Selection, not generation

    Text to SQL asks a language model to recall your schema and produce a string. Here it chooses from a model that already carries the keys.

  • Deterministic resolution

    The same query against the same model compiles to the same SQL every time. Phrasing changes the conversation, not the plan underneath it.

  • One layer, every surface

    Chat, dashboards, embedded views and anything built on the API resolve through the same models and metrics. Two surfaces cannot quietly disagree about revenue.

  • It says what it cannot

    Where the model cannot express a question, iDash names the missing piece rather than inventing a column. You get a modelling task back, not a plausible number.

Compiled query planVerified

Question

What was revenue by region last quarter?

Resolved

model
orders
measure
sum(orders.net_revenue)
dimension
regions.region_name
grain
order_id

Join path

orderscustomersregions
  • customers.customer_id · many to one
  • regions.region_id · many to one

Primary key dedup applied on order_id

order_items multiplies each order row 3.4 times on average. Revenue is measured on the order grain, so the compiler dedups on the primary key before aggregating.

Compiled plan

WITH orders_dedup AS (
  SELECT DISTINCT ON (o.order_id)
         o.order_id, o.customer_id, o.net_revenue, o.placed_at
    FROM orders o
    JOIN order_items oi ON oi.order_id = o.order_id
)
SELECT r.region_name,
       SUM(od.net_revenue) AS net_revenue
  FROM orders_dedup od
  JOIN customers c ON c.customer_id = od.customer_id
  JOIN regions   r ON r.region_id   = c.region_id
 WHERE od.placed_at >= DATE '2026-05-01'
   AND od.placed_at <  DATE '2026-08-01'
 GROUP BY r.region_name
 ORDER BY net_revenue DESC
  • Join path resolved, 2 hops, no ambiguity
  • Primary key dedup applied on orders.order_id
  • One inflated model in the query, single dedup CTE is sufficient
  • Read only connection, statement timeout 30s
  • 5 rows · 412ms

Built by introspection, refined by your team.

Nobody starts a modelling project from nothing. iDash writes the first version from your warehouse, and the people who know the business correct it.

Introspection writes the draft

Connecting reads tables, columns, primary keys and foreign keys, and turns them into a model you can query the same afternoon.

Curation makes it yours

Rename fields into the words your team uses, hide what nobody should read, and write down the definitions people currently argue about in meetings.

It tracks the warehouse

Schemas move. Reconnecting picks up new tables and columns and shows what changed, so the layer your agents run on stays the layer you approved.

See what your schema already knows.

Connect a read-only replica and read the model iDash builds from it before you ask a single question.