CustomLabs
Governance

The AI Governance Layer: prove how the system behaves, and who's accountable.

Six surfaces, 24 named controls, five ways a governance program lies, and the scoreboard that keeps them honest. A shipped AI system must hold up under this standing regime a year later. This page is no checklist for getting one feature past review.

Updated First published

29 min read

Markdown

A security review is questionnaire prep. It gets one feature past InfoSec, Privacy, Risk, and Procurement once, before it ships. Governance must keep holding a year later. The register still lists what is running. A reviewer can still disagree at the checkpoint. The logs can still reconstruct a specific decision. See the security review for the one-time gate. This page describes the regime underneath it.

All six surfaces below apply to a system that is not classified as high-risk. A register, a named owner, and a system cardA system card is a short document stating an AI system's purpose, limits, and owner. cost little. They answer a question that someone will eventually ask, whatever the classification. Scale the rest to what the classification calls for.

As of 12 August 2026. Regulation (EU) 2026/1744 (the "Digital Omnibus on AI") deferred the EU AI Act's high-risk obligations. Stand-alone systems now have until 2 December 2027. Systems embedded in other products have until 2 August 2028. The Article 5 prohibited-practices regime, the transparency duties, and the general-purpose-AI obligations were not part of that deferral. None of the six surfaces below depends on a compliance deadline. Build a register and a system card on the schedule your own risk sets. Add a checkpoint that a reviewer can contest. Do not wait for a regulator to start checking. Regulation (EU) 2026/1744, EUR-Lex →

The six surfaces

What a governance program has to cover.#

Each surface fails a different way. No surface can stand in for another.

Diagram in six lanes, one per governance surface: inventory and classification; human oversight; and records and traceability. The other three are documentation and disclosure; third-party assurance; and monitoring and incidents. Each lane holds one node that shows the metric that surface watches. No edges connect the surfaces; each one covers separate ground. INVENTORY HUMAN OVERSIGHT RECORDS AND TRACEABILITY DISCLOSURE THIRD-PARTY ASSURANCE MONITORING & INCIDENTS Register coverage Override rate Retrievable trace Current system card Attestation age Report latency
Six governance surfaces cover a system from its first registration to its last incident report.
01

Inventory and classification

Covers: Every system that touches a model, who is accountable for it, and how much decision weight it carries.

Breaks when: A team ships a new integration through an approved platform. The register keeper never learns that the integration now calls a model.

Watch: Register coverage

02

Human oversight

Covers: Which actions a system may take unattended, and whether the person at the checkpoint can disagree with it.

Breaks when: The checkpoint exists on a diagram. The reviewer sees the proposed action but not the evidence behind it. The interface only supports a yes.

Watch: Oversight override rate

03

Records and traceability

Covers: What was running, what it saw, and what it did. The record must be complete enough to answer for one past decision.

Breaks when: A log captures the prompt and the output. It does not capture the model, index, or tool version that produced them. Nobody can run the decision again.

Watch: Share of decisions with a retrievable trace

04

Documentation and disclosure

Covers: What a system is for, what it must not be used for, and whether the people it affects know that AI is involved.

Breaks when: A system card sits in a wiki that nobody outside engineering has read. Procurement improvises an answer to a question the card already settled.

Watch: Share of live systems with a current system card

05

Third-party and data assurance

Covers: What a model or library provider commits to on training use, retention, and sub-processors, and whether that commitment still holds.

Breaks when: A team reads a vendor's terms once, at procurement. Nobody checks them again, even after the vendor adds a sub-processor without notice.

Watch: p95 vendor attestation age

06

Monitoring, incidents and change control

Covers: What happens after launch: who watches the system, what counts as an incident, and what triggers a new review.

Breaks when: A dashboard tracks the right numbers. The last person who looked at it left the company two quarters ago.

Watch: Declaration-to-report latency

The control bank

24 controls, six surfaces.#

Filter by how often a control runs. Then copy the visible list as a Markdown checklist.

01 Inventory and classification

Every governance question starts with two answers: what AI is running, and who is accountable for it. This sounds easy until a team ships a model call in an unflagged feature. The platform already had approval for something else. This surface is the register that must catch that case. It classifies each system by the cost of a wrong decision. Model brand and model size do not matter here.

