Quickstart

remember

Save a definition, schema note, join path, or gotcha so your agent retains it across sessions and you stop re-explaining the same context.

remember is the retention mechanic. It saves a single new piece of context — a metric definition, a schema note, a join path, a gotcha — so your agent keeps it across sessions. This is what makes ClariLayer feel like "Claude Code finally understands my project": the corrections you make stick, instead of evaporating when the conversation ends.

Every time you correct your agent, or it discovers how a metric is actually computed, that knowledge can be remembered once and recalled forever after. The longer you use it, the more grounded your agent gets on your data — and the more annoying it would be to lose.

What it saves

remember saves (or updates) one context entry. You give it a type and a name, the content to store, and optionally a SELECT query that captures how a metric is computed. Remembering the same (type, name) again updates that entry rather than creating a duplicate, so refining a definition is just remembering it again with the better wording.

Typical things worth remembering:

a definition — "Active Customer means an account with at least one billable subscription in the trailing 30 days, excluding internal test workspaces";
a schema note — "fct_orders.amount is in cents, not dollars";
a join path — "join users to orgs on users.org_id, never on email";
a gotcha — "refunds live in fct_refunds, so revenue queries must subtract them or they double-count."

How to run it

You rarely call remember directly; you let your agent do it as part of the conversation. A natural prompt:

Remember that our revenue numbers must subtract refunds from fct_refunds, or they double-count.

Your agent calls remember with that content, and it is saved to your store. You can also attach the SQL that backs a definition by including it, which sets up the entry so it can later be reconciled against your real warehouse result.

Status and provenance

A remembered entry is saved with status asserted and provenance you. asserted is the honest baseline: you saved it, ClariLayer is taking your word for it, and nothing has been checked against your data yet. Provenance you records that you are the source, as opposed to something imported by bootstrap.

Remembering is not verifying. A saved definition has the same trust property as the words you typed — it is asserted until something grounds it. That is exactly the gap reconcile closes: it checks a saved definition against a real warehouse result and flags a mismatch as a caveat.

remember vs reconcile

remember captures a claim. It is fast and always available, and it is the right tool for institutional memory and corrections.
reconcile checks a captured claim against reality. It is how an asserted definition earns a caveat when its declared shape and the actual result disagree.

Use remember constantly; use reconcile when you want to know whether a definition still holds against the warehouse.

It compounds

Because remembered entries persist and are surfaced by recall, each one makes the next session a little better. The context you build is the moat: it is yours, it travels across Claude Code, Cursor, and Codex, and it is the bridge to shared team context as your team adopts ClariLayer.