Governance model

Metatate is an advisory decision layer for governed data. It does not enforce rules inside your data platforms; it compiles your governance intent into published, citable decisions that humans and AI agents can ask about before they touch data. Everything flows through one pipeline:

One invariant holds the whole model together: only the current deployment publication's deployed instruction decisions are decision authority. Drafts, approved-but-unpublished versions, generated reviews, and pending jobs never influence a live answer.

Catalog vocabulary

Connectors discover the structure of your estate — databases, schemas, tables, and columns — and your team layers meaning on top: column classifications against the taxonomy, descriptions and tags, named collections of tables, and the platform roles policies can reference. The catalog stores structural metadata only, never your data rows. It is the vocabulary every policy targets; see Catalog.

Canonical policies

You author policies as YAML (or JSON) documents, and Metatate validates each one into a canonical policy. Policies are versioned, and each version moves through a review lifecycle: draft, review requested, approved. Approval makes a version eligible for publication — it does not make it live. See the Policy YAML reference and Policies in the app.

Deployable instructions

A policy expresses intent; an instruction is the operational unit derived from it. Metatate deterministically extracts each policy version into deployable instructions — masking rules, role grants, row filters, usage guidance, AI governance, retention, compliance context, and more. Each instruction carries:

• Scenario — the canonical runtime question it answers (a key such as masking.display or ai.training) and its delivery lane. See Scenarios.
• Decision — one of allow, deny, mask_full, mask_partial, require_review, log_only, retain, or conditional (allowed once a specific obligation — approval, anonymization, a role — is met).
• Priority — the policy's priority (0–999), projected to a rank of critical, high, medium, or low.
• Enforcement mode — enforce, monitor, or advisory. In monitor and advisory modes, enforceable rules are served as require_review instead of their active decision, while advisory guidance keeps its honest verdict.
• Reason — a bounded decision reason explaining the verdict.
• Provenance — the source policy and version, a stable instruction key, the resolved asset scope, and the resolution path (selector, collection, or taxonomy) that put the asset in scope.

Deployment review

Approved policy and catalog state form a ready-to-publish set. From it, Metatate generates a deployment review: a human-readable bundle of exactly what would change if you publish. The review is derived state — you can leave it without losing approved changes, and if the ready set changes underneath it, the review goes stale and is regenerated rather than trusted. See Deployments.

Current deployment publication

Publishing applies the reviewed bundle and advances your workspace's current deployment publication. The publication pins everything an answer needs: the included policy versions, the catalog state they resolved against, and the full set of deployed instruction decisions. Exactly one publication is current at a time; publishing a new one supersedes the old, and prior publications remain queryable for explanation.

This is the boundary the product is built around: ready is not live. Nothing you author, approve, or review changes a live answer until a publication makes it current.

Typed answers

Seven read-only MCP tools (and the matching in-app preview) answer from the current publication's deployed instruction decisions. Every decision-bearing answer is one of three typed states: answered, review_required, or not_enough_published_state, each with stable reason codes. Missing coverage is reported as a fact about your workspace — never dressed up as a fabricated decision. See Typed answer states and the MCP overview.

Design properties

Deterministic

Same published rows in, same answer out. When multiple rows apply, the effective decision follows a fixed ranking where the first difference wins: specificity (column-level beats table-level; within a level, selector beats collection beats taxonomy resolution), then priority (higher first), then restrictiveness (deny > mask_full > mask_partial > require_review > conditional > retain > log_only > allow), then a stable instruction key tiebreak so ordering never depends on read order.

Auditable

Every answer cites the instruction rows that produced it — instruction key, policy version, scenario, asset, and publication. Each cited row carries a decision_id you can pass to explain_why to retrieve that exact record's evidence, so any decision can be traced back to the policy version that authored it.

Honest

Typed states replace guesswork. Zero applicable rows is not_enough_published_state, not an implicit pass and not an invented review. Conflicts are never ranked away: if opposing rows tie at the winning tier, the answer is review_required carrying every source.

Ready is not live

Authoring is intent. Approval is readiness. Publication is what makes governance live. Deployed instruction decisions are runtime truth, and answers are advisory explanations over that truth.