What it covers
A single, current list of every system in the organization that calls a model, however small the feature.
How to build it
One register and one owner. A build or procurement gate requires an entry before a model-touching feature ships.
Produces
A register that answers "what AI do we run" in one lookup. No round of Slack messages.
Tradeoff
A register that nobody must update decays within a quarter (see the trap below). It needs a gate. A request is too weak.
Prove it
Register coverage: the share of running systems that have a current entry.
What it covers
One named person is accountable for each system in the register. This person is separate from the team that maintains the code.
How to build it
Add a required "owner" field to the register entry. A named individual holds it. That person has the authority to pause the system. A distribution list does not qualify.
Produces
One name to call when a system does something unexpected. Without it, a team passes the question around internally.
Tradeoff
Ownership must survive reorgs and departures. An owner field that points at someone who left is worse than an honest blank.
Prove it
Share of register entries with a current, reachable owner.
What it covers
A tier per system based on what a wrong decision costs. The model and its size do not matter.
How to build it
A short rubric, scored at registration. Do not infer the tier from the tech stack. Ask three questions. Does the system decide something about a person? Can it act without review? Is the domain regulated?
Produces
A tier that shows which of the other five surfaces needs the most effort for this system.
Tradeoff
A coarse rubric puts everything in one tier. That is the same as no classification.
Prove it
Every register entry carries a tier. The team assigns it before launch and does not backfill it after a question.
What it covers
A written, specific definition of the change that sends a system back through classification and review.
How to build it
Name the triggers: a new data source, a materially different model, or a new class of action. Review the list on a schedule so it does not go stale.
Produces
A re-review that happens because a rule fired. Nobody has to remember.
Tradeoff
A broad definition re-triggers review on routine changes, and the team starts to work around it. A narrow definition lets real changes slip through.
Prove it
Every re-review in the last period traces to a named trigger. None came from an ad hoc decision to check.

02 Human oversight

A human checkpoint that always approves is a delay with a signature on it. It is not oversight. This surface designs the checkpoint so that disagreement is a real, informed option. It sets which actions never run unattended. It sets what the reviewer sees before they decide. It also sets what happens when someone contests an outcome later.

What it covers
A written list of the actions that a system may never take until a human confirms.
How to build it
At design time, name the irreversible or high-stakes actions, such as a refund, a termination, or a diagnosis. Route each one through a checkpoint before it runs.
Produces
A hard boundary that the system cannot reason its way around. A guideline can be argued past. A boundary cannot.
Tradeoff
Each action on this list adds latency and takes a person's attention. If the list is too long, everyone routes around the checkpoint.
Prove it
Zero unattended runs of a listed action. Check the call logs. The design doc is not evidence.
What it covers
What the person at the checkpoint sees before they approve or reject. They need the inputs and retrieved evidence behind a proposal. The proposal alone is not enough.
How to build it
Show the evidence that the system used next to the proposal. In the interface, make rejection at least as easy as approval.
Produces
A checkpoint with a real reject rate. The reviewer is informed, and rejecting is easy.
Tradeoff
Full evidence takes more of the reviewer's time per decision. If reviewers cannot finish in the time they have, they rubber-stamp anyway.
Prove it
A reject rate above zero. A reviewer can explain a specific rejection from the evidence shown, without outside knowledge.
What it covers
A real path for an affected person to challenge a decision and reach a human. The path runs outside the system itself.
How to build it
A named contact or process, separate from the system, with a committed response time.
Produces
A dispute path that exists before the first complaint. Nobody improvises it afterward.
Tradeoff
A contest route that leads back into the same automated system is not a route.
Prove it
Median time from a raised contest to a human response. Track it. Do not assume it.
What it covers
Whether the reviewer at a checkpoint understands the system well enough to catch a bad proposal. They must know what it does well and what it does badly.
How to build it
Onboard every checkpoint reviewer. Give them a refresher on the known failure modes of the system. Repeat it as the system changes.
Produces
A reviewer who can name the specific way this system tends to be wrong. A job title with checkpoint access does not give you that.
Tradeoff
Training takes time from the review queue. It also goes stale as the system changes under the reviewer.
Prove it
Every checkpoint reviewer has completed training that is current to the last substantial change.

03 Records and traceability

