The knowledge that runs your data shouldn't live in people's heads.

Most teams carry critical knowledge informally. That includes what a column means, why a pipeline exists, and which value is safe to trust. We make that knowledge explicit, executable, and versioned, so it can be reviewed like code and survives long after the people who wrote it.

# before - knowledge lives in heads

"Ask Marie, she knows that table."

"I think that field is in cents?"

"We do not touch that pipeline."

"It worked before the refactor."

# after - knowledge lives in the repo

Encode it once. Reviewed, tested, trusted.

Undocumented systems are expensive in slow, invisible ways.

Onboarding takes months. Every change is risky because no one is sure what depends on what. The same questions get answered again in chat. And when a key person leaves, a piece of the system goes dark.

An AI agent is only as reliable as the knowledge you give it.

Point an LLM at your warehouse and it will guess what a column means, what unit it is in, and which rows count. Those guesses ship as confident, wrong answers.

Encoded contracts remove the guessing. The same definition that validates your data also grounds the agent and gates what it is allowed to run.

# orders.contract.yaml - read by humans, CI, and agents

model: orders

columns:

- name: amount_cents

unit: minor_units # cents, not euros

constraints: [not_null, ">= 0"]

- name: status

enum: [pending, completed, refunded]

- name: customer_email

pii: true# never expose to an agent

invariants:

- revenue = sum(amount_cents) where status = 'completed'

It grounds the agent, then guards what it runs.

agent> "What was revenue last month?"

# grounded: cents, completed only, no pii

SELECT SUM(amount_cents) / 100.0 AS revenue_eur

FROM orders

WHERE status = 'completed'

AND placed_at >= date_trunc('month', now())

contract check: PASS

# without the contract, the agent guesses

x SUM(amount) # no such column

x SUM(amount_cents) # refunds counted

x SELECT customer_email # pii leak

contract check: BLOCKED before execution

How we help you get there.

A short, bounded engagement. You finish with contracts running in your CI, wired into your agents and tools, and owned by your team.

Audit

$ audit ./warehouse

scanning datasets...

47 undocumented fields

We map what your data means today and where the missing knowledge costs you most.

Encode

+ orders.contract.yaml

unit: minor_units

pii: true

We turn the highest value definitions into contracts: schemas, units, invariants, and PII flags.

Wire in

# ci pipeline

contract-check PASS

breaking change BLOCKED

Contracts run in your CI to block breaking changes, and feed your agents and tools as grounding.

Hand over

# a normal change

git commit -m

"add refunds rule"

Your team owns it. Adding or changing a definition becomes a normal pull request.

Let's encode the knowledge your data runs on.

A short, bounded engagement. We'll look at how your team captures knowledge today and where contracts would pay off first.

Book a technical review

# the engagement, end to end

audit ./warehouse

encode contracts + ci

handover owned

status: ready