Individual-analyst context layer, MCP-delivered
Connect ClariLayer to Claude Code, Cursor, or Codex over MCP. It bootstraps your real working context from the SQL you already have, then your AI data agent stops making the same data mistakes — wrong table, wrong join, refunds counted in revenue — session after session.
Connect your AIFour verbs, in your agent
ClariLayer installs as an MCP server into the agent you already use. From then on it exposes four tools — all live today.
bootstrapPoint ClariLayer at the work you already have — your SQL files, a data dictionary or codebook, your dbt models, an existing CLAUDE.md — and it bootstraps your real working context. Your SQL is validated and deterministically structured, and a data dictionary maps into one schema-note per variable; your dbt models and notes are imported. Day-1 value, not a cold empty store.
recallOnce connected, your agent has an in-flow recall tool (get_analysis_context) it can call to pull the right context mid-task — each entry tagged with its provenance and status — without you ever leaving Claude Code, Cursor, or Codex.
rememberEvery correction, join path, and gotcha you save is remembered across sessions. Your agent grounds on more of your context over time, so it gets progressively more right about your data. Want to capture a lot at once? Ask it to harvest the durable facts from a working session — they land in your Inbox for you to approve, never auto-saved.
reconcileA hand-written CLAUDE.md has the same trust problem as the original numbers — it's just asserted text. Reconcile grounds a saved definition against your real warehouse results: your agent runs the SQL with its own access and reports back the result shape. A declared-vs-actual mismatch surfaces as a caveat so you know exactly what to trust.
Reconciled, not blindly asserted
A hand-typed file of claimed definitions has the same trust problem as the original numbers — it's just asserted text. ClariLayer is different: it reconciles a saved definition against your real warehouse results. Your agent runs the stored SQL with its own access and reports back the result shape; ClariLayer compares declared-vs-actual and flags a mismatch as a caveat.
ClariLayer never holds your warehouse credentials and never executes SQL server-side — your agent is the connector and sends result metadata plus any optional preview rows it chooses to include. Today reconcile records a caveat on mismatch or leaves the entry asserted; a stronger verified mark is the documented trajectory, coming when our SQL parser fast-follow lands.
assertedThe honest baseline — we're taking your word for it. The default for anything you remember. In v1 a clean reconcile still reads asserted while recording evidence; a mismatch becomes a caveat.
caveatReconcile caught a declared-vs-actual mismatch. The valuable signal: you and your agent now know exactly what to treat with care.
provenanceEvery entry shows where it came from — you, a SQL import, a data dictionary, dbt, or a fact your agent suggested — surfaced next to its status so trust is legible at a glance.
in-flowAll of this rides inside the agent you already use, over MCP. No destination app to visit, no context-switch to check a number.
In-flow, via MCP
ClariLayer lives inside the agent you already use — there's no separate destination app. One command installs it as an MCP server into Claude Code, Cursor, or Codex. From then on your agent can recall the right context mid-task, remember new corrections, and reconcile definitions against your warehouse, all without you leaving your flow. The AI agent context guide walks through the recall-first loop that keeps your AI data agent grounded session after session.
The longer you use it, the more grounded it gets on your data — and the more annoying it would be to lose. The context you build is yours; it travels across your agents and later merges into shared team context. Already run a metrics stack? See how ClariLayer sits above your semantic layer.
Install the clarilayer MCP server into Claude Code, Cursor, or Codex.
Bootstrap your context from the SQL, data dictionaries, dbt, and CLAUDE.md you already have.
Your agent recalls, remembers, and reconciles in-flow — every session.
A session, before and after
Say you're an analyst chasing a familiar gap: the revenue dashboard says one number, the ad-hoc query you just ran says another, and the board deck is due this afternoon. Here is the same task without ClariLayer, then with it — using only the shipped verbs, nothing roadmap.
Without a context layer
orders — but your canonical revenue lives in fct_orders, and it's counting gross, refunds included.With ClariLayer, in-flow
bootstrap — on day one you point it at ./analytics/sql and your dbt models, so the canonical revenue definition is already in your context store, structured into tables, joins, and time grain.recall — the agent pulls that definition mid-task and reaches for fct_orders from the start, with provenance and status attached so you can see where it came from.reconcile — you ask it to check the saved definition against the warehouse. It runs the SQL with its own access and reports the result shape back; reconcile compares that against the definition's declared signals — columns, grouping, aggregates — and the shapes don't match, so it records a caveat. That caveat is the flag to investigate, and it sends the agent back to the numbers, where it finds refunds are still in the total.remember — you save the correction once: net revenue must net refunds. Next Tuesday it's already there; the agent doesn't re-litigate refunds, and the context you built quietly compounds.That caveat is the honest output of v1: reconcile records a caveat on a declared-vs-actual mismatch, or leaves the entry asserted when nothing conflicts. A stronger verified mark is the documented fast-follow — it lands when our SQL-parser work ships, not before. And throughout, ClariLayer never holds your warehouse credentials and never executes SQL server-side: your agent is the connector, sending result metadata and any preview rows it chooses to include.
For teams · where this is going
ClariLayer starts as your personal context layer. As a team adopts it, the personal context analysts build merges into shared, owned, governed team context — ownership, approval, and the one right metric. That's the Expansion path, and the governance feature set is kept here for teams ready for it.
These capabilities aren't the headline — the single-player loop above is — but they're where ClariLayer goes as it becomes production infrastructure for a whole team.
As a team adopts ClariLayer, the personal context analysts build can be proposed up to shared, owned, governed context — tier-based approvals, immutable release bundles, and audit trails for high-stakes metrics.
Explore team governance, ownership, and release evidenceYour reconciled definition can be proposed up to the team's shared layer, and the team's canon can flow back down to you — always with agency: adopt it, override it, or fork it, never a silent overwrite.
Explore how personal context becomes team canonWhat flows across an edge carries its owner, version, and validation evidence, so whoever adopts it — a teammate, or their AI data agent reading the governed contract — knows whether to trust it.
Explore the evidence a definition carriesAs teams adopt it, agents, dashboards, and internal apps can fetch the governed definition, owner, version, and trust state through a read-only contract instead of scraping stale warehouse artifacts.
Explore the read-only contract for team agents and BI toolsConnect ClariLayer to Claude Code, Cursor, or Codex. It bootstraps your real working context from the SQL you already have, then your agent stops making the same data mistakes — session after session.
Connect your AIWe use privacy-friendly analytics
With your consent we use PostHog and Vercel Analytics to understand how ClariLayer is used so we can improve it. We never sell your data. Errors are always monitored (without analytics) so we can keep the app reliable. You can change your mind anytime.