A log that nobody can reconstruct fails when someone disputes a decision months later. This surface turns "we log things" into "we can answer for this decision." Version the prompt, model, index, and tools as one release. Log every decision's inputs and outputs against that version. Keep the logs past the dispute window. Prove on demand that you can reproduce a decision.

What it covers
One version identifier that pins the exact prompt, model, index snapshot, and tool set that were live at a given time.
How to build it
Bundle the four into one release artifact with one version tag. A normal software release already does this for code.
Produces
A version number that a log entry can point to. "What was running" becomes a lookup, not a guess.
Tradeoff
Versioning all four together adds release overhead compared with a lone prompt tweak. The alternative is a log that nobody can resolve.
Prove it
Every logged decision resolves to one version identifier. Test this by resolving one at random.
What it covers
A single, complete log entry per decision: what went in, what the system retrieved, which tools ran, and what came out.
How to build it
One structured log record per decision, keyed to the release version above. Capture all four elements. Do not log only the final output.
Produces
A decision that you can read back in full. You do not rebuild it from whichever pieces happened to be logged.
Tradeoff
Logging full inputs and retrieved context at this detail costs storage. For personal data, it also forces a privacy-scoping decision. It is not free.
Prove it
A decision picked at random resolves to a complete log entry. Someone checks this. A written policy does not count.
What it covers
A retention period for decision records that covers the full time someone has to dispute a decision.
How to build it
Set retention against the real dispute or audit window for the system's domain. Do not carry over a generic default from an unrelated policy.
Produces
A record that still exists when the dispute arrives. Without it, the schedule deletes the record a month early.
Tradeoff
Longer retention costs more storage. It also raises the exposure if that storage is breached. Match retention to the real window. Do not default to "forever."
Prove it
The team documents the retention period and checks it against the system's real dispute or audit window. A database default does not count.
What it covers
Whether the team can rebuild and re-run the exact system that produced a past answer. A description of the system is not enough.
How to build it
Pick a real past decision. Pull its version and log entry. Re-run it end to end against the same inputs. Run this as a recurring drill. One proof is not enough.
Produces
A demonstrated answer to "can you show me how this decision was made." You are not just asserting that you could.
Tradeoff
The drill takes time from the system owner. It proves only what it tested.
Prove it
Time to reconstruct a named past answer. Measure it in a real drill. Do not estimate it.

04 Documentation and disclosure

A system card that only engineering can find discloses nothing to procurement or a new hire. This surface is the system card that every model-touching system needs. It states purpose, limits, data, evals, and owner. Procurement can hand it to a counterparty without you in the room. This surface also covers a harder task: telling users when they talk to AI and would otherwise assume a person.

What it covers
One document per system. It states the purpose, limits, data sources, eval results, and owner.
How to build it
A short, structured template. Fill it in at launch and update it at every substantial change. Store it outside the codebase.
Produces
One document that answers most of what procurement or a new team member will ask. They get the answer before they ask.
Tradeoff
A system card that does not update at the same trigger as the re-review above becomes another stale document.
Prove it
Every register entry links to a system card dated at or after the system's last substantial change.
What it covers
A written boundary on what the system must not be used for. This is separate from a description of what it does.
How to build it
An out-of-scope list on the system card itself. Use the classification tier above to inform it.
Produces
A written answer to "can we use this for X" that exists before someone asks in production.
Tradeoff
A boundary that nobody revisits drifts out of date. The system changes, and so does what people try to use it for.
Prove it
The out-of-scope statement is current as of the last substantial-change review. The original launch date does not count.
What it covers
Whether a user knows that AI is talking to them or evaluating them. This applies wherever they would otherwise assume a person.
How to build it
A visible disclosure at the point of interaction. Do not bury it in a terms-of-service page that nobody reads.
Produces
A user who does not find out later that a decision or a conversation did not involve a person.
Tradeoff
If you disclose every trivial automation, users learn to ignore the notice by the time it matters. Reserve it for cases where the assumption would be wrong.
Prove it
A fresh user sees the interaction cold and correctly says whether AI was involved.
What it covers
A standing package of system card, eval results, and data-flow summary. It answers a procurement or diligence question without a live meeting.
How to build it
Assemble the pack from documents that already exist elsewhere on this list. Keep it current. Do not write it fresh under deadline for each request.
Produces
A same-day answer to a procurement questionnaire. No scramble that stalls the deal.
Tradeoff
An evidence pack that you assemble only on request is the trap below under a different name. Maintain it. Do not produce it on demand.
Prove it
The team can hand over the pack for a given system within one business day of the request. Check this as a drill.

