An auditor at the synthetic insurer asks the submissions team a short question about the broker intake service: "Show me that the build running in production was made by your factory, from an approved pattern, and that nobody changed it after your gates passed."
The team is well prepared, or so it thinks. It has the factory manifest of FR-0003, with the pattern PAT-INTAKE-API 2.1.0, the specification hash and a sha256 digest for every generated file. It has the gate report from the previous chapter, with four gates passed. It has the rollout manifest that names a release approver.
The auditor reads them and asks a second question: "Who wrote these files?" The factory did. Every document the team holds is a statement the producer made about its own work. That is the factory's version of the problem this site keeps returning to: a self-report of "done" is not evidence. A manifest the factory wrote is better than nothing, but anyone who could change the build could also change the manifest.
The learner's question: who is allowed to decide what in a governed factory, how are those rules enforced by code instead of by memory, and what can a reviewer check about an artifact without trusting the team that built it?
Who owns which decision#
Plain English. Governance is the set of rules about who may decide what, written down, enforced where possible by machines, and recorded every time it is used. It is not a meeting.
A factory concentrates decisions. One pattern change reaches dozens of products; one station's permissions reach every run. So the first governance question is not a tool but a table: for each kind of decision, which role owns it.
The platform team is the team that builds and runs the shared capabilities other teams use: templates, the registry, the catalog, the factory's runtime and, in this site's insurer, the pattern PAT-INTAKE-API itself. The domain team is the team that owns one business area and its products: the submissions team owns broker-submission-intake, its spec, its business rules and its release. The other three roles are review roles, not builders.
Before AI. Regulated companies had this split long before factories: a central platform or middleware group that owned the shared frameworks, product teams that owned their services, an architecture review for new designs, a security review for anything touching identity, and a change advisory board for production. What a factory changes is the volume. A pattern patch that used to reach one service at a time now reaches forty in an afternoon, so the rules have to run as code or they will be skipped.
| Role | Owns the decision | Does not decide | In the insurance factory |
|---|---|---|---|
| Platform team | which patterns exist, their versions, the factory runtime and its permissions | any product's business rules or release date | owns PAT-INTAKE-API; approves pattern releases |
| Domain team | the product spec, the business-rule module, when its product is released | what the shared pattern contains | owns SPEC-INTAKE-001 and the release of the intake service |
| Architect | whether a new pattern or a deviation fits the reference architecture | individual releases | reviews a new pattern before it is approved |
| Security reviewer | governed components: authentication, authorization, secrets, the factory's credentials | product behavior | approves changes to auth middleware and the secret scan |
| Compliance | audit records, data handling, retention, evidence an auditor will ask for | how a feature is built | approves changes to the audit record format |
The right-hand column is the useful one. Every row names a concrete thing in the running example. A role that cannot be pointed at an artifact it approves is a role nobody will exercise.
Approved patterns: a short list the factory enforces#
An approved pattern is a pattern version that the platform team has released and the review roles have accepted for production use, recorded in a list the factory reads before it starts. The tiny example: PAT-INTAKE-API 2.1.0 and 2.1.1 are approved; 1.9.0 is not. The operational consequence is that "use an approved pattern" stops being advice and becomes a refusal. Example C already does this at the smallest scale: its factory refuses a spec that names a wrong pattern version (test_factory_gates.py, "wrong pattern version refused"), and refuses a spec that opens the decision route to the agent, because human_decision_roles: ["underwriter"] is a pattern constraint, not a setting.
The trade-off is speed of adoption. A new pattern version cannot be used until it is approved, so the approval process must be fast for patches and thorough for new major versions. Factory learning loop is the home of pattern versions and blast radius; this page cares who signs the release.
The smallest primitive: a policy as data, checked by code#
Policy as code means writing an organizational rule as data or code that a program evaluates automatically on every change, instead of as a paragraph in a document that a person must remember. A tiny example: "an authorization change needs the security reviewer" becomes one entry in a policy file, and the pipeline asks the policy who must approve. The consequence: the rule runs every time, the same way, and its own changes are reviewed and versioned. The trade-off: a policy only covers what it names, so it must refuse what it does not recognize instead of letting it through.
The script below was written for this page as a teaching reconstruction and run on 2026-11-20. What it demonstrates: a policy that blocks unapproved pattern versions, routes the high-risk change classes of this site's safety rules to named roles, and refuses unknown risk flags. What it does not demonstrate: identity. Who the approver is, and that they really approved, is the job of the identity system and the signed record further down.
POLICY = {
"policy_id": "POL-RELEASE-001",
"version": "1.2.0",
"owner": "security reviewer",
"human_review_required": { # spec section 10: these changes always need a named person
"authorization_change": "security reviewer",
"insurance_decision_logic": "underwriting lead",
"schema_destruction": "data owner",
"credential_handling": "security reviewer",
"irreversible_deployment": "release approver",
},
"approved_patterns": {"PAT-INTAKE-API": ["2.1.0", "2.1.1"], "PAT-EVENT-WORKER": ["1.4.0"]},
}
def evaluate(change: dict, policy: dict = POLICY) -> dict:
"""Return the verdict and the people who must approve. Never approves anything itself."""
reasons, approvers = [], []
allowed = policy["approved_patterns"].get(change["pattern"], [])
if change["pattern_version"] not in allowed:
reasons.append(f"{change['pattern']} {change['pattern_version']} is not an approved pattern version")
for risk in change["risk_flags"]:
role = policy["human_review_required"].get(risk)
if role is None:
reasons.append(f"unknown risk flag {risk!r}: refuse rather than guess")
elif role not in approvers:
approvers.append(role)
verdict = "blocked" if reasons else ("needs human approval" if approvers else "automated gates suffice")
return {"change": change["id"], "verdict": verdict, "reasons": reasons, "approvers": approvers,
"policy": f"{policy['policy_id']} {policy['version']}"}
Four change requests, run through evaluate:
CHG-101: automated gates suffice; approvers=[]; reasons=[]
CHG-102: needs human approval; approvers=['security reviewer', 'release approver']; reasons=[]
CHG-103: blocked; approvers=[]; reasons=['PAT-INTAKE-API 1.9.0 is not an approved pattern version']
CHG-104: blocked; approvers=[]; reasons=["unknown risk flag 'new_tool_access': refuse rather than guess"]
CHG-101 is a reversible change on an approved pattern: the automated gates of CI/CD are enough. CHG-102 touches authorization and turns on an irreversible deployment, so two named roles must approve; the policy lists them and stops there. CHG-103 uses a pattern version nobody approved. CHG-104 carries a risk flag the policy has never seen, and the policy refuses it: a policy that let unknown flags through would be governed by its own gaps. Note also the version field. The policy is itself an artifact, with an owner and a version, changed through review like code.
Product (Sigstore cosign, as documented on 2026-11-20): cosign verify-attestation takes a --policy file written in CUE or Rego, so the same idea can be applied to signed attestations at verification time. This page's script uses neither language; it shows the shape of the decision.
Diagram: Where each role acts between a pattern and production
Three lanes. The platform team acts once per pattern release; the domain team acts once per spec and per release; the review roles act only where the policy routes a change to them. The policy box in the middle lane sits on every path and is the only box that never approves anything: it names who must.
- Platform team
- release a pattern version: A new pattern version becomes usable only after it is added to the approved list.
- factory runtime and identity: The platform team owns what the factory may touch and the identity it runs as.
- Policy and review
- architect review: Checks that a new pattern or a deviation fits the reference architecture.
- policy evaluates the change: Blocks unapproved patterns and unknown risk flags; names the approvers for high-risk classes.
- security or compliance approves: A named person reviews with the evidence in front of them.
- Domain team
- product spec: The domain team owns the spec, the business rules and the release decision.
- exception request: A deviation with a reason, a compensating check, an approver and an expiry.
- release with provenance: The release carries a signed statement of digest, builder and parameters.
The diagram shows where each role acts on the way from pattern to production. The platform team acts once per pattern release; the domain team acts once per product spec and per release; the review roles act only where a policy routes a change to them. The policy box sits in the middle of the line because every change passes it, and it is the only box that never approves anything: it decides who must.
Approvals: the changes a person must see#
This site's safety rules name five kinds of change that always require human review: high-risk authorization changes, external financial or insurance decisions, schema destruction, credential handling, and irreversible deployments. Each has the same reason: a mistake cannot be repaired after the fact by a rollback or a later test. The policy above routes each one to a role. CI/CD and deployment owns the general decision of manual approval against automated gate; this page owns who the person is.
Approvals multiply with a factory, and the blast lab shows how fast. Its governance preset renames a field of the shared audit record, actor to principal, a breaking change to a governed component. The lab's own function b_blast.radius, run on a scratch copy of examples/labcore/ with a script written for this page:
change: Audit record: field actor renamed to principal | breaking -> major
pattern PAT-EVENT-WORKER 1.4.0 -> 2.0.0 (owner: integration team)
pattern PAT-INTAKE-API 2.1.0 -> 3.0.0 (owner: platform team)
affected broker-submission-intake 3 of 50 tests
affected claim-notice-intake 3 of 40 tests
affected endorsement-request-intake 2 of 29 tests
affected policy-event-relay 2 of 24 tests
affected audit-export-job 5 of 18 tests
consumer: {'product': 'audit-export-job', 'owner': 'compliance engineering', 'reads_from': ['broker-submission-intake', 'claim-notice-intake', 'endorsement-request-intake'], 'contract_tests': 4}
suite: 19 of 206 tests
approvals:
- integration team (owner of PAT-EVENT-WORKER)
- platform team (owner of PAT-INTAKE-API)
- submissions team (owner of broker-submission-intake)
- claims team (owner of claim-notice-intake)
- policy servicing team (owner of endorsement-request-intake)
- integration team (owner of policy-event-relay)
- compliance engineering (owner of audit-export-job)
- compliance reviewer (audit_record is a governed component)
Teaching reconstruction: the catalog, owners and test counts are the lab's synthetic data. Eight approvals for one field rename is the honest cost of a breaking change to a governed component: both pattern owners, every affected product owner, and the compliance reviewer, because the audit record is evidence for auditors. The design response is not fewer approvers but one review with everything in front of them: the blast radius, the selective suite of 19 tests, and the consumer audit-export-job that reads three products' records.
Exceptions: a deviation on the record, with an end date#
An exception process is the governed way to let one product depart from a rule for a stated reason, with a compensating check, an approving role and an expiry date, recorded where everyone can count it. Platform foundations shows the record itself (EXC-0012, a product with no staging environment until a partner sandbox exists) and the decision of when to allow a deviation at all. Governance adds three duties around that record: someone reviews open exceptions before they expire; an exception may never cover a rule the policy marks as admitting no exception (who may decide an insurance outcome, masking of personal data); and the count of exceptions per rule is a signal that the rule itself should change.
Audit: records the auditor can read without asking the team#
An audit trail in this sense is the set of records that let someone outside the team reconstruct who did what, when, with what authority. A governed factory has two kinds, and they must not be mixed. The product's own audit records belong to the running service: Example C writes one per request, including refusals, and its auditor role reads 17 of them in the demo; Insurance factory, part 3 owns those. The factory's records are about building: factory runs, station attempts, gate results, approvals and the provenance of each artifact. The rest of this page is about the second kind, and about the auditor's second question.
Supply-chain provenance: what a reviewer can check#
Provenance is a record of where an artifact came from: which builder made it, from which source and parameters, in which run. An attestation is a signed statement about an artifact, made by a party that a verifier chooses to trust; provenance is the most common kind. Artifact signing binds an artifact's digest to an identity with a signature, so anyone can check that the bytes they have are the bytes that identity signed. A software bill of materials (SBOM) lists the components and dependencies inside an artifact.
The auditor's question becomes checkable when the record is not written by the code it describes. Four outside references give the vocabulary and the checks. Each is labelled with what it is, and each claim comes from its own documentation, read 2026-11-20.
Standard (SLSA v1.2, read 2026-11-20): SLSA's current approved version, v1.2, has a Build Track and a new Source Track. On the Build Track, L1 means provenance exists, generated by the build platform, but may be unsigned and is easy to forge; L2 means a hosted build platform generates and signs the provenance, so tampering after the build is detectable; L3 means hardened builds, isolated from one another, with signing secrets kept away from user-defined build steps. The Source Track requirements define four levels: version controlled; history and provenance; continuous technical controls on protected branches; and two-party review of changes to protected branches.
Standard (in-toto Attestation Framework, read 2026-11-20): an attestation is a Statement with _type https://in-toto.io/Statement/v1, a required subject list where each entry carries a digest, a required predicateType, and a predicate. The recommended signing envelope is DSSE. SLSA build provenance is expressed as such a Statement with predicate type https://slsa.dev/provenance/v1. in-toto is listed by the CNCF as a graduated project since 2025-02-10.
Open-source project (Sigstore, as documented on 2026-11-20): three parts: cosign, the signing client; Fulcio, a certificate authority that issues certificates valid for 10 minutes bound to an OIDC identity; and Rekor, a transparency log described as an immutable, append-only ledger of signing events. In the keyless flow the private key is discarded after one signing, and a verifier checks the certificate, the expected identity and proof of inclusion in Rekor instead of a long-lived key. The latest cosign release read was v3.1.4. Rekor v2 is generally available, but a post dated 2026-06-28 says the public-good instance keeps Rekor v1 as its default log for the foreseeable future, with v2 as an opt-in.
Standards (SBOM formats, read 2026-11-20): SPDX lists 3.0 as current on spdx.dev (the published spec site shows 3.0.1), and states that the SPDX specification is the international standard ISO/IEC 5962:2021. CycloneDX is at 1.7 (2025-10-21), published as ECMA-424 2nd edition; its in-toto predicate type https://cyclonedx.org/bom lets a CycloneDX BOM be the predicate of an attestation.
Guideline (NIST SP 800-218, SSDF, read 2026-11-20): the Secure Software Development Framework version 1.1 is final (February 2022) and groups practices as Prepare the Organization, Protect the Software, Produce Well-Secured Software and Respond to Vulnerabilities. SP 800-218 Rev. 1 (SSDF 1.2) is an initial public draft from 2025-12-17; comments closed and no final is published. SP 800-218A, a profile for generative AI and dual-use foundation models, is final (July 2024).
Diagram: From build to verified artifact: the producer's word never decides
Time runs down the page. The factory's builder produces the artifact and a provenance statement with its digest, builder and parameters. A separate signing step, holding a short-lived identity the stations cannot reach, signs the statement, and the signing event goes into a transparency log. The reviewer, with expectations fixed in advance, checks the signature, matches the digest, and compares builder, build type and parameters. An edited artifact or an unknown parameter fails.
- Factory builder to Signing step: statement: subject digest, builder, parameters. An in-toto Statement with predicate type https://slsa.dev/provenance/v1.
- Signing step to Transparency log: record the signing event. Digest, signature and certificate go into the log.
- Signing step to Factory builder: signed envelope. The statement wrapped in a signed envelope (DSSE is the recommended format).
- Reviewer to Transparency log: check signature and inclusion. Is this signature from the expected identity, and is it in the log?
- Reviewer: digest, builder, parameters. Match the subject digest to the artifact; compare builder, build type and parameters with expectations.
Read the sequence top to bottom. The factory's builder produces the artifact and a provenance statement naming its digest, its builder and its parameters. A signing step, holding a short-lived identity the build steps cannot reach, signs the statement, and the signing event is recorded in a transparency log. Later the reviewer, who decided in advance which builder, build type and parameters are acceptable, checks the signature, matches the digest to the artifact in hand, and compares the statement with those expectations. The factory's own word appears nowhere in the reviewer's decision.
The executable demonstration: a reviewer's checks, without the signature#
What this demonstrates: the checks a reviewer makes on the content of a provenance statement, following the order the SLSA verification page describes (match the subject to the artifact digest, confirm the predicate type, compare builder, build type and external parameters with expectations; unrecognized external parameters should fail verification). What it does not demonstrate: the signature check, which comes first in a real verifier and needs a signing system this example does not have. Teaching reconstruction: an unsigned, in-toto-shaped statement for openapi.json from FR-0003, written by a script for this page and run on a scratch copy of Example C on 2026-11-20. The builder and build-type URIs use the reserved .example domain; they are not real.
def review(stmt: dict, artifact_bytes: bytes) -> list:
problems = []
actual = hashlib.sha256(artifact_bytes).hexdigest()
if actual not in [s["digest"].get("sha256") for s in stmt["subject"]]:
problems.append("subject digest does not match the artifact")
if stmt["predicateType"] != "https://slsa.dev/provenance/v1":
problems.append("unexpected predicateType")
pred = stmt["predicate"]
if pred["runDetails"]["builder"]["id"] != EXPECTED["builder_id"]:
problems.append("built by an unexpected builder")
if pred["buildDefinition"]["buildType"] != EXPECTED["build_type"]:
problems.append("unexpected buildType")
params = pred["buildDefinition"]["externalParameters"]
for key in sorted(set(params) - EXPECTED["allowed_parameters"]):
problems.append(f"unrecognized external parameter: {key}")
if params.get("pattern") not in EXPECTED["approved_patterns"]:
problems.append(f"pattern not approved: {params.get('pattern')}")
return problems
The expectations come from the reviewer, not from the statement: the builder id, the build type, the allowed parameter names, and the approved pattern PAT-INTAKE-API 2.1.0. Three cases:
artifact sha256: d79646305fc547b1...
1 as built: no problems
2 artifact edited: ['subject digest does not match the artifact']
3 extra parameter: ['unrecognized external parameter: skip_gates']
note: no signature was checked here; a real verifier checks the envelope signature first
Case 1 is the build as the factory made it: the digest matches the one in FR-0003's manifest (d79646305fc5…). Case 2 adds one byte to the artifact, as a hand edit after the gates would: the digest no longer matches, and the edit is visible without any knowledge of what changed. Case 3 adds a parameter skip_gates the reviewer never allowed; the SLSA rule that unrecognized external parameters should fail catches it. With a signature check in front, these three checks answer the auditor: built by the expected builder, from an approved pattern, and unchanged since.
What this is not. This page owns roles, approved patterns, policy as code, approvals, exceptions and provenance for what the factory builds. The identity behind each approval, delegation and tokens are Auth Engineering; runtime policy on what an agent may do is Guardrails Engineering; the audit records of the running insurance service are Insurance factory, part 3. The controls around one coding agent's run are Harness Engineering.
In a coding agent. A coding agent such as Claude Code or Codex, running headless as a station worker, is a producer like any other, and governance treats its output that way: its commits are attributed to its own identity, its changes pass the same policy, and its own summary of what it did is never part of the evidence. Product (Claude Code, as documented on 2026-11-20): settings have a managed level that takes precedence over command-line, project and user settings, which is where an organization puts rules every developer and every agent run must follow. A person with merge rights reviews what the agent produced.
Try it#
The lab opens on the governance preset: the breaking rename of the shared audit record's actor field. Pick the other changes to compare how a patch, an additive change and a breaking change reach products, tests and approvers.
The same information for a reader without JavaScript (from docs/LABS.md, examples/labcore/b_blast.py, synthetic catalog of 3 patterns, 8 products and 206 tests):
| Change | Kind · bump | Pattern versions | Affected | Tests to rerun | Approvals |
|---|---|---|---|---|---|
audit-field-rename (governance) | breaking · major | PAT-EVENT-WORKER 1.4.0 → 2.0.0, PAT-INTAKE-API 2.1.0 → 3.0.0 | 5 products, plus consumer audit-export-job's 4 contract tests | 19 of 206 | 8 |
auth-middleware (platform) | fix · patch | PAT-EVENT-WORKER 1.4.0 → 1.4.1, PAT-INTAKE-API 2.1.0 → 2.1.1 | 5 products | 15 of 206 | 3 |
logging-format (default) | additive · minor | PAT-EVENT-WORKER 1.4.0 → 1.5.0, PAT-INTAKE-API 2.1.0 → 2.2.0 | 5 products | 7 of 206 | 3 |
test-harness | fix · patch | PAT-ALGO-UNIT 1.3.0 → 1.3.1, PAT-EVENT-WORKER 1.4.0 → 1.4.1, PAT-INTAKE-API 2.1.0 → 2.1.1 | 7 products | 9 of 206 | 3 |
idempotency-store | additive · minor | PAT-EVENT-WORKER 1.4.0 → 1.5.0, PAT-INTAKE-API 2.1.0 → 2.2.0 | 5 products | 16 of 206 | 2 |
The approval rule behind the last column: always each touched pattern's owner; a governed component (audit record, authentication, logging format) adds its reviewer; a breaking change adds every affected product's owner. No model takes part in this lab. Where the examples put an agent at a station, the agent there is a scripted stand-in, so these results show how the factory mechanics work, not how good any model is.
WatchAlgo in practice#
WatchAlgo was governed by one person, which is a legitimate design for a solo content site, and its repository shows exactly where the single-owner assumption carries the weight.
Observed in the repository (docs/EVIDENCE.md rows 9 and 17): there is no human review record. The reviews in reviews/ are model-written; the earlier pattern had Codex workers generating and Gemini reviewing only (.ai-context/SESSION_STATE.md). Acceptance was deterministic code (verify_solution, verify_viz in scripts/viz/pipeline.py), which is a strong control, but no person signed off on any unit or batch. "Spot-checked in browser" appears once, without saying by whom.
Observed (docs/EVIDENCE.md section 5): the September workers ran as claude -p --model sonnet --dangerously-skip-permissions with a 60-minute timeout. In this page's terms, the worker's permissions were not scoped by policy; the only boundary was the task and the acceptance check after it. Observed (section 13): an hourly cron entry still runs the old watchdog script; on 2026-11-20 it failed to start a binary that is no longer at its path and logged "Resume triggered" anyway, and the evidence notes warn it would start generation sessions on its own if that binary reappeared. Observed (section 13): the September branch with all content after 2026-04-02 has no upstream, so the only copy of 2,163 visualizations' history is one machine.
Reported by the author: the corpus was "assembled with no manual review" (watchalgo-architecture/AGENTS.md, 6011de34), and the 3,246 problems came from a repeatable process; The WatchAlgo story holds the reconciliation. Teaching reconstruction: three governance additions would have cost little even for one author: an inventory of every scheduled or automated worker with an owner and an end date, which would have retired the watchdog; scoped worker permissions instead of a skip flag; and a recorded human sample per batch, which EVIDENCE.md lists as the evidence that would turn "no manual review" into a measured quality rate.
Enterprise translation#
At the insurer, governance is mostly the routing of decisions that already exist to the people who already own them, with records. The platform team approves pattern releases and owns the factory's runtime identity. Domain teams approve their own specs and releases. The security reviewer owns the governed components and the factory's credentials. Compliance owns the audit record format and the evidence package. The architect reviews new patterns, not every release.
What dominates the critical path is not writing the policy file. It is agreeing which changes count as high-risk, getting the factory's own identity and permissions through security review, and deciding which provenance level the organization will require for which products, because a higher build level needs a build platform that can isolate runs and keep signing secrets from build steps. This site's recommendation: start by requiring signed provenance for every artifact that reaches production and verifying it at deployment, then raise the required level per risk tier.
Failure test#
The failure: after the gates passed, someone edits the generated openapi.json in the release folder to open a route, or a pipeline passes an extra parameter that skips a check. The gate report still says all gates passed, because it was written before the edit.
How the factory catches it: at verification, not at build time. The reviewer's check compares the artifact's digest with the provenance subject and refuses the mismatch (case 2), and refuses any external parameter not on the expected list (case 3). With signing in place, the attacker cannot rewrite the statement to match, because the signing identity is not reachable from build steps.
What to run or toggle: in a scratch copy of Example C, run run.py, then the provenance check script described above against out/factory/openapi.json; append one byte to the file and run it again. In the lab, compare the approvals of auth-middleware (3) with audit-field-rename (8).
Where to go deeper#
- Scaling safely (next): scoped credentials, sandboxes and quotas for many workers and teams.
- CI/CD and deployment: the gates and the evidence record that provenance signs.
- Platform foundations: the exception record and the golden-path decision.
- Factory learning loop: pattern versions and blast radius.
- Insurance factory, part 3: the audit records and trust controls inside the product.
- Auth Engineering: identity, delegation and least privilege behind every approval.
- Guardrails Engineering: runtime policy for what agents may do.
Checklist for Monday#
- Write the five-role table for your factory, with one artifact each role approves.
- Keep an approved-pattern list the factory reads before it starts, and refuse anything not on it.
- Turn the high-risk change classes into a versioned policy that names approvers and refuses unknown flags.
- Give every exception an owner, a compensating check and an expiry date; never allow one on a no-exception rule.
- Keep an inventory of every automated or scheduled worker, with an owner and a retirement date.
- Generate provenance for every artifact that reaches production, sign it with an identity build steps cannot reach, and verify digest, builder and parameters at deployment.
- Produce an SBOM per artifact in one format your consumers read, and attach it as an attestation.
Exercises#
- The factory's manifest lists every artifact's digest. Why is that not provenance in the SLSA sense?
Answer 1Written and stored by the producer, unsigned
Anyone who can change the build can change the manifest. Provenance at Build L2 is generated and signed by a hosted build platform, so tampering after the build is detectable; the manifest is closer to L1 (exists, easy to forge).
- A product team asks for an exception: "our service may skip PII masking in logs until next quarter". Approve with an expiry?
Answer 2No: a no-exception rule
Masking of personal data protects something that cannot be restored once leaked; Example C even lists an unmasked email in a log as a rollback condition. Rules of that kind belong in the pattern as enforced code, outside the exception process.
- A provenance statement passes every check, but the signature was never verified. What has the reviewer learned?
Answer 3Only that the statement is self-consistent
Without the signature, anyone could have written a statement that matches the artifact. The content checks become evidence only after the signature ties the statement to a trusted builder identity.
Advanced perspective#
Which SLSA build level a factory can honestly claimL1 is easy, L2 needs a hosted signer, L3 needs isolation
Standard (SLSA v1.2, read 2026-11-20): Build L0 is the absence of SLSA, meant for development builds. L1 requires a consistent build process and provenance generated by the build platform and distributed to consumers; it protects against mistakes, not tampering. L2 requires a hosted build platform that generates and signs provenance. L3 requires that build runs are isolated from one another and that signing secrets are not reachable from user-defined build steps. The pages read here define Build L0 to L3 only.
A factory raises a specific question for L3: the stations are user-defined build steps, and some of them run model-driven workers that read untrusted input such as specs, issue text and retrieved documents. If a worker can reach the signing identity, an injected instruction can produce a perfectly signed bad artifact. So the factory's design must keep signing outside every station: the station runner hands its output to a separate signing step that the station cannot call with arbitrary content. That is also why Scaling safely gives each worker only the credentials of its own task.
The verification side matters as much. Standard (SLSA v1.2 verifying artifacts, read 2026-11-20): expectations can come from trust on first use, from the producer over an authenticated channel, or from the source repository; verification can run at upload to a package registry, at download or install, or in a continuous monitor, and at least one should be used. For an internal factory, verifying at deployment admission, against expectations owned by the security reviewer, is the natural first point.
Transparency logs and keyless signing, operationallyShort-lived certificates, a public log, and a migration in progress
Long-lived signing keys are a governance problem of their own: someone must store, rotate and revoke them, and a leaked key signs anything. Open-source project (Sigstore, as documented on 2026-11-20): keyless signing replaces the key with a certificate valid for 10 minutes, issued by Fulcio against an OIDC identity, and records the signing event in Rekor; verification checks the certificate identity and issuer (cosign verify --certificate-identity … --certificate-oidc-issuer …) and inclusion in the log. For a factory the identity is the build platform's workload identity, not a person's, which ties each signature to the factory's builder.
Two operational facts from the same documentation are worth planning for. Rekor v2 is generally available with only two entry types (hashedrekord and dsse) and a new API, and clients need cosign v2.6.0+ or v3.0.1+; yet the public-good instance keeps v1 as its default for the foreseeable future, and the project flags a coming post-quantum migration with more breaking client changes. Pin your verifier's version, do not hardcode log shard URLs (the documentation says they rotate), and treat the signing stack as a dependency with an owner. Whether to use the public-good instance or run a private one is an organizational decision; the documentation read here does not make it for you.
SBOMs in a factory: generate per artifact, consume by policySPDX or CycloneDX, and what an SBOM does not prove
A factory generates many artifacts from one pattern, so their dependency lists are mostly shared; an SBOM per artifact makes the shared part queryable. When a vulnerable library is announced, the question "which products contain it" becomes a search, which is the dependency version of the software catalog's "who owns this".
Standards (SPDX, CycloneDX, read 2026-11-20): SPDX 3.0.1 is organized into profiles including Software, Security, Build, AI and Dataset; CycloneDX documents formats for software, services, cryptography, ML models and vulnerability exchange (VEX, VDR), in JSON, XML and Protobuf. Either can travel as the predicate of an attestation; CycloneDX documents the predicate type https://cyclonedx.org/bom. This site does not rank them. The practical criterion is which format your consumers and scanners read; choose one per organization.
What an SBOM does not prove: that the list is complete, that the components were not tampered with, or that a listed vulnerability is reachable. It is a claim by the producer. Signed as an attestation from a trusted builder, it becomes a claim with a known author; it never becomes a test.
Mapping the factory to NIST SSDF, carefullyVersion 1.1 final, 1.2 draft, 800-218A for model producers
Guideline (NIST SSDF, read 2026-11-20): SP 800-218 (SSDF 1.1, final February 2022) groups practices as PO (Prepare the Organization), PS (Protect the Software), PW (Produce Well-Secured Software) and RV (Respond to Vulnerabilities). A factory maps onto all four without stretching: roles and the approved-pattern list are preparation; signed provenance and protected signing are protection; gates and independent tests are production of well-secured software; the learning loop that turns a defect into a pattern change is response.
Two cautions for anyone writing a compliance mapping. First, cite 1.1 as final and 1.2 as a draft: SP 800-218 Rev. 1 (SSDF 1.2) was published as an initial public draft on 2025-12-17, comments closed on 2026-01-30, and no final is listed as of the date read; its specific changes are not listed on the pages read here. Second, SP 800-218A (final, July 2024) adds practices for producers of generative AI models and of systems that use them; a factory that only calls a model at some stations is a consumer of models, and the profile's relevance depends on what the organization produces. The documentation read here does not say whether 800-218A will be updated to match SSDF 1.2.
In one breath#
Governance in a factory is a table of who decides what, enforced by code where it can be and recorded every time it is used. The platform team releases approved patterns, domain teams own specs and releases, and security, compliance and architecture review only what a versioned policy routes to them; the policy names approvers, refuses what it does not recognize, and never approves anything itself. The auditor's question is answered by provenance the producer cannot rewrite: a statement naming the artifact's digest, builder and parameters, signed by an identity build steps cannot reach, and checked against expectations the reviewer set in advance.
The intake service now carries an owner, an approved pattern and a verifiable origin. What governance cannot do alone is keep forty factory workers, five teams and one shared account from stepping on each other: who may touch which files, which credentials each worker holds, and how many may run at once. Scaling safely draws those boundaries.