The context layer that checks itself · MCP-delivered
Stop re-explaining your data to your AI every session.
Connect ClariLayer to Claude Code, Cursor, or Codex. It bootstraps your real working context from the SQL you already have — the context your AI data agent recalls before it answers. Then your agent stops making the same data mistakes — wrong table, wrong join, refunds counted in revenue — session after session.
One command to connect
Your context layer
What your AI knows about your data
- Asserted
Active customer
Definition · you → reconciled
- Asserted
Net revenue (excl. refunds)
Definition · from dbt
- Caveat
orders.region — null before 2023
Schema note · you → reconciled
- Asserted
fct_orders ↔ dim_customers join
Join path · you
Reconciled against your source — not blindly asserted. Mismatches surface as a caveat so you and your agent know what to trust.
ClariLayer never holds your warehouse credentials and never runs SQL server-side. Your agent runs the query with its own access and sends back the result shape; ClariLayer reconciles it and flags caveats.
Bootstraps from the SQL and dbt you already have
See it work inside the agent
Your context, recalled and reconciled — without leaving Claude Code.
One command to connect. Then your agent recalls the definition you saved, runs the query with its own warehouse access, and reconcile flags what to treat with care.
saved context · returned by recall
Reenactment of the real loop — the same recall → reconcile → caveat flow the MCP runs today. Your agent keeps its own warehouse access; ClariLayer never holds your warehouse credentials and never runs SQL server-side.
Your AI is brilliant — and it forgets your data every session.
Every session starts from zero
New chat, new context window — and your agent has forgotten which table is the real one, how the joins go, and which definition you actually use. You re-explain it. Again.
A CLAUDE.md is just asserted text
Hand-typing your definitions into a notes file has the same trust problem as the original numbers: nothing checked it against your warehouse. It drifts, and your agent trusts it anyway.
So it repeats your data mistakes
Wrong table, wrong join, refunds counted in revenue, an active customer defined three different ways — the same mistakes, session after session, because nothing remembers the correction you already made.
Reconciled, not asserted
A CLAUDE.md is asserted. A ClariLayer entry is reconciled.
Hand-typing your definitions into a notes file is a real, useful start — but nothing checked it against your warehouse. A ClariLayer entry is the same definition, reconciled against your real warehouse result: provenance and status are shown, and a declared-vs-actual mismatch surfaces as a caveat instead of a confident wrong answer.
Just text. Nothing reconciled it against your warehouse, so when the definition drifts the agent keeps trusting the stale line — confidently.
- source
- dbt + you → reconciled
- last reconciled
- 2 days ago
- status
- asserted
The declared definition counted logged-in users; reconciling against your warehouse showed the billing rule (mrr > 0) returns a different number. Flagged for you to resolve — not hidden behind a clean-looking total.
Reconciled against the result your agent computed locally. ClariLayer never holds your warehouse credentials and never runs SQL server-side — it checks declared against actual, and shows its work.
How it works
Bootstrap. Recall. Remember. Reconcile.
One MCP server, four verbs your agent can call in-flow. No destination app to visit — it rides along inside the agent you already use.
Bootstrap
Point ClariLayer at the work you already have — your SQL files, your dbt models, an existing CLAUDE.md. Your SQL is validated and structured; the rest is imported as notes. Day-1 context, not a cold empty store.
Recall
Mid-task, your agent can pull the right context in-flow — the definition you actually use, the join path, the gotcha — without you leaving Claude Code, Cursor, or Codex.
Remember
Every correction, definition, and schema note you make persists. Your agent retains it across sessions, so you stop re-explaining the same thing every chat.
Reconcile
Ground a saved definition against your real warehouse result. A declared-vs-actual mismatch surfaces as a caveat — checked against your source, not blindly asserted.
Same agent. Same prompt. The difference is your context.
Without your saved context, the agent guesses from raw table names. With it, the agent recalls the definition you reconciled against your warehouse — and knows what to treat with care.
SELECT count(*) FROM raw_users
WHERE last_login > now() - interval '90 days';
// Wrong table (raw_users, not fct_customers).
// "Active" = logged-in, not your billing rule.
// The same mistake you corrected last week.
// Agent recalls your saved context:
"Active customer" → fct_customers,
status = 'active' AND mrr > 0
source: you → reconciled · status: asserted
SELECT count(*) FROM fct_customers
WHERE status = 'active' AND mrr > 0;
// Grounded in your definition, checked against
// your warehouse. Caveats flagged, not hidden.
The first reconcile
“Why don’t these two numbers match?”
The acute analyst moment: two sources disagree and the QBR is in an hour. ClariLayer reconciles a saved definition against your real warehouse result and flags the drift as a caveat — checked against source, never blindly asserted.
Your dashboard says
$1.42M
Net revenue for the quarter — the number on the board.
Your agent’s query returns
$1.51M
The ad-hoc query your agent just wrote, against the same warehouse.
A $90K gap, and no way to tell which one is right.
reconcile
Your agent runs the stored net_revenue SQL with its own access and reports the result shape back. ClariLayer compares the saved definition’s declared signals — its columns, grouping, and aggregates — against what came back.
They don’t line up: the live result is missing a column the saved definition expects, so reconcile records a caveat. That’s the signal to look closer — not a ruling on which dollar figure is right.
The caveat sends your agent digging
With its own warehouse access it traces the $90K to the cause: the ad-hoc query never joined the refunds table, so it reported gross, not net. You ship the refund-adjusted $1.42M.
remember
You correct it once so next quarter the agent starts from it instead of rediscovering it:
“net revenue must net refunds”
source: you · status: asserted
The caveat caught the $90K discrepancy an hour before the QBR. Your agent traced it to the missing refunds join, you shipped the right number, and the correction is remembered for good. Your agent runs the query with its own access; ClariLayer never holds your warehouse credentials and never runs SQL server-side.
Your context, working for you.
One analyst, your own data, your own agent. No data team, no platform account, no procurement — just your context, bootstrapped, reconciled, and remembered.
Day-1, not blank-slate
Bootstrap
Your agent doesn't start from zero — and it doesn't start from a hand-typed CLAUDE.md. Point ClariLayer at the work you already have.
What gets ingested
- SQL
- Validated SELECTs, deterministically structured
- dbt
- Model files imported as schema notes
- CLAUDE.md
- Your existing notes, brought along
“Bootstrap my context from ./analytics/sql + my dbt models.” Real working context on the first session.
Checked, not just claimed
Reconcile
A saved definition is reconciled against your real warehouse result — your agent runs the SQL with its own access and reports back the shape.
What reconcile returns
- Match
- Stays asserted — taken at your word, nothing flagged
- Mismatch
- Flagged as a caveat so you know what to trust
- Measured
- Internal paired eval: 36/38 data questions right with the layer vs 26/38 without
ClariLayer never holds your warehouse credentials and never runs SQL server-side. Evidence-backed, caveat-aware context.
It compounds
Remember
Every correction, every reconcile, every new note persists. Your agent grounds on more of your context over time.
The retention loop
- Correct once
- The fix is remembered, not re-typed next session
- Recall in-flow
- The right context, pulled mid-task
- Over weeks
- Progressively more right about your data
“Claude Code finally understands my project.” The context you build is the moat.
For teams · the Governed Context Edge
Yours today. Your team's — in pilot now.
ClariLayer starts as your personal context layer. The Governed Context Edge — your reconciled definitions promoted into a governed team canon, with ownership, approval, and one right metric — is built and in private pilot. A few design-partner slots are open.
Personal context merges into shared
The definitions and corrections you build solo are exactly what later merges into shared, owned team context — the same engine, one level up.
Ownership, approval, one right metric
When a team adopts it, governance arrives: who owns a definition, what's approved, and the one right answer everyone's agents use.
Land solo, expand to the team
Start as your personal context layer with no procurement. When the team is ready, the Edge is already built — private pilots are onboarding now.
Connect your AI
One command, and your agent knows your data.
Add the MCP to Claude Code, Cursor, or Codex, then mint a context key. Your agent starts recalling and reconciling your saved context in-flow — no extra app to switch to.
Run in your terminal
claude mcp add --transport http clarilayer https://clarilayer.com/api/mcp/mcp --header "Authorization: Bearer cl_YOUR_CONTEXT_KEY"Replace cl_YOUR_CONTEXT_KEY with the context key you mint in ClariLayer. The key is shown once at creation, so paste it straight into the command.
Built to be trusted with your data
Grounded against your warehouse — and it shows its work.
The whole point is that your AI's context is grounded against reality, not just asserted. We measured what that is worth — and we label every claim with exactly how far it goes.
Measured, not manufactured
36 of 38 with the layer. 26 of 38 without.
In our internal paired eval, the same agent answered 36 of 38 data questions correctly with ClariLayer connected — 26 of 38 without. The cheaper the model, the bigger the lift: the control went confidently wrong under session load.
Shipped, not slideware
Four MCP verbs, live in your agent today.
Bootstrap, recall, remember, and reconcile are live in production — one MCP server your Claude Code, Cursor, or Codex agent connects to and calls in-flow. No destination app to visit.
A standard, not a shortcut
Every mark you see is one we can back.
A saved definition is checked against your real warehouse result: a mismatch is flagged as a caveat, otherwise it stays asserted. A “verified” stamp only ships when it can never be wrong — ours arrives with the SQL parser.
Your data, your access
ClariLayer never holds your warehouse credentials.
It never runs SQL server-side. Your agent runs the query with its own access and sends back the result shape plus any preview rows it chooses to include — ClariLayer reconciles on that, then flags what to trust.
FAQ
Straight answers to the real objections.
What ClariLayer can see, what it doesn't touch, what's free, and what “reconciled” actually means.
Stop re-explaining your data.
Connect ClariLayer to Claude Code, Cursor, or Codex in one command. Free to start — no team, no procurement, just your context.
Connect your AIFor teams
The Governed Context Edge is in private pilot — a shared, governed canon for your whole team's agents. We onboard design partners personally.