05 Third-party and data assurance

A vendor commitment that you read once at signing is worth only what you remember of it. This surface covers every provider that a system depends on. That includes the open-weight models and libraries that most inventories leave out. It names the terms that matter: training use, retention, sub-processors, and residency. It replaces the one-time procurement check with a re-attestation clock. It also answers, per system, which data may cross which boundary.

What it covers
The contract terms that govern risk: training-data use, retention, sub-processors, and data residency.
How to build it
Extract those four terms from every provider's agreement into the register entry. Do not leave them in a contract that nobody re-opens.
Produces
A one-line answer to "does this vendor train on our data." No search through a PDF.
Tradeoff
Contracts change. A pinned term is stale the moment the vendor updates its terms, unless someone re-checks it against the current agreement.
Prove it
Every third-party dependency has its four key terms recorded and dated.
What it covers
A recurring check that a vendor's terms and posture still match what was true when you signed.
How to build it
A fixed re-attestation interval per vendor, tied to the system's classification tier. A one-time procurement checkbox does not do this.
Produces
A change in vendor terms or sub-processors that you catch within the re-attestation window. You do not wait for someone to reread the contract.
Tradeoff
The same schedule for every vendor wastes effort on low-tier dependencies. Tie the interval to the tier that the vendor supports.
Prove it
p95 vendor attestation age, tracked against the interval that each vendor should sit on.
What it covers
A live answer to which categories of data a system may send to which provider or region.
How to build it
A data-flow map per system. Record it on the register entry. Check it against the provider terms pinned above.
Produces
A direct answer to a residency or data-transfer question. Nobody traces the call path by hand.
Tradeoff
The map is only as good as its last update. A new data source that is not added to the map reopens the question the map was built to answer.
Prove it
The data-flow map for a system matches its current inputs. Check it. Do not assume it from the original design.
What it covers
Whether a self-hosted open-weight model or a third-party library counts as a governed dependency, like a hosted API.
How to build it
Put self-hosted models, and any library that shapes model behavior, in the same register and re-attestation process as an API vendor.
Produces
One consistent boundary. Without it, the governance program sees only the dependencies that send an invoice.
Tradeoff
No procurement contract triggers the review. The team must pull these dependencies in at registration.
Prove it
Self-hosted models and behavior-shaping libraries appear in the register with the same fields as an API vendor.

06 Monitoring, incidents and change control

The first five surfaces lose their value after launch if nobody watches the system. A dashboard that nobody opens does not count. This surface sets post-deployment monitoring with a named owner. It defines what an AI incident is and who may declare one. It requires a rollback path that the team rehearses across model, prompt, index, and tool config. It also sets a rule for when the system, its data, or its rules change enough to re-run the whole review.

What it covers
Whether a named person watches the live behavior of the system. A dashboard that exists is not enough.
How to build it
The owner named in the register checks specific, named metrics on a defined cadence. An alert path fires when a metric crosses a threshold.
Produces
A regression that you catch the week it starts. You do not find it in the quarter when someone opens the dashboard.
Tradeoff
Monitoring that alerts on too much gets tuned out. Alert on the metrics that predict a governance failure. Do not alert on everything you can measure.
Prove it
The named owner can show the last time they acted on an alert from this system. Confirming that the dashboard exists does not count.
What it covers
A written definition that is specific enough for two people to look at the same event and agree on whether it is an incident.
How to build it
Name the categories that qualify: a harmful output that reached a user, an unattended action outside its allowed list, or a confirmed injection. Also name who has the authority to declare one.
Produces
An incident that you declare on the day it happens. Nobody debates whether it counts.
Tradeoff
A broad definition turns routine bugs into incident-response events. A narrow definition lets a real incident pass as ordinary.
Prove it
Declaration-to-report latency, measured from a real incident. A tabletop exercise alone does not count.
What it covers
Whether reverting a system to its last known-good version works when you try it. The version is the one release defined above.
How to build it
Run a real rollback drill on a schedule. Do not rely on a documented procedure that nobody has executed.
Produces
A rollback that takes minutes because the team has done it before. Nobody improvises it for the first time during an incident.
Tradeoff
Rollback drills take engineering time on a schedule, even when nothing is wrong.
Prove it
Time to complete a rollback drill, tracked per drill. Do not assume it from the runbook.
What it covers
Whether a substantial change, as defined in the inventory surface above, triggers a fresh pass through classification, oversight design, and disclosure.
How to build it
Wire the substantial-change trigger directly to a required re-review step. A note to revisit it eventually is too weak.
Produces
A governance program that tracks what the system has become. It does not describe the system at launch.
Tradeoff
Every re-review costs review time again. This holds together only if the substantial-change definition is neither too broad nor too narrow.
Prove it
Every substantial change in the last period has a matching, completed re-review on record.
Five ways a governance program lies

A policy is a claim, not an artifact.#

Each of these looks like a passing program until someone asks to see the evidence.

A policy with no producible artifact

Looks like: A written governance policy exists, and everyone can describe it accurately. Nobody can hand over the evidence pack that it requires.

Costs you: An auditor or a diligence team asks to see the artifact and does not accept a description of the policy. The gap between the two becomes the finding.

Fix: Treat the artifact as the deliverable. If you cannot produce the evidence pack within a business day, the policy is not implemented yet.

See the control: Keep an evidence pack procurement can read without you in the room →

Rubber-stamp oversight

Looks like: A human checkpoint is in place. The approval rate sits near 100% month after month.

Costs you: A near-universal approval rate is a finding about the checkpoint. It does not show that the system is right. It usually means the reviewer cannot see enough to disagree, or has no time to.

Fix: Redesign the checkpoint to show the evidence behind a proposal. Track the reject rate as a health metric. Do not treat it as a nuisance number.

See the control: Design the checkpoint so the reviewer can disagree →

Logs without versions

Looks like: Every decision is logged in detail, with a prompt and an output. The log does not say which model, index, or tool configuration produced it.

Costs you: A log that cannot be tied to a release cannot be reconstructed. When someone disputes a decision, the answer is "probably" instead of a demonstration.

Fix: Version prompt, model, index, and tools as one release. Key every log entry to that version. A timestamp alone is not enough.

See the control: Version prompt, model, index and tools as one release →

A hand-maintained register, stale within a quarter

Looks like: A spreadsheet lists every AI system. Whoever remembers updates it. No gate is tied to it.

Costs you: New systems ship without an entry. Decommissioned systems stay listed as live. The register becomes a historical document, usually within one quarter.

Fix: Tie registration to a real gate: a build or procurement step that cannot complete without an entry. Do not rely on someone remembering.

See the control: Keep one register of every system that touches a model →

Vendor assurance frozen at the procurement date

Looks like: A team reviews a vendor's terms carefully once, at signing. The sign-off is then treated as permanent.

Costs you: A vendor can add sub-processors or change retention terms long after signing. Nothing in the process notices.

Fix: Put every vendor on a re-attestation clock sized to the systems it supports. A one-time procurement checkbox is not enough.

See the control: Re-attest vendors on a clock, not once at procurement →
The scoreboard

Six numbers, and how each one lies.#

You can measure each of these today. No number is trustworthy alone. Pair each one with the number next to it.

Register coverage

Why it matters
Whether "what AI do we run" has a one-lookup answer or a round of Slack messages.
How it misleads
A high coverage number can describe a register that nobody has reconciled against production for months.
Pair with
Days since the register was last verified against production

Share of decisions with a retrievable trace

Why it matters
The direct measure of whether the records surface is a capability or a policy document.
How it misleads
A high share can hide a slow retrieval. The trace exists, but nobody has timed how long it takes to pull one.
Pair with
Median time to retrieve a named trace

Oversight override rate

Why it matters
The number that separates a checkpoint that catches real problems from one that always agrees.
How it misleads
A healthy-looking override rate can come from one overworked reviewer who overrides everything near a deadline. The checkpoint design is not the cause.
Pair with
Reviewer time spent per checkpoint decision

Time to reconstruct a named past answer

Why it matters
The most concrete test of whether the records surface works. Run it against one real decision. A policy claim proves nothing.
How it misleads
A fast reconstruction of one convenient, recent decision says nothing about an older decision. That decision may sit near the edge of the retention window and may not resolve at all.
Pair with
Retention window remaining for the decision reconstructed

p95 vendor attestation age

Why it matters
How stale the oldest-checked fifth of your vendor commitments is. The median alone will not show this.
How it misleads
A young median age can hide a handful of long-forgotten, high-tier vendor dependencies. They sit well past their re-attestation window.
Pair with
Number of sub-processors added by a vendor since its last attestation

Declaration-to-report latency for an AI incident

Why it matters
How long a declared incident takes to reach whoever must act on it or disclose it.
How it misleads
A fast latency with zero declared incidents over a long period often means the definition is too narrow. It can also mean nothing went wrong.
Pair with
Number of incidents declared in the same period
What this is built from

Verifiable, not claimed.#

We invented no compliance stats. This section lists what this site already documents and what a real diligence pass found.

Sources

  1. EUR-Lex - Regulation (EU) 2026/1744

    The regulation text our governance page's compliance claims are checked against. Retrieved 2026-08-24.

  2. European Commission - AI Act Service Desk: Article 113

    The official guidance on the entry-into-force article our governance page cites. Retrieved 2026-08-24.

  3. NIST - AI Risk Management Framework (AI RMF 1.0)

    The risk-management functions our governance and adoption controls map onto. Retrieved 2026-08-24.

This page describes what a governance program must produce to survive an audit or a regulator's question. These are the controls we build for clients so the answer exists before someone asks. This page is not a legal opinion on what applies to your organization. It is not legal advice. Your counsel makes the compliance call for your situation.

Not sure what you could produce today

A Ship Audit checks this program against your specific systems. It tells you which surface is covered and which surface only looks covered on paper.

Questions

Before you tell a regulator or a buyer 'we have this.'#

What teams ask us before they stand up an AI governance program.

01 We're not building a high-risk system. Do we need any of this?

The register, an accountable owner, and a system card cost little. They answer a question that someone will eventually ask, whatever the classification. Scale the rest to what the classification tier calls for. This includes the oversight checkpoint and the re-attestation clock. Do not skip the whole page because one label does not apply.

Link to this answer: We're not building a high-risk system. Do we need any of this?
02 Isn't this the same thing as the security review?

No. The security review is questionnaire prep. It gets one feature past InfoSec, Privacy, Risk, and Procurement once, before it ships. Governance is the standing regime that must still hold a year later. It covers the register, oversight, records, disclosure, vendor re-attestation, and incident reporting.

Link to this answer: Isn't this the same thing as the security review?
03 Who owns AI governance in a 200-person company?

Nobody, by default. That is the first problem the inventory surface fixes. In practice, one named individual owns it. This person often sits in engineering leadership or risk. A dedicated AI ethics hire is rare at this size. The owner is accountable for the register and the re-review trigger. Whoever owns each system does the checkpoint and disclosure work for it.

Link to this answer: Who owns AI governance in a 200-person company?
04 What changed with the EU AI Act in 2026?

The high-risk compliance deadlines moved later. The prohibited-practices rules, the transparency duties, and the general-purpose-AI obligations did not move. See the linked insight for the dates and what stayed in place.

Link to this answer: What changed with the EU AI Act in 2026?
05 Do we need ISO 42001 certification?

Certification is a business decision. It depends on what a specific customer or deal requires. It is not a universal requirement. ISO/IEC 42001 asks for a system inventory, a defined oversight process, and documented risk treatment. These controls largely overlap the six surfaces on this page. If you build to this page, you get most of the way there. That holds whether or not you pursue the certificate.

Link to this answer: Do we need ISO 42001 certification?
06 What do we hand an auditor on day one?

Hand over four items. The register entry for the system in question. Its current system card. The last completed re-review. A sample decision log with its version resolved end to end. If any one of the four takes more than a day to produce, close that gap first.

Link to this answer: What do we hand an auditor on day one?
Check the register, not the memory

A hand-maintained register usually goes stale within a quarter, and rubber-stamp oversight rarely gets caught until it matters. AI Readiness scores your own program against the same six surfaces this page maps.

Source: https://customlabs.io/governance/

↑↓ navigate ↵ select esc close