Skip to content

Latest commit

 

History

History
512 lines (380 loc) · 124 KB

SPEC.md

File metadata and controls

512 lines (380 loc) · 124 KB

Weight Custody Manifest (WCM)

An Open Specification for Protecting Model Weights in Customer-Controlled Infrastructure

Working draft, v0.16. Open specification, pre-1.0. Subject to change and NOT ready to build against yet; read the open questions (section 8) before relying on anything here. The operated custody service and enclave implementation are separate and proprietary; this repository is the open protocol layer only.

Renamed from "Model Manifest" in v0.2. The artifact governs weight release and custody, not model identity or capability, so the name now says that. The "Model *" naming space (a separate companion model-passport effort) is intentionally left aside. See section 4.


1. The Setup: The Trust Direction Nobody Solved

Confidential-computing platforms solve a specific and well-understood problem: protecting a customer's data from the operator of the model that touches it. Confidential computing, verifiable agent identity, and the cMCP gateway all point the same direction. The enterprise is the vulnerable party, the model operator is the party being constrained, and the customer needs proof the constraint is real.

Deploy a frontier model into a customer's own infrastructure, on prem, inside a sovereign cloud, behind an air gap, and the vulnerable party flips. Now it is the model builder whose IP is exposed. Once weights leave the builder's boundary, the builder has to trust the customer's hardware, hypervisor, and operations staff not to extract the weights, copy them, fine tune and leak a derivative, or reverse engineer proprietary architecture choices out of the artifact itself. Attestation-gated key release into a verified enclave is established technology: key broker / KBS services ship it today (CNCF Confidential Containers Trustee, Azure Secure Key Release, Intel Trust Authority). What does not yet exist is a profile that binds that release to weight-custody terms, license, permitted derivatives, jurisdiction, under joint builder-and-custodian authority, with a way to revoke it if the environment is later found compromised. That profile, and the flipped trust direction it serves, is what this document specifies; the release primitive it builds on is prior art, not a claimed invention.

This is a forward-looking design. It targets the builder-into-customer-infrastructure case: a frontier lab whose weights need protecting the moment a custodian's infrastructure sits between those weights and a customer's own hardware. It is written ahead of that need, not against any specific deployment.

This is the half of that trust boundary the customer-facing platforms do not address, and where this specification starts.

Weight Custody Manifest is the second half of a trust boundary the customer-facing platform already owns one side of. Where the existing platform proves to the customer what the model operator did, Weight Custody Manifest proves to the model builder what the customer's infrastructure will and will not do with the weights it is trusted with.


2. Design Principles

Five principles. To be precise about what is open and what is opinionated: the manifest format, schema, and threat model are open and vendor-neutral (Principle 5 makes the neutrality explicit); the reference architecture is opinionated, it assumes a custodian and an enforcement point, with an operator-hosted custodian as the default, rather than a fully federated protocol. Open where interoperability and auditability matter, opinionated where a working reference has to make choices. It is not a "trust us" black box, and it is not a finished public standard either; the natural standards home for the manifest-plus-signed-receipt design is IETF SCITT, noted as follow-up.

  1. Custody, not just visibility: a guarantee that only observes misuse after the fact is not sufficient for an asset as valuable as frontier weights. Against a remote software adversary the weights are never in a form the customer's infrastructure can act on outside the enclave: encrypted at rest, decrypted only inside attested memory, and inaccessible to the host OS and a software-privileged operator without hypervisor control by construction. A malicious hypervisor is covered only when ciphertext-side-channel mitigation (ciphertext-hiding) is enabled, and a physical operator who owns the hardware is not covered by the silicon at all (the honest scope is section 3.6). Against that operator the guarantee is not cryptographic custody but accountability-grade: raising the cost of extraction, detecting and attributing it, containing continued serving through revocation, legal recourse, and a physical-hardening tier that is mandatory when the operator itself is the adversary.
  2. Enforced at the point of release, not the point of detection: the strongest control is the one exercised before the key is handed over, not the one that notices theft afterward. Attestation gated key release is the anchor primitive everything else in this document hangs off.
  3. Revocable, always: every grant of access has a corresponding way to take it back, and the ability to revoke cannot depend on the customer's cooperation. If an environment's attestation posture changes, degrades, or is later found compromised, decrypt access stops without needing the customer's infrastructure to agree.
  4. Symmetric with the platform, not bolted onto it: a confidential-computing platform already runs a control plane for the customer facing direction. Weight Custody Manifest is the same control plane, same enclave primitives, same cMCP gateway, exercised for the opposite party. A customer bringing their own model into that environment (BYOM) and a builder placing a model into that environment should be the same underlying mechanism with the roles reversed, not two separate products.
  5. Custodian is a role, not a fixed party: an operator-hosted custodian is the default, but the architecture leaves room for a customer's own infrastructure to act as custodian without a third-party operator in the loop, provided it meets the same attestation bar. This matters for sovereign customers who will not accept a third party, even a trusted one, sitting permanently in the key release path. The protocol, not the operator, is the thing being trusted.

3. Reference Architecture

Four layers, deliberately mirroring the shape of the platform's existing customer facing side, because the same primitives, run in the other direction, are the whole point.

+-----------------------------------------------------------+
|  Layer 4 - Derivative Lineage & Compliance Mapping         |
|  (fine-tune tracking, IP chain of custody, RATS/EAT, NIST) |
+-------------------------------------------------------------+
|  Layer 3 - Runtime Custody & Extraction Defense            |
|  (kill switch, exfiltration monitoring, resource ceilings)  |
+-------------------------------------------------------------+
|  Layer 2 - Attestation-Gated Key Release                    |
|  (enclave verification, policy co-governance, revocation)   |
+-------------------------------------------------------------+
|  Layer 1 - Weight Custody Manifest                                   |
|  (signed weight identity, license terms, release policy)    |
+-------------------------------------------------------------+
              ^                                    ^
        Model builder                       Customer enclave
    (any frontier lab or vendor)       (any sovereign or enterprise env)

3.1 Layer 1: The Weight Custody Manifest

Before any weights move, the builder issues a signed manifest describing exactly what is being released and under what terms. This is the artifact this document is named for, and it is the one piece of this architecture built to also serve as the customer facing evidence of what was released, in case of audit or dispute.

The normative machine-readable form of this section is schema/wcm-manifest-v1.schema.json, a JSON Schema 2020-12 document identified by https://wcm.agentrust-io.com/schema/manifest/v1.json. It is frozen at v1 and additive-only: fields and permitted enum values may be added, but nothing is removed, renamed, made required, narrowed, or repurposed inside v1, so an implementation written against it stays valid as the specification continues to evolve pre-1.0. One constraint below (derived_from must not equal weights_hash) cannot be expressed in JSON Schema and is verifier-side only; schema/README.md records the versioning policy and that gap, and conformance/vectors/manifest/ carries the structural vectors an implementation is checked against. The JSON below is illustrative and abbreviated; where the two differ, the schema governs.

Two enum values were renamed in v0.16 and their old spellings are deprecated aliases: revocation_authority: builder-and-opaque-joint is builder-and-custodian-joint, and custodian_type: opaque-hosted is custodian-hosted. Under the additive-only rule both old spellings stay valid in v1. A verifier MUST accept them and MUST treat each as identical to its replacement for every policy decision. A verifier MUST NOT rewrite them before computing the signing pre-image, since the signatures cover the spelling the signer used. New manifests SHOULD use the new spellings. The revocation_authority default remains builder-and-opaque-joint in v1, because verifiers materialize defaults into the pre-image and changing the default would break every signed manifest that omits the field; issuers SHOULD write the field out explicitly.

{
  "manifest_version": "0.1",
  "weights_hash": "sha256:4a1c...9b02",
  "builder": {
    "identity": "example-builder",
    "signing_key": "ed25519:builder-key..."
  },
  "release_terms": {
    "license": "customer-deployment-agreement-ref:CDA-2026-0091",
    "permitted_derivatives": "fine-tune-only, no re-export of base weights",
    "derivatives": "fine-tune-only",
    "permitted_environments": ["example-attested-enclave"],
    "jurisdiction_restriction": "US, EU"
  },
  "release_policy": {
    "required_assurance_tier": "hardware-attested",
    "physical_hardening": "not-required | tamper-evident-enclosure+access-control+chain-of-custody",
    "trusted_time_source": "secure-tsc | lease-with-op-count-hybrid | none-best-effort",
    "memory_fingerprint_challenge": "required-for-hostile-owner-posture | not-required",
    "required_hw_platform": ["amd-sev-snp", "nvidia-cc-gpu"],
    "required_gpu_measurement": {
      "rim_pin": "nvidia-rim:driver+vbios golden measurement id",
      "require_cc_mode": "optional; absent means required, only false waives it",
      "note": "GPU attestation report is a SEPARATE evidence chain from the CVM report; verify both plus the serving-image measurement, bound by a nonce echo (see 3.2 composite verification)"
    },
    "require_evidence_verification": "optional; absent means required, only false waives it",
    "tenancy": "shared",
    "platform_integrity": {
      "alias_check_complete": "required | not-required",
      "ciphertext_hiding": "required | not-required",
      "note": "hardware-reported platform state, read from SEV-SNP PLATFORM_INFO bits 5 and 4; optional and absent by default, see 3.6"
    },
    "required_serving_image": {
      "signer": "ed25519:builder-key...",
      "release_rule": "prefer-current: refuse a retiring image when a current one is available; require signed/attested time for retire_after, never the host clock",
      "accepted_measurements": [
        { "measurement": "sha256:serving-stack-v2...", "status": "current" },
        { "measurement": "sha256:serving-stack-v1...", "status": "retiring", "retire_after": "2026-07-16T00:00:00Z" },
        { "measurement": "sha256:serving-stack-v0...", "status": "revoked" }
      ],
      "note": "key decrypts only under a builder-signed serving stack whose measurement is current or retiring; status:revoked hard-fails immediately (emergency kill for one image without darkening others or re-issuing live manifests)"
    },
    "key_release_mode": "attestation-gated",
    "replay_protection": "kbs-nonce-required",
    "attestation_revocation_check": "live-per-release, max-cache-age: short-window",
    "revocation_authority": "builder-and-custodian-joint",
    "sovereign_profile": {
      "enabled": false,
      "revocation_authority": "quorum",
      "sovereign_signer": "required",
      "note": "when enabled, no single party (builder included) can revoke or dark the model unilaterally"
    }
  },
  "custody": {
    "custodian": "example-custodian",
    "custodian_type": "custodian-hosted | customer-self-custody",
    "kbs_image": {
      "measurement": "sha256:kbs-release-logic...",
      "signer": "ed25519:custodian-key...",
      "note": "the key release service runs in an attested enclave in EVERY profile, operator-hosted included, so even a custodian insider cannot alter release logic without failing this measurement"
    },
    "enclave_id": "did:example:enclave-04",
    "attestation_cadence": "24h",
    "kbs_attestation_cadence": "24h (anchor: >= inference cadence; short-inference sovereign deployments set this much longer than their inference cadence, see 3.5)"
  },
  "base_confidentiality": "confidential | gated-open | open",
  "deployment_model": "builder-to-customer | byom-symmetric",
  "signatures": [
    { "role": "builder", "signer": "example-builder", "sig": "base64:..." },
    { "role": "custodian", "signer": "example-custodian", "sig": "base64:..." }
  ]
}

Key design choices:

  • The manifest is signed jointly by the builder and the custodian, never by the customer alone. The customer is the party being constrained by this document. Letting the constrained party co-sign its own constraint defeats the purpose. The custodian stands in the position TLS certificate authorities occupy for the web: a party both sides can point to. The analogy carries an obligation, though: CAs became trustworthy only once Certificate Transparency made equivocation detectable. Joint signatures alone do not stop a custodian (or a coerced builder) from issuing two different manifests for one weights_hash, so the same transparency mechanism is required here (section 3.7).
  • release_terms is a legal artifact wearing a technical wrapper. License, permitted derivatives, and jurisdiction restriction map directly onto the deployment agreement's actual contract language, so the manifest is the enforceable, machine checkable version of terms legal already negotiated, not a parallel policy invented by engineering.
  • required_assurance_tier is not optional the way it is in an open protocol. Weight Custody Manifest has exactly one baseline tier for anything above a pilot: hardware attested. Claim-only assurance, sufficient for a hobbyist self-hoster, is not sufficient for frontier weights. There is no lower tier to fall back to. Above the baseline, the physical_hardening tier adds tamper-evident or tamper-responsive enclosure, physical access control, and supply-chain chain-of-custody. It is optional in the semi-trusted default posture, where the silicon holds in practice, and mandatory in the hostile-owner posture, where it is the only technical defense against the memory-bus attack class that defeats the CPU CVM and forges attestation (section 3.6).
  • revocation_authority is joint by default, with a unilateral emergency override. The builder alone should not be able to revoke mid contract without recourse, and the custodian alone should not be able to keep serving weights the builder has flagged. Joint authority is the standard path. Either party can also trigger an immediate unilateral emergency revocation outside that path, with mandatory joint reconciliation afterward. See section 3.2 for how that works in practice.
  • custodian_type is not locked to one operator. The default is an operator-hosted custodian, but a customer's own infrastructure can act as custodian if it meets the same hardware attestation bar as required_assurance_tier. In the operator-hosted case, the operator is trusted to run the key release service. It is not architecturally required to be a permanent third party in every deployment. Independent of who hosts it, the key release service itself runs inside an attested enclave in every profile (custody.kbs_image), so the release logic is measured and cannot be altered even by a custodian insider with infrastructure access. Self-custody differs only in who operates that attested enclave, not in whether it is attested (section 3.5).
  • required_serving_image is the control that actually protects the weights, and it is builder-signed. Attestation-gated release protects the decryption key. The asset is the decrypted weights in enclave memory, and whoever supplies the code running inside the enclave can read them. So the party that gets to read the weights is the party that signs the serving stack, and in this architecture that party is the builder, not the customer and not the custodian. The key decrypts only under a serving image whose measurement matches the builder's signature, which is why "no raw weight export path" (Layer 3) can be a real property rather than a policy promise. The consequence is deliberate and worth stating plainly: the customer, including a sovereign customer, runs builder-signed code inside its own environment. The customer's leverage is not authorship of that code but the ability to read its measurement out of the attestation quote and refuse the deployment if it does not match what was disclosed, plus the revocation veto below. This is the one place the architecture asks the customer to accept opacity, and it is the price of the guarantee being enforceable in silicon instead of on paper. Patching is handled by accepted_measurements: the builder keeps a small set of currently-valid serving-image measurements and retires old ones on a window, so a security patch to the serving stack adds a measurement rather than invalidating every live manifest and forcing a fleet-wide re-issuance.
  • tenancy is an opt-in dedicated-hardware control. The default is shared. A high-value deployment can set dedicated, forbidding co-located workloads on the same physical host. This is the operational mitigation for the side-channel residual (cache, timing, and contention attacks on shared silicon) that hardware confidentiality does not fully close, documented as ADV-6 in the threat model. It is opt-in because it trades cost and hardware flexibility for that margin, and not every deployment needs it.
  • required_hw_platform is a profile list, not a universality claim. The manifest pins concrete platforms (amd-sev-snp, nvidia-cc-gpu), and today those are the only implemented ones, so "any environment" in the diagram means any environment that satisfies an accepted platform profile, not literally any silicon. What a platform must provide to qualify is abstract and silicon-agnostic: a hardware-rooted, nonce-bound attestation quote over its firmware and the measured runtime/serving image, verifiable against a builder-pinned reference, plus a confidential execution boundary the host cannot read. Any accelerator meeting that interface, a CPU CVM, a confidential GPU, a TPU, a custom ASIC, or a lab's own silicon, can be added as a new platform profile. This matters for a frontier lab whose requirement is every silicon including its own; the abstraction is specified, the additional concrete profiles are follow-up, and the spec should not imply coverage it has not implemented.
  • trusted_time_source names the clock the cadence floor trusts, per deployment, rather than assuming one. Wipe-on-lapse only bounds exposure if the enclave has a clock the host cannot stall or roll back (section 3.2). The field makes that assumption explicit and picks its strength per platform. secure-tsc is a hardware-rooted monotonic clock the hypervisor cannot stall (AMD SEV-SNP, current generations); where the silicon provides it, it is required, and the floor holds as specified. lease-with-op-count-hybrid is the fallback for platforms without a hardware time root (Intel TDX today, any future non-AMD profile): it anchors renewal in the actively-serving case to a count of inference operations the enclave's own execution increments, which a host cannot advance without also doing the inference work, and in the idle case to a wall-clock lease sourced from the KBS's own signed timestamp rather than the guest's local clock. That bounds exposure to how long the host can lie to the KBS about elapsed time, which is narrower and more auditable than how long it can lie to the guest, but it is the weaker guarantee and is marked as such: a builder accepting a deployment must be able to tell the two tiers apart, and the hybrid tier must never read as equivalent to secure-tsc. none-best-effort provides no floor and is disclosed as such. This is the resolution of former open question 8.9.
  • platform_integrity carries requirements on hardware-reported platform state, read from the SEV-SNP PLATFORM_INFO field rather than asserted by the deployment. alias_check_complete requires bit 5 (AMD's BadRAM mitigation, AMD-SB-3015); ciphertext_hiding requires bit 4, the precondition section 3.6 attaches to the semi-trusted-operator custody claim. Both are not-required by default and the whole object is optional, so a manifest written before the field existed signs to identical bytes (the pre-image is built over a dump that drops absent optional fields; a defaulted non-optional field would have invalidated every existing signature). Two implementation notes the verifier must honour: ALIAS_CHECK_COMPLETE carries meaning only from SNP report version 3, so on an older report it is indeterminate and a required check MUST deny rather than read the reserved zero as a failure or a pass; and this field is SEV-SNP-specific, so a required check on non-SNP evidence denies rather than silently passing.
  • memory_fingerprint_challenge and attestation_revocation_check are the two additions that split the forged-attestation problem (section 3.6, former open question 8.8). Forged attestation was two different attacks wearing one label. The measurement-forgery half (BadRAM-class: aliasing DRAM so a measurement reads clean while the guest runs from aliased addresses, the signing key never leaving the chip) is detectable, because aliased memory produces address collisions a genuine full-size DRAM installation cannot. memory_fingerprint_challenge is the WCM-level check for it: the KBS sends random values, the enclave writes them across its full declared DRAM range, reads them back, and returns a hash of the readback pattern in its attestation response; collisions indicate aliasing. It is not in any vendor's stock attestation flow, so it is specified here, required in the hostile-owner posture and optional in the semi-trusted default. The key-extraction half (TEE.fail-class: an interposer physically lifts the attestation signing key, then signs a cryptographically valid quote for a fabricated environment) is not detectable at the gate, because the quote is genuinely valid. attestation_revocation_check is one of its compensating controls, made a hard release_policy requirement rather than left to whoever builds the KBS: the attestation-key certificate (AMD VCEK via KDS, the NVIDIA equivalent) is checked live per release against a short maximum cache age, so a revoked key is caught fast. The other compensating controls (vendor-side short-lived certs, mandatory physical hardening, fleet anomaly monitoring) live in section 3.6; the key-extraction half stays honestly open.
  • base_confidentiality states whether the base weights are actually secret, so the manifest is not read as promising a guarantee it does not hold. Three values, all under the joint signature. confidential is the default and the frontier-model case the rest of this document is written around: the base weights are secret and attestation-gated release protects that secrecy. gated-open is a base obtainable under a gated license (a community license, a click-through); its secrecy is license-gated, not cryptographic. open is a fully public base (a downloadable open-weight checkpoint), where encrypting the base protects nothing because anyone can fetch the same checkpoint. Making the value explicit resolves a real ambiguity: for an open base the same four layers still do genuine work, but a different set of work than for a confidential one. What they protect is the integrity and provenance of the served stack (you are running exactly the certified checkpoint and serving image, not a tampered fork), the enforcement of license and field-of-use terms as a technical release condition, the custody and lineage of the derivative (the fine-tune on proprietary data, which is novel IP that never existed publicly and is the actual asset), and a kill switch whose trigger has shifted from "theft detected" to a safety recall or license breach. The field is declarative; the reference verifier does not block on it, but it emits a consistency note where a declaration and a control disagree (an open base carrying secrecy-only controls such as tenancy: dedicated or physical_hardening), so the mismatch is on the record rather than silently implying secrecy. The base's own confidentiality being moot does not make the manifest moot; it moves the value, and the field says which regime applies.
  • deployment_model names which direction the trust runs, and makes the symmetric case a first-class posture rather than an accident. builder-to-customer is the default and the primary walk-through of this document: a builder places a model into a customer's environment, and the vulnerable party is the builder. byom-symmetric is the case where one organization holds both the builder and custodian roles, bringing its own model into confidential infrastructure it also operates and custodies. This is design principle 4 (section 2) made concrete: the same control plane, enclave primitives, and gateway, exercised with the roles collapsed onto one party rather than split across two. Structurally it requires custody.custodian_type: customer-self-custody (the org custodies its own model), and it is the posture in which builder.identity equal to custody.custodian is expected rather than suspect; the verifier confirms the single-identity self-custody in a note. The common trigger is an enterprise governing an open-weight model for its own use, where the builder/custodian distinction that protects a frontier lab's IP against a customer no longer has two adversarial parties to separate, but the integrity, license, and derivative-custody machinery is still wanted. Naming it keeps BYOM from being two separate products; it is the same manifest with the roles identified.
  • sovereign_profile binds revocation to a quorum (and the name is scoped deliberately). In the default (non-sovereign) profile, either party can trigger a unilateral emergency revocation (see section 3.2). That is unacceptable in a sovereign deployment: a foreign builder holding an own-signature kill switch over a model running inside a sovereign jurisdiction is exactly the dependency sovereign programs exist to remove. With sovereign_profile.enabled, revocation requires a quorum that includes the sovereign signer, so no single foreign party can dark the model. The tradeoff is that emergency revocation is slower. Note that wipe-on-lapse is not an independent backstop in this profile, because a hostile hardware owner can forge attestation (section 3.2, open question 8.8); the sovereign profile's revocation guarantee rests on the quorum and on mandatory physical hardening, not on the floor. The name is precise about its scope: it confers a quorum veto over the release-and-revocation decision, not sovereignty over the weights, the runtime code (still builder-signed), or the silicon. It is a governance control, not a claim of full national control over the deployment.

3.2 Layer 2: Attestation-Gated Key Release

This is the handshake, run in the opposite direction from a model-passport verification, where a caller verifies a model before sending it data. Here, the builder (or the custodian acting on the builder's behalf) verifies the customer's enclave before releasing a decryption key. It builds on the established attestation-gated key-release pattern (key broker / KBS services such as CNCF Confidential Containers Trustee, Azure Secure Key Release, and Intel Trust Authority); the novelty is the weight-custody profile and the flipped trust direction, not the primitive.

Flow:

  1. The enclave requests release. The key release service replies with a fresh, single-use challenge (nonce). This binds the coming quote to this exchange and this instant, so a quote captured on the wire cannot be replayed later to obtain a key.
  2. The customer's enclave produces its evidence over that nonce. This is two chains, not one: a CPU CVM quote (RATS/EAT format, covering firmware, kernel, confidential-VM measurements, and the running serving-image measurement) and a separate GPU attestation report (NVIDIA CC, covering GPU firmware/VBIOS and CC mode). Both echo the same nonce.
  3. The key release service performs composite verification: the nonce is the one it issued and unexpired; the CPU hardware is genuine and its measurements satisfy required_hw_platform, required_assurance_tier, and required_serving_image (current or retiring, not revoked, prefer-current); the GPU report is genuine, its measurement matches required_gpu_measurement against NVIDIA's RIM golden values, and it establishes confidential-compute mode (a GPU whose mode is off does not protect the weights in its memory; the mode is established only by a cryptographically verified GPU report, under the assumption stated below, and only required_gpu_measurement.require_cc_mode: false waives this); and the CVM report and GPU report are bound to each other by the shared nonce echo, so a valid CPU quote paired with an unattested or mismatched GPU is rejected. The binding is the real join and is the part NVIDIA leaves least documented, so it is called out explicitly. "Genuine" means verified cryptographically, against the vendor's certificate chain and the challenge nonce, unless release_policy.require_evidence_verification is explicitly false; a release service with no verifier for evidence the manifest requires refuses rather than trusting the evidence's structured fields. The operator of a release service can require verification a manifest waives, and cannot waive verification a manifest requires. The release service itself runs in an attested enclave (custody.kbs_image), in every profile, so this verification logic is measured and cannot be quietly altered by whoever operates the KBS.
  4. If verification passes, the decryption key for that specific weights_hash is released into the enclave and never persists outside it. The host OS, hypervisor, and any custodian staff with infrastructure access cannot observe the key or the decrypted weights.
  5. The enclave holds the key only for the attestation cadence window declared in the manifest (mirroring a session TTL). Before that window lapses, the enclave must re-attest, the same as Layer 1's re-signing. If re-attestation does not succeed before the window closes, the enclave zeroizes the key from its own memory, stops authorizing inference, and invokes its teardown adapter to stop the serving worker (see wipe-on-lapse below, and the stop semantics under Failure paths for what that adapter is and is not). The key is not "suspended pending renewal"; it is gone, and a fresh release requires a fresh successful attestation.

Renewal is evidence-bound, not a caller assertion. The KBS consumes a fresh single-use challenge, re-runs the release gates, and issues a short-lived signed renewal decision containing the weights hash, signed-manifest hash, challenge-nonce hash, complete-evidence hash, gate results, and validity window, but no model key. The initial release pins the KBS renewal public key. The enclave resets its cadence and operation budget only after verifying a matching, unexpired decision it has not consumed before. A decision for another model or policy, a failed gate, an expired decision, a replayed decision, or a decision arriving after zeroization cannot renew custody. The low-level SDK reattest() method is a compatibility primitive whose caller remains responsible for fresh verification; production serving uses the signed decision path.

Stopping after unsuccessful renewal: no unsuccessful outcome ever extends the current lease, and two cases are distinct. An inconclusive failure, where the KBS was unreachable or its response could not be verified, carries no verdict about the enclave: fresh attempts may continue within the existing lease and its remaining operation budget. An authenticated denial is a verdict the KBS reached after verifying evidence, and the enclave must not treat it as a transport error or retry it as though nothing was decided. The distinction is already on the wire in the signed decision's renewed field, so an implementation that collapses a denial into the same outcome as a malformed or unverifiable decision is discarding a signal the protocol carries. A denial whose reason is revocation-class, including a revoked serving image, a revoked attestation key, or a manifest no longer in force, ends custody immediately. Any other authenticated denial stops new admission and leaves the enclave serving out an unextendable lease, so an image roll or comparable operational condition can resolve without darkening the fleet. Serving out that remainder does not weaken the floor and must not be read as a concession: a denial cannot move the deadline, so worst-case exposure is still the one cadence window wipe-on-lapse bounds, which is the only property it claims. A revocation authenticated under the applicable profile likewise takes effect immediately. Otherwise the stop boundary is the lease deadline, inclusive (now >= deadline); a window still open at the instant it closes is a window whose length is unstated. A protected controller must enforce the boundary while idle as well as while serving, independently of a blocked renewal call. It must stop admission and prevent in-flight inference from continuing beyond that boundary. Graceful draining must finish before the boundary; remaining work must be cancelled or forcibly terminated, not granted extra lease time.

At the boundary the runtime permanently disables authorization, zeroizes its held key, and invokes a teardown adapter that stops admission, halts in-flight inference, releases model memory, and terminates the serving worker. Be precise about which half of that WCM enforces. Ending authorization and wiping the key are enforced. The teardown itself is supplied by the deployment, because nothing in WCM can reach a worker's decrypted weights; what is normative is that the adapter is invoked in that order, exactly once, that memory release is skipped when in-flight work cannot be confirmed quiesced rather than freed underneath a running kernel, that a failed teardown never restores the ability to serve, and that termination is still attempted when earlier steps fail. This is a required interface, not an optional one: a deployment supplying no adapter must disclose that it has none, exactly as release_policy.trusted_time_source requires none-best-effort to be named rather than left silent. Such a deployment still stops authorizing at the boundary, and nothing tears its loaded model down. Restart requires fresh attestation and release. Process exit, buffer deallocation, and the SDK's best-effort Python overwrite are not proof of erasure of all plaintext copies from DRAM or device memory, and a process cannot attest its own completed termination. A protected watchdog, an external supervisor, and platform-specific teardown primitives remain necessary; see protected-runtime evidence.

Channel binding: the key is sealed to the enclave, not handed to the channel. Nonce binding (step 1) closes quote replay, a quote captured on the wire cannot be presented later. It does not by itself close quote relay: a network adversary (ADV-4) that terminates the enclave's channel can forward a live, valid quote and have the key released onto its own channel, because attested-TLS-style binding ties the evidence to the ephemeral transport key only, not to the whole session (the intra-handshake binding gap; CVE-2026-33697). WCM closes this by not returning the key on the channel at all. In step 2 the enclave generates a transport keypair and folds its public key into the quote's REPORT_DATA alongside the nonce (sha256(nonce || transport_pubkey)), so the transport key is vouched for by the same hardware signature and a relay cannot substitute its own without breaking verification. In step 4 the KBS seals the released key to that transport key (ephemeral-static X25519, HKDF-SHA256, ChaCha20-Poly1305) before it leaves. A relayed release then yields only ciphertext the relay cannot open; only the enclave holding the transport private key can. On platforms where REPORT_DATA is not guest-controlled (the Azure vTPM paravisor path), the transport key's hardware binding rides the enclosing vTPM quote rather than the CVM report field, the same topology already noted for the nonce. The object-seal holds regardless, since it depends on the transport private key never leaving the enclave, not on where the binding is recorded.

The gate is only as sound as attestation is unforgeable. Every step above assumes the quote the KBS verifies is genuine. That assumption holds against a remote or software adversary and, in practice, against a semi-trusted operator. It does not hold against a hostile hardware owner: TEE.fail / BadRAM-class attacks forge quotes that pass verification at the highest trust level (section 3.6), so in that posture the KBS cannot distinguish a forged environment from a real one by verification alone. This is why the hostile-owner posture requires the physical-hardening tier, and why detecting a forged quote at the gate is called out as an unresolved residual (open question 8.8). In the semi-trusted default posture, the gate is sound.

Confidential-compute mode is an assumption, stated as one. No signed NVIDIA evidence we have examined states whether a GPU is in confidential-compute mode. None of the NRAS v4 appraisal claims named it (RTX PRO 6000 Blackwell, 19 September 2026). On an H100 80GB HBM3 with the mode on (driver 595.71.05, inside a TDX guest), the certificate chain carried identity and a firmware measurement only, and no field of the signed report changed when the GPU ready state, the only confidential-compute control a guest can operate, was switched off. A second H100 of the same model with the mode off (driver 580.126.09) produced no attestation report and no attestation certificate chain at all. WCM therefore treats a GPU report that verifies against NVIDIA's device root and binds the challenge nonce as establishing that the device was in confidential-compute mode when it produced it, because a device without the mode was observed to produce nothing to verify. That rests on two H100s on two drivers. It is not documented by NVIDIA, and a confidential host that deliberately disables the GPU's mode was not tested. If NVIDIA documents the mode in signed evidence, or a verified report is observed from a device with the mode off, this rule changes to read that evidence. The property belongs to whichever device produced the report; a report relayed from another confidential GPU still verifies, which is why the GPU report is bound to the CPU quote by the challenge nonce. The captures are in the reference implementation's tests/fixtures/nvidia/cc-mode.

Failure paths:

Failure Default behavior
No attestation quote produced Hard fail. No manifest speaks to an unattested environment, no exceptions.
Quote does not carry the current challenge nonce, or the nonce is expired or reused Hard fail. Blocks a network adversary from replaying a previously valid quote to obtain a key.
Quote valid and fresh, but relayed onto an attacker-terminated channel (the attacker claims a transport key the quote does not vouch for) Hard fail on verification: REPORT_DATA binds the enclave's transport key, so a substituted key breaks it. Even a faithfully-relayed quote gains nothing, since the key is sealed to the enclave's transport key and the relay cannot open it (channel binding, above; CVE-2026-33697).
Quote fails hardware measurement check Hard fail. Key is never released.
Renewal attempt is inconclusive: the KBS is unreachable, or its response does not verify No verdict was reached, so custody is unchanged and the enclave may retry within the lease it already holds. The lease is not extended, so a partitioned enclave still stops at its existing deadline.
Renewal is denied by a verified signed decision (renewed: false) A verdict, not a transport error. New admission stops and the lease cannot be extended. Revocation-class reasons (revoked serving image, revoked attestation key, manifest no longer in force) end custody immediately; any other denial serves out the unextendable remainder, still bounded by the one cadence window.
Quote valid, but platform not in required_hw_platform Hard fail. This is a policy the builder set, not one the custodian can override on the customer's behalf.
Quote valid, but serving-image measurement not in required_serving_image.accepted_measurements (or past its retire_after) Hard fail. Key is never released. This stops the customer from swapping in a stack that could read weights out of memory, while the accepted set lets the builder roll a patched image without re-issuing every live manifest.
Serving-image measurement is status: revoked Hard fail, immediate, even if otherwise within a window. The emergency kill for one compromised image; propagates like a manifest revocation, no re-issuance of other live manifests.
A current image exists but the enclave presents a retiring one Refused under the prefer-current release rule. Prevents booting a deliberately-kept older-but-still-blessed stack after a security patch.
GPU attestation report absent, or its measurement not matching required_gpu_measurement, or not bound to the CVM report by the challenge nonce Hard fail. The GPU is a separate evidence chain; a valid CVM quote alone is insufficient (see composite verification, step 3).
GPU confidential-compute mode not established: the GPU report was not cryptographically verified, or the evidence states the mode off Hard fail unless required_gpu_measurement.require_cc_mode is explicitly false. A CC-capable GPU with the mode disabled passes every other GPU check and leaves decrypted weights readable in device memory. An adapter stating the mode on is not evidence of it, since no signed field carries the mode; only a verified report establishes it, under the assumption stated above.
Evidence the manifest requires verified, with no verifier configured for it Hard fail unless release_policy.require_evidence_verification is explicitly false. Without a verifier the release service could only trust the evidence's structured fields, which whoever produced the evidence controls.
Attestation cadence lapses without re-attestation Key is zeroized from inside the enclave, further inference is no longer authorized, and the teardown adapter is invoked to stop the serving worker. Not "suspended," gone. A fresh successful attestation re-releases a new key; there is nothing to reinstate. Ending authorization is enforced; the teardown itself is the deployment's adapter, run on the rules above, and a deployment with no adapter must disclose that it has none.
Revocation entry issued (default profile, builder+custodian joint signature) Hard fail, immediate, no grace period, no policy override.
Unilateral emergency revocation triggered by either party alone (default profile only) Hard fail, immediate. Access is suspended on the single signature without waiting for the other party's co-signature. Disabled under sovereign_profile.
Revocation under sovereign_profile Requires the quorum defined in the profile, including the sovereign signer. No single party, builder included, can revoke alone. The wipe-on-lapse path still applies independently of quorum.
Customer's infrastructure changes underlying hardware or region Manifest's enclave_id no longer matches. Treated as a new environment, requiring a fresh manifest issuance and fresh attestation, not an automatic transfer.

Wipe-on-lapse is the revocation floor, against an operator who cannot forge attestation. The two revocation paths below depend on a signal reaching the enclave, and a customer who has compromised the host can try to keep serving by partitioning the enclave from the key release service so no revocation ever arrives. Wipe-on-lapse removes that as an option for a semi-trusted operator: the enclave will not serve past its cadence window without a fresh successful attestation, and if that attestation does not happen, it zeroizes the key from its own memory. So against an operator who cannot forge attestation, the worst-case time from a decision to cut off weights to weights being unusable is bounded by the cadence window, whether or not any revocation signal gets through. This is what makes Principle 3 true against a hostile host rather than only a cooperative one, and it makes attestation_cadence a security parameter: a 24 hour cadence means a 24 hour worst-case exposure window, and a high-risk deployment should set it in minutes and accept that a network partition becomes an outage by design.

Two limits, both load-bearing. First, it assumes trusted time. Enforcing a cadence TTL requires a trusted monotonic clock inside the enclave; a host-privileged operator who can stall the enclave's perceived time never trips the deadline and serves indefinitely on a stale key. SEV-SNP does not give the guest trusted time by default, so the floor requires a named trusted-time source in the manifest (release_policy.trusted_time_source, section 3.1). This is now a resolved build decision rather than an open question: secure-tsc names a hardware-rooted monotonic clock in the TCB where the silicon provides it (the full floor holds), and lease-with-op-count-hybrid is the fallback for platforms without one, combining operation-count-anchored renewal for the serving case with a KBS-signed wall-clock lease for the idle case, at an explicitly weaker and clearly-marked guarantee. The requirement is that the source is named, not assumed; a deployment that names none-best-effort has disclosed that it has no floor (former open question 8.9; threat model TCB item on trusted time). Second, it does not hold against a hardware owner who can forge attestation. Such an owner re-attests every cadence with a fresh forged quote and never zeroizes, or simply uses the key it has already physically extracted. So the floor bounds exposure only in the semi-trusted posture; in the hostile-owner posture it provides no bound, and any real bound there must come from something the interposer cannot forge (open question 8.8), not from enclave-resident logic on adversary-owned hardware.

Unilateral emergency revocation (default profile only). Joint signature revocation assumes both parties can be reached and agree, which is a reasonable assumption for a planned wind down and a bad one for an active incident. In the default (non-sovereign) profile, either the builder or the custodian can trigger an immediate unilateral revocation on their own signature alone. Key access stops the moment that single signature is verified, no waiting on the other party. The revocation is provisional: within a fixed reconciliation window (24 hours, see open question 8.1), both parties review the incident and either confirm the revocation as permanent or, if it turns out to have been a false alarm, jointly reinstate access under a fresh manifest. The unilateral path exists specifically so that "can we reach each other fast enough" is never the bottleneck between a discovered compromise and weights actually going dark. This path is disabled under sovereign_profile; there, the quorum is the only fast path (and, per the floor's second limit above, wipe-on-lapse is not an independent backstop against a forging owner).

Multi-party policy co-governance and the sovereign profile. For deployments where more than one stakeholder needs to sign off (a regulator, the customer's own security team, and the builder, for example in a sovereign deployment), the release_policy object supports an additional_signers array requiring a quorum before the manifest is valid. The sovereign_profile extends that quorum to revocation, not just release: with it enabled, the sovereign signer is required for any revocation, so no single foreign party can dark a model running in the sovereign's jurisdiction. This is the mechanism that lets a regulated sovereign deployment satisfy "no single party unilaterally controls the release or the kill decision" without inventing a separate approval workflow outside the manifest. The cost is that the builder gives up its own-signature kill switch in exchange for the sovereign deal. Note that in this hostile-owner posture wipe-on-lapse does not provide an independent backstop, because the owner can forge attestation (the floor's second limit, and open question 8.8); the sovereign profile's revocation guarantee rests on the quorum and on mandatory physical hardening, not on the floor.

3.3 Layer 3: Runtime Custody & Extraction Defense

Once weights are live inside the enclave, custody is an ongoing obligation, not a one time check.

  • Kill switch: a revocation entry suspends key access for a weights_hash, and the enclave ends custody and runs the same teardown path as a lapse as soon as it receives the entry or, failing that, on its next cadence lapse. This is the same mechanism as Layer 2's revocation path, exercised at any point during the deployment's life, not only at re-attestation time. In the default profile either party can trigger it unilaterally; under sovereign_profile it needs the quorum. Either way the effective worst case is bounded by the cadence window through wipe-on-lapse, so "the customer partitioned the enclave so the revocation never arrived" does not buy the customer more than one cadence window of continued serving.
  • Extraction and distillation defense, and its honest limit: the enclave boundary enforces resource and rate ceilings on inference calls, and every call produces a signed, hash-chained audit receipt (reusing TRACE's receipt format rather than inventing a second one). Anomalous call patterns, high volume probing consistent with model stealing, are visible in the receipt stream without the custodian or the builder needing to see call content. What this does not fully solve is distillation by a customer whose legitimate production traffic is already high volume: a determined customer can train a student model from outputs generated entirely within its permitted rate envelope, and no ceiling that keeps production usable will stop that. Rate ceilings and receipts raise the cost and make gross theft visible; they do not make in-envelope distillation impossible, and this draft should not claim they do. Stronger distillation resistance (output watermarking, per-tenant response perturbation) is out of scope here and noted as follow up.
  • No raw weight software export path, and an honest limit against a physical operator: against every software adversary, the host OS, the hypervisor, a privileged operator with software access, and a custodian insider, the enclave design makes it structurally impossible, not merely against policy, for decrypted weights to be written to customer storage, copied to another process, or transmitted off the enclave, provided required_serving_image is builder-signed and measured so the customer cannot substitute a stack that dumps memory (section 3.1). That much is real and enforced in silicon. The honest limit: current confidential-GPU hardware protects GPU-resident weights by access-control firewalling, not memory encryption, so weights sit in plaintext in HBM during compute, and NVIDIA explicitly excludes sophisticated physical attacks (decapsulation, on-package probing) from its threat model. A determined operator who owns the hardware is therefore not stopped by the silicon. Against that adversary WCM does not claim structural impossibility; it raises the cost and skill bar, makes extraction detectable and attributable through attestation and receipts, limits the value window through wipe-on-lapse and revocation, backs it with the manifest's legal terms, and offers the optional physical-hardening tier. The full scope statement is section 3.6. A software-policy violation here is unrecoverable the moment it happens, which is why the software path is closed in silicon rather than in policy.
  • Cost and resource governance: rate ceilings enforced at the serving boundary double as a defense against resource exhaustion and as an early signal for extraction attempts, reusing the same enforcement point as the ceiling above.

3.4 Layer 4: Derivative Lineage & Compliance Mapping

If the customer is permitted to fine tune inside the enclave (per permitted_derivatives in Layer 1), the resulting derivative weights need their own chain of custody back to the original manifest.

  • Derivative manifests: a fine tune produces a new weights_hash with a derived_from field pointing at the parent manifest. The builder's IP claim over the base weights does not disappear because a derivative exists; rights_holder on the derivative manifest reflects whatever the deployment agreement specifies, commonly a split between builder IP in the base and customer IP in the fine tune data. A derivative manifest carries these two fields on top of the Layer 1 fields of section 3.1, and both are covered by the joint signature (they are not appended post-signing):
{
  "manifest_version": "0.1",
  "weights_hash": "sha256:9f2c...derivative...",
  "derived_from": "sha256:4a1c...parent...",
  "rights_holder": {
    "base": "example-builder",
    "derivative": "example-customer"
  },
  "builder": { "identity": "example-builder", "signing_key": "ed25519:..." },
  "release_terms": { "...": "as section 3.1" },
  "release_policy": { "...": "as section 3.1" },
  "custody": { "...": "as section 3.1" },
  "signatures": [ "...builder + custodian joint..." ]
}

Whether a derivative may be created at all is governed by the parent's release_terms. Alongside the freeform permitted_derivatives legal text, a machine-checkable derivatives field (none | fine-tune-only | unrestricted) lets a verifier resolve the derived_from chain to its root and refuse a derivative whose parent set none. permitted_derivatives remains the human/legal expression; derivatives is the part a tool can enforce. A root manifest omits derived_from.

  • Standards home, IETF SCITT: the manifest-plus-signed-receipts design is not a new standard; it is an application of SCITT (Supply Chain Integrity, Transparency, and Trust). WCM's constructs map onto SCITT roles directly, which is the intended standardization path rather than a bespoke format:
WCM construct SCITT role
Manifest (Layer 1), signed by builder + custodian Signed Statement, from its Issuers
Transparency log (section 3.7) Transparency Service (append-only, signed tree heads)
Inclusion proof bound to re-attestation SCITT Receipt
Revocation / measurement-set change entries Signed Statements registered against the same log
Monitors, including a sovereign's accreditation body Auditors / Monitors
  • Secondary framework crosswalk (for auditors, not the primary claim): for teams that grade in existing frameworks: the attestation evidence is RATS (RFC 9334) / EAT (RFC 9711); receipts are SLSA-style provenance applied to inference custody rather than build; the manifest doubles as an ML-BOM entry and maps to NIST AI RMF "Map"/"Govern." These are a crosswalk, not five separate conformance claims. Positioning for the AI-security community goes through CoSAI; the technical standardization goes through SCITT.

3.5 Self-Custody: The Attested Key Release Service

Implementation status: this section specifies the required deployment, not a capability delivered by the reference Docker server. Customer control of an ordinary KBS/Trustee, including its keys or verifier configuration, is unsupported for custody against that customer. The owner must verify KBS code and all security-relevant configuration before provisioning keys over a channel bound to that attested instance. Host-mounted plaintext secrets, internal admin separation, or an external KMS that trusts customer-controlled decisions do not meet that requirement. The reference server does not implement this provisioning flow; custody.kbs_image alone does not enforce it. See the deployment checklist and acceptance evidence.

The default deployment has a hosted custodian operating the key release service (KBS). A sovereign customer will often refuse a third party, even a trusted one, sitting permanently in the release path. The naive answer, "let the customer run the KBS," breaks the whole model: a customer who controls the KBS can release the key to itself and ignore the manifest. The builder would be trusting the customer's word, which is exactly the thing this architecture exists to replace.

The design requires the KBS to run inside an attested enclave in every deployment, operator-hosted included. Its release logic (custody.kbs_image) and security-relevant configuration must be builder-verified before keys are provisioned into that instance. Protecting only the executable measurement leaves mutable configuration and key-loading paths exposed to the insider (threat model ADV-3). Self-custody changes who hosts this protected boundary; it does not grant that host authority to override it.

The reference design for self-custody applies the same primitive one level up, with the customer as the operator: the customer runs the attested KBS enclave itself.

  • Recursion that terminates at the builder's root of trust: the KBS enclave image, the release logic and policy engine, is signed by the builder and has a known measurement. The builder verifies the KBS enclave's attestation quote the same way the KBS verifies the inference enclave's quote. So the chain is: the builder trusts hardware attestation, verifies the KBS measurement against a value it signed, and the KBS in turn verifies the inference enclave. It bottoms out at the hardware root of trust, not at anyone's promise. Two attested enclaves, both measured up to the builder. This recursion assumes the KBS quote is itself unforgeable, which holds against a semi-trusted self-custodian but not against a hardware-owning sovereign, who can forge its own KBS quote (section 3.6). That is why sovereign self-custody carries the two extra conditions below.
  • What the customer gets: it hosts the KBS on its own hardware, in its own jurisdiction. The hosted operator is not a permanent party in the release path. Its role narrows to authoring the reference KBS image and, optionally, co-signing the manifest, not running the service.
  • What the customer cannot do (semi-trusted case): it cannot alter the measured release logic, cannot release the key against manifest policy, and cannot self-release, because any of those changes the KBS measurement and fails the builder's verification, provided the self-custodian cannot forge the KBS quote. A semi-trusted self-custodian cannot; a hardware-owning sovereign can (section 3.6), which is exactly why the sovereign case carries the extra conditions below. This is the same verify-by-measurement-not-authorship bargain the serving image makes in section 3.1, applied to the release path.
  • Single key for semi-trusted, threshold required for sovereign: for a semi-trusted self-custodian, v1 is a single key: the attested KBS enclave is the sole release authority, and the residual is a bug in the measured, builder-signed KBS logic, mitigated by keeping that logic small and revocable. For a sovereign (hostile-owner) self-custodian, single-key is not sound: that owner forges its own KBS quote and self-releases, the attack this section otherwise calls impossible. Sovereign self-custody therefore requires two things that are optional for the semi-trusted case: the physical_hardening tier on the KBS host, and threshold split-key release (no single party, the customer included, can assemble the key alone). Threshold is a prerequisite for sovereign self-custody, not the later v2 hardening it remains for the semi-trusted case, because it is the only design where one forged quote is insufficient to release.
  • The KBS is the stable anchor, not the flakiest link: the KBS re-attests on its own cadence, set deliberately longer and more conservative than the inference enclaves it feeds (illustratively 6h for the KBS against 15m for inference), so its normal re-attestation blips do not cascade into the fleet that depends on it. A degraded KBS still loses its own trust standing, and the inference enclaves still enforce their own short cadence and wipe-on-lapse independently, so the anchor being slower does not weaken the floor. See the cadence coupling note in section 8 for the reasoning.
  • Composes with the sovereign profile: an attested self-custody KBS plus sovereign_profile, with threshold and physical hardening per above, gives the sovereign the properties it actually wants: no foreign party operates its release path, no single foreign party can dark the model, and no single forged quote releases the key. As in section 3.2, wipe-on-lapse is not an independent floor in this hostile-owner posture; the real bound comes from threshold, physical hardening, and the transparency log (3.7), not from enclave-resident timing on adversary-owned hardware.

The KBS enclave image, and its threat model. Self-custody is "offered," not merely "described," only once the thing the builder signs and measures is pinned down. The KBS enclave image (custody.kbs_image) contains, and contains only, the release path:

  • the composite quote verifier (CPU and GPU: cert-chain to the vendor roots, report-signature check, nonce binding);
  • the release-policy engine that evaluates release_policy against the presented evidence (platform, required_assurance_tier, the required_serving_image measurement, memory_fingerprint_challenge, attestation_revocation_check);
  • the single-use challenge/nonce service that gives replay protection;
  • the key broker: it holds the wrapped key, or under sovereign_profile the threshold combiner that reconstructs the key from a quorum of shares inside the enclave, releases only on a full policy pass, and never persists plaintext key material outside enclave memory;
  • the transparency-log client that verifies the manifest's inclusion proof and binds re-attestation to a logged, in-force manifest (section 3.7);
  • the revocation checker (live attestation_revocation_check; a revoked measurement hard-fails).

Excluded on purpose, to keep the trusted computing base small and auditable: no shell or interactive runtime, no network egress beyond the vendor certificate/CRL endpoints and the transparency log, no persistence of plaintext keys, and no customer-authored code. The image is built reproducibly, its measurement is what custody.kbs_image pins, and it re-attests on kbs_attestation_cadence.

Threat model. Against every software adversary (the host OS, the hypervisor, a software-privileged operator, a custodian insider) and against a customer self-custodian, the release logic cannot be altered without changing the measurement and failing attestation: the KBS behaves as measured or not at all. It does not defend against a hardware-owning sovereign who forges its own KBS quote with a physically-extracted key (open question 8.8), which is exactly why sovereign self-custody adds threshold release and physical hardening above. The residual is a bug in the measured release logic itself, held down by the minimal TCB above, a reproducible build an independent auditor can check against certified source (section 8.3), and the ability to revoke a bad KBS measurement. The builder verifies the KBS measurement and the KBS in turn verifies the inference enclave, so the chain terminates at the hardware root of trust, not at anyone's word. This closes open question 8.2.

Two lighter alternatives were considered and rejected as standalone answers. An operator-authored appliance the customer hosts keeps that operator as the logical release authority, so it does not actually satisfy the no-third-party-in-path requirement; it is at most a pragmatic interim offering before the attested KBS is built. A reproducibly-built KBS with a tamper-evident audit log is detect-not-prevent (a forked binary can still self-release, you just learn about it afterward), which contradicts Principle 1, so it is useful only as an audit supplement layered on top of attestation, never on its own.

3.6 Guarantee Scope: What the Silicon Does and Does Not Cover

This section states plainly what the hardware WCM runs on actually guarantees, so no downstream reader over-reads the custody claim. It is grounded in an adversarial assessment of NVIDIA Confidential Computing (H100/H200/Blackwell) and closes former open question 8.4.

Cryptographic custody against a remote software adversary, with a load-bearing hypervisor caveat. A host OS, a remote attacker, a software-privileged operator without hypervisor control, and a custodian insider cannot read the decryption key or the decrypted weights. This rests on SEV-SNP/TDX for the CPU CVM, NVIDIA CC firewalling for the GPU, an attested serving image, and an encrypted, replay-protected CPU-to-GPU channel (AES-GCM-256). The caveat: a malicious hypervisor can extract keys via ciphertext side channels (CipherLeaks, Heracles) with no physical access, because full-DRAM memory encryption is deterministic and unauthenticated. So the claim holds against a remote software adversary by construction, but against a hypervisor-privileged operator it holds only when AMD SEV-SNP ciphertext-hiding (or an equivalent) is enabled and required in the manifest. The common commercial case, with that mitigation in place, is a managed or enterprise operator who will not physically attack the hardware.

Not custody-grade against a physical operator who owns the hardware. NVIDIA CC protects GPU memory by access-control firewalling of a Compute Protected Region, not by encrypting HBM, so weights are plaintext in HBM during compute, and NVIDIA scopes sophisticated physical attacks out of its threat model. Confidentiality against a physical adversary rests on the assumption that on-package HBM resists common interposer tools, which is a design assumption, not a proof. For the on-prem and sovereign deployments WCM targets, where the customer owns the box, this is the adversary that matters most, and the silicon does not stop them.

The cheaper GPU attack is not on the GPU. The paragraph above prices the GPU residual at decapsulation or on-package probing, which is sophisticated-lab effort. That is the wrong floor. NVIDIA's GPU attestation does not identify the guest it is serving ("the attestation does not identify what the GPU is running", TEE.fail section 8.3), so an adversary who has already broken the CPU TEE need not touch the GPU at all: they relay the attestation call to a genuine confidential GPU elsewhere. TEE.fail demonstrated exactly this with a local RTX 3060 forwarding to an external H100-equipped server, passing both TDX and CC attestation, and notes the economics (an H100 is north of $20,000 against sub-$2.50/hour spot, so "a provider could multiplex a single H100 to provide attestations for hundreds of instances"). No NVIDIA key was extracted; this is a binding failure, not a cryptographic one.

WCM does not inherit that particular gap, and the reason is worth stating rather than leaving implicit: composite verification binds the GPU report to the CPU quote through the single KBS-issued nonce (section 3.2), so a report echoing a nonce from another session or another enclave fails the gate. That defends the relay shape specifically. It does not survive the CPU TEE itself being broken (T1.7), because an adversary holding the CPU attestation key controls both halves of the composite.

Hardware-reported platform state, and the one bit that is actually checkable. Two bits of the SEV-SNP PLATFORM_INFO field are the only statements about physical platform state that any production attestation report carries today, on any vendor. WCM now reads both and lets a manifest require them through platform_integrity (section 3.1).

  • ALIAS_CHECK_COMPLETE (bit 5) is AMD's BadRAM mitigation (CVE-2024-21944, AMD-SB-3015): the Secure Boot loader measures DRAM's response to address bits at boot and sets the bit only if no aliasing addresses were found. Requiring it raises the floor from "any ~$10 SPD spoof" to "an interposer". It does not close the class, because a boot-time scan is a time-of-check/time-of-use control: Battering RAM passes the command and address lines through untouched during POST so the check reports success, then enables aliasing at runtime. Treat it as raising cost, not as custody.
  • CIPHERTEXT_HIDING_EN (bit 4) reports whether the host's read path to guest private memory returns constant values instead of ciphertext. This is the precondition this section attaches to the semi-trusted-operator claim, so it should be required in the manifest rather than assumed.

A measured correction, and it is uncomfortable. Both SEV-SNP platforms WCM has captured report PLATFORM_INFO = 0x25: ALIAS_CHECK_COMPLETE set, and CIPHERTEXT_HIDING_EN clear.

Capture Machine CPU Report version PLATFORM_INFO Ciphertext hiding
Azure SEV-SNP CVM (vTPM paravisor) - - 3 0x25 off
GCP N2D, us-central1-a (2026-09-11) n2d-standard-4 AMD EPYC 7B13 (Milan) 5 0x25 off

Neither platform satisfies the precondition stated two paragraphs above for WCM's own custody claim, and until this release nothing in the SDK read the field that would have said so. The honest reading is that the cryptographic-custody claim against a hypervisor-privileged operator is not currently met on either, and a deployment that needs it must require bit 4 and verify a platform that sets it. This is a checkable property rather than a matter of posture: platform_integrity.ciphertext_hiding: required denies release on a platform that does not report it.

On GCP the gap is structural, not a configuration choice. Google documents SEV-SNP as available on N2D with AMD EPYC Milan only; C3D (Genoa) and C4D (Turin) offer plain AMD SEV, not SEV-SNP, and the API rejects SEV_SNP on both. Ciphertext hiding requires EPYC 9005 (Turin), so no GCP SEV-SNP platform can set bit 4 today. A deployment that must have it needs a cloud and SKU that pairs Turin silicon with SEV-SNP, and the manifest requirement is the mechanism that stops a Milan platform being accepted by mistake.

Note also what ciphertext hiding does and does not buy, because the two halves are routinely blurred. Enabled, it fully stops the software ciphertext side-channel class (the Heracles authors state it "fully stops Heracles as well as software-based ciphertext attacks in general"). It does nothing against a bus interposer: TEE.fail extracted an ECDSA private key from a SEV-SNP CVM on an EPYC 9015 with ciphertext hiding verified enabled, and states plainly that it "does not fix issues with deterministic encryption nor does it prevent physical bus interposition".

What WCM offers against the physical operator, in order:

  1. Cost: extraction requires decapsulation or on-package probing, sophisticated-lab or nation-state effort, not a curious admin with software access.
  2. Detection and attribution: attestation state and hash-chained receipts make tampering and anomalous use visible and attributable.
  3. Containment: wipe-on-lapse and revocation stop future release and cap continued in-enclave serving. They do not reach material already extracted: a copied key or weights file remains useful indefinitely (section 3.3). That residual is carried by the other pillars, cost, detection and attribution, and legal recourse, not by containment.
  4. Legal recourse: the manifest is the machine-checkable expression of contract terms, so physical extraction is a provable breach.
  5. Physical hardening (mandatory in the hostile-owner posture): the physical_hardening tier requires tamper-evident or tamper-responsive enclosure, physical access control, and supply-chain custody, pushing the residual onto operational controls the deployment must meet and be audited against.

The correction, stated honestly. This is not a defeat of the architecture, it is a correction to the claim. Everything WCM does above the silicon (revocation, wipe-on-lapse, receipts, legal binding, physical hardening) matters more given the silicon floor is software-grade, not less. The dishonest version of this document would say "physically impossible." The honest version uses two names for two different guarantees, never blended: cryptographic custody against software theft in the semi-trusted posture, and accountability-grade protection, cost plus detection plus containment plus recourse, backed by mandatory hardening, against a hardware owner.

Two dependencies this assessment also surfaced:

  • Attestation phone-home, on both silicon vendors: NVIDIA attestation depends on NVIDIA-signed RIM golden measurements and, by default, the NVIDIA-operated NRAS service. The AMD side carries the same shape: SEV-SNP attestation depends on AMD's Key Distribution Service (KDS) for VCEK certificate retrieval. Both are cacheable for air-gapped use, but neither should be an unstated runtime dependency. A fully air-gapped deployment must pre-stage and refresh both, with an explicit staleness and revocation-freshness policy; treat it as a deployment requirement, not an afterthought.
  • CPU-CVM physical surface (assessed, and worse than the GPU case): physical memory-bus attacks defeat SEV-SNP and TDX today. TEE.fail (2025, tee.fail) is a sub-$1000 DDR5 bus interposer built from hand-soldered commodity parts; on Intel TDX/SGX it forges attestation quotes that verify at the highest trust level, and on AMD SEV-SNP its demonstrated result is key and confidential-data extraction from live memory. BadRAM (CVE-2024-21944, IEEE S&P 2025) is the one that forges SEV-SNP attestation, for about $10 plus one-time SPD access. The root cause is structural, deterministic unauthenticated full-DRAM encryption without freshness, so it is not fixable without new silicon. Two consequences for WCM, both severe against the operator-owns-the-box adversary: (1) the decryption key in the CPU CVM is physically extractable, more cheaply than the GPU weights; (2) attestation itself can be forged, which undermines the anchor primitive, attestation-gated release (Principle 2), not just confidentiality. Software-only variants (CipherLeaks, USENIX Security 2021; Heracles, CCS 2025) extract keys via ciphertext side channels from a malicious hypervisor with no physical access. This reaches the foundation of the scheme, so the positioning response is decisive, and it is resolved next.

Positioning (resolved), custody is scoped to the operator-trust model. WCM makes its custody claim against two clearly separated operator postures, not one, and never blends them:

  • Semi-trusted operator (default): Operator-hosted, reputable-cloud, or contract-bound enterprise deployments, where a bus-interposer attack on the operator's own datacenter is impractical, detectable, attributable, and a provable breach. Here the silicon guarantee holds in practice, and WCM is cryptographic-custody-grade against every adversary short of the operator physically attacking hardware they control, subject to the one caveat above (a malicious hypervisor requires ciphertext-hiding enabled). This is the default posture and the near-term commercial surface. In RAND's Securing AI Model Weights terms it is the recommended confidential-computing measure, holding against the OC1-OC3 attacker tiers; it is one control in a weight-security posture, not a whole "security level."
  • Hostile-owner operator (sovereign or on-prem bare metal), physical hardening mandatory: where the operator owns the bare metal and is themselves the adversary (RAND OC4-OC5), the silicon does not hold, so this posture is supported only with the physical_hardening tier required, not optional: tamper-responsive memory enclosure that zeroizes on bus tamper, locked SPD, physical access control, and supply-chain custody. Hardening is the only concrete technical defense against the TEE.fail / BadRAM class, and even with it the honest claim is accountability-grade, raise-cost plus detect plus contain plus legal, backed by hardening, not cryptographic custody. A hostile-owner deployment without the hardening tier is not offered.

The claim WCM never makes is silicon-enforced custody against a bare-metal owner with no physical hardening. That configuration is out of scope, deliberately.

Forged attestation, split into what is closed and what stays open. The forged-attestation concern (open question 8.8) conflated two attacks with different shapes, and separating them is the resolution, not a promise of more research. The first is measurement forgery with the key intact: a BadRAM-class attack aliases DRAM through a misreported SPD size so a measurement reads clean while the guest runs from aliased addresses, and the signing key never leaves the chip. This one is detectable, because aliased memory produces address collisions a genuine full-size DRAM installation cannot, so a second evidence type alongside the vendor quote closes it. The memory_fingerprint_challenge field (section 3.1) is that evidence: the KBS sends random values, the enclave writes them across its full declared DRAM range and reads them back, and a hash of the readback pattern goes into the attestation response; collisions in the pattern indicate aliasing. It is a WCM-level addition, not part of any vendor's stock flow, required in the hostile-owner posture and optional in the semi-trusted default. The second attack is key extraction: a TEE.fail-class interposer physically lifts the attestation signing key, after which it can sign a fully valid quote for a fabricated environment, and no verification logic at the gate can tell that quote from a real one because cryptographically it is real. This half is not closed, and the spec says so plainly. Its compensating controls, now tied explicitly to 8.8 rather than scattered: a mandatory attestation_revocation_check (live-per-release, short cache age) on the attestation-key certificate (AMD VCEK via KDS, NVIDIA equivalent), so a revoked key is caught quickly, subject to the measured limits in the paragraph below; vendor-side short-lived certs that narrow a stolen key's value, an inherited dependency WCM does not itself enforce; mandatory physical hardening in the hostile-owner posture, which is prevention not detection here (the tamper-responsive enclosure has to stop the interposer attaching, because once it has attached and extracted the key the gate has already lost); and fleet-level behavioral anomaly monitoring, a real operational signal that lives in the custodian's monitoring stack, not in the manifest's logic, and should not be oversold as part of the protocol. So 8.8 resolves into one closed sub-problem (measurement forgery) and one honestly-open sub-problem (key extraction) with named compensating controls, which is a decision the design can build against rather than an unbounded research item.

How much attestation_revocation_check actually buys, measured. The control is specified as though revocation were a working lifecycle mechanism on both vendors. It is weaker than that, and the gap is asymmetric, so a deployment should not treat a passing revocation check as evidence that a compromised device would have been caught.

  • NVIDIA: the offline path is inert, and OCSP is the only live control. Every certificate in the GH100 device identity chain, verified against this repo's own captured H100 chain (python/tests/fixtures/gpu_h100_attestation.json), carries notAfter = 9999-12-31 23:59:59 GMT, root included. The published CRLs are empty and refresh on a two-year cycle: crl/l1-root.crl last updated 2026-02-06 with next update 2028-02-06, crl/l2-gh100.crl last updated 2026-01-16 with next update 2028-01-16, both with zero revoked entries (fetched 2026-09-11). So a verifier that falls back to the CRL learns nothing, and cannot tell "not revoked" from "this list is eighteen months stale". Nonce-bound OCSP against ocsp.ndis.nvidia.com is the only control with real freshness, and a WCM deployment MUST treat OCSP unreachability as a failure rather than falling back to the CRL.
  • AMD: the CRL cannot name a chip even in principle. VCEK certificates are minted per request with serial number zero, so there is no identifier for a CRL entry to carry; de-facto revocation is TCB versioning, which is fleet-wide and firmware-scoped rather than per-device.
  • The operator cannot invoke any of it. On all three vendors the decision to revoke sits with the vendor. A customer who knows a specific host was physically opened has no documented path to have that device's attestation key stopped. This is the practical reason physical hardening is prevention rather than detection in the hostile-owner posture: there is no containment step behind it to fall back on.

3.7 Transparency: Making Equivocation and Suppressed Revocations Detectable

Joint signatures prove who authorized a manifest; they do not prove there is only one manifest. A custodian, or a coerced builder, could issue two differently-signed manifests for the same weights_hash (say, sovereign_profile on for one audience and off for another), and no party could detect that the other exists. A revocation can likewise be silently withheld: wipe-on-lapse contains a suppressed revocation but never makes it detectable. This is the equivocation problem Certificate Transparency solved for the web PKI, and the CA analogy in section 3.1 inherits the obligation to solve it here.

The mechanism. Every manifest, every revocation, and every change to an accepted_measurements set is registered on an append-only transparency log with signed tree heads, inclusion proofs, and consistency proofs (IETF SCITT, or a Rekor-style log with independent witnesses and monitors). Two bindings make it load-bearing rather than decorative:

  • Re-attestation binds to an inclusion proof: the enclave renews only against the specific manifest that is provably logged and in force; a manifest absent from the log, or superseded, does not verify. This turns equivocation into a detectable split-view.
  • Revocations publish to the same log: a suppressed revocation is then a missing expected entry a monitor can flag, not a silent non-event.

Where it is mandatory. Under sovereign_profile the transparency log is required: a sovereign that cannot independently confirm it is shown the same manifest as everyone else has no basis to trust a foreign custodian, and its own accreditation body should be able to run a monitor. In the default profile it is recommended, not mandatory, to keep the adoption bar low.

This does not close the open key-extraction half of the forged-attestation problem (open question 8.8) and must not be read as doing so: a hardware owner signing a quote with a physically-extracted key is a different failure than a custodian equivocating on a manifest. Transparency makes the authority layer honest; it does not make adversary-owned silicon honest.

3.8 Multi-Stage BYOM: Sequential Re-Custody

Symmetric BYOM (section 3.1, deployment_model: byom-symmetric) collapses the builder and custodian onto one organization for one model. The multi-stage case is different: a model moves through several parties' environments in sequence, and each stage re-custodies. A base model is fine-tuned by party A inside A's enclave, adapted further by party B, then deployed by C. Each hand-off is a new custody boundary, and the question is how a downstream stage releases a key without letting an unattested or over-privileged intermediate slip into the chain.

This is specified using the primitives already in this document, with no new manifest fields:

  • Chained manifests. Each stage runs inside an attested enclave and issues its own Layer 1 manifest for the weights it produces, with derived_from pointing at the incoming stage's weights_hash (section 3.4). The lineage chain is the pipeline.
  • Release gated on the upstream. A stage's KBS releases the decryption key only if the incoming manifest verifies, its lineage resolves to a trusted root, and every upstream manifest in the chain is present in the transparency log with a valid inclusion proof (section 3.7). An intermediate that is not logged does not release, so no party can quietly insert an unattested stage.
  • Monotone rights. release_terms narrow down the chain and never widen. A stage may restrict the license, the permitted_derivatives / derivatives policy, the jurisdiction, or the permitted environments it inherited, but a verifier rejects any derivative manifest that grants a right its parent withheld: a fine-tune-only parent cannot yield an unrestricted child. Rights flow downhill only.
  • Revocation cascades. Because re-attestation binds to the logged chain, revoking an upstream weights_hash invalidates every descendant. The next cadence lapse or re-attestation of a downstream stage fails its upstream-logged check, so the kill switch propagates along the lineage with no separate mechanism.

What this deliberately does not solve is broad multi-party policy co-governance: arbitrary approval graphs across many stakeholders, beyond this sequential chain and the sovereign_profile quorum, remain follow-up. The sequential re-custody protocol above builds only on the shipped lineage (section 3.4) and transparency-log (section 3.7) primitives; enforcing the monotone-rights and cascade checks in the reference SDK is a tracked follow-up, specified here but not yet shipped.

3.9 Provenance Interop: Composing with Model Signing

WCM is the custody-and-release layer. It is not a model-signing scheme and it does not re-sign the model files. Where a builder already publishes a provenance signature over the weights, in particular an OpenSSF Model Signing (OMS) signature produced by a compatible implementation, a WCM manifest references it rather than duplicating it.

An optional provenance object carries that reference under the joint signature:

"provenance": {
  "model_signing": {
    "method": "openssf-model-signing",
    "signed_digest": "sha256:<digest WCM derives from the model-signing manifest>",
    "transparency": "rekor:<log index or locator>",
    "signer": "<the model-signing identity, if disclosed>"
  }
}

Because provenance is in the signed field set, the builder and custodian commit to the provenance pointer at issuance and it cannot be swapped afterward. Verification is two-sided:

  • Layer 1 (verify_manifest) records the reference as a non-blocking note; it does not fetch anything.
  • Provenance (verify_provenance) cryptographically checks the referenced signature: it verifies the OpenSSF model-signing signature over the model files and re-derives signed_digest from those files, so a manifest cannot point at a signature for a different artifact.

This positions WCM as a complement to the signing layer, not a competitor: model-signing establishes what artifact this is and who signed it; WCM governs whether the key releases, into which enclave, under what terms, and for how long. Binding WCM's own weights_hash to the same physical bytes is the deploying party's step at ingest; the two digests are computed differently and are not interchangeable.


4. Relationship to Adjacent Work

Naming. This document is the Weight Custody Manifest: it governs weight release and custody, not model identity, so the name says that. The "Model *" naming space (for example a companion model-passport specification) is left to the agentrust-io teams, with no dependency on this document.

Relationship to a model-passport specification. A model passport answers "what is this model and is it safe to call." This document's manifest answers "who is allowed to hold a decryption key for this model and under what proof." They are complementary, not competitors: a passport could reference a Weight Custody Manifest as one of its attested inputs. WCM is open-core (next paragraph), so its spec layer is intended to sit alongside the other agentrust-io open specs, not opposite them.

Open-core, deliberately. A custody guarantee that a frontier lab cannot audit is not trustworthy. A builder and a sovereign must be able to read exactly what is and is not claimed (section 3.6), and the 8.3 posture (reproducible builds plus independent third-party audit, trust the auditor not the vendor's word) cannot coexist with a secret spec. WCM is therefore open-core:

  • Open (destined for agentrust-io): the protocol and manifest schema, the attestation and revocation semantics, the threat model, and the reproducibly-built reference KBS image that section 8.3 already requires to be independently auditable.
  • Left to implementers: an operated custodian service and its key-release operation, gateway integration, and enclave engineering on confidential-compute silicon.

The open layer is the protocol; the value of an implementation lies in operating a trustworthy attested custodian and in the quality of the enclave implementation, not in keeping the format secret. This mirrors the rest of the family (TRACE, cMCP, Agent Manifest, cA2A): open spec, independent implementations. Publication is not gated on closing open question 8.8. The specification is published openly, for review and comment and pre-1.0, because an auditable format put in front of scrutiny is worth more than one withheld pending a silicon fix, and because its one remaining open limit, the key-extraction half of 8.8 (section 3.6), bites only against a hardware owner outside the operator-trust model WCM targets. That adversary is one a builder self-selects against at deal time: a lab does not knowingly hand weights to a party it expects to lift them out of the silicon. So WCM addresses the semi-trusted operator by construction and the hostile owner by accountability and physical hardening, discloses the residual in full rather than hiding it, and leads with that limit instead of treating it as a reason to withhold the document. WCM does not claim to have closed the key-extraction half; the durable fix is extraction-resistant silicon, pursued on the CC-vendor roadmap.

Relationship to TRACE and cMCP. Layer 3's audit receipt format reuses TRACE's hash chained receipt design rather than inventing a second one. Layer 2's attestation gated key release is the same enclave and attestation infrastructure cMCP already runs for the customer facing gateway, exercised in the opposite direction. This document is not a new product surface; it is the second face of infrastructure a confidential-computing operator already runs.


5. Worked Example: End-to-End

A frontier lab (referred to here generically as "the builder") is deploying a model into a customer's confidential environment. The primary walk-through is the default profile. The sovereign delta follows.

5.1 Default profile

  1. Manifest issuance: the builder signs a Layer 1 manifest for the specific fine tune being deployed: weights_hash, release_terms matching the signed deployment agreement, required_assurance_tier set to hardware attested, required_serving_image set to the builder's signed serving stack, revocation_authority joint, attestation_cadence at the 24 hour default. The custodian co-signs.
  2. Enclave provisioning: the customer's confidential environment boots, produces its hardware attestation quote, and requests key release against the manifest's weights_hash.
  3. Key release: the custodian's key release service verifies the quote against the manifest's policy, including that the running serving image is the builder-signed one. It passes. The decryption key is released directly into the attested enclave memory, never touching customer visible storage or the custodian's own operational staff.
  4. Normal operation: inference proceeds. Every call produces a signed audit receipt. On the 24 hour cadence the enclave re-attests automatically and access continues; if any re-attestation failed, the enclave would zeroize the key on its own within that window.
  5. Something goes wrong: a security review finds a misconfiguration that could allow host level access to enclave memory under specific conditions. The builder does not wait to reach the custodian for a joint signature. It triggers a unilateral emergency revocation against the weights_hash on its own signature.
  6. Propagation, with a floor underneath it: key access is cut the moment that single signature verifies. If the compromised host tries to buy time by partitioning the enclave so the revocation never lands, it gains at most one cadence window: the key zeroizes on the next failed re-attestation regardless. Within the 24 hour reconciliation window, the builder and the custodian jointly confirm the revocation as permanent.
  7. Recovery: the misconfiguration is fixed, the environment is re-attested from scratch, and a new manifest is issued referencing the revoked one for audit continuity. The prior key grant does not carry forward, matching Layer 2's design.

5.2 Sovereign delta

Same flow, three changes. The rest is identical.

  • Issuance: sovereign_profile.enabled is true, with the sovereign's security team as a required quorum signer. attestation_cadence is set short, worked here at 1 hour, because in this profile the cadence is the revocation floor and the fast unilateral path is gone.
  • Provisioning: before allowing the enclave to come up, the sovereign's security team reads the required_serving_image measurement out of the manifest and confirms it matches the builder-disclosed stack. It cannot author that code, but it can verify the measurement and refuse the deployment. This is the whole of the sovereign's leverage over the runtime, and it is deliberately just verify-and-refuse, not authorship (section 3.1).
  • Revocation: step 5 changes, the builder cannot dark the model on its own signature. It raises the incident and the quorum (builder, custodian, sovereign security team) assembles to sign. The floor in step 6 is unchanged and matters more here: even though the quorum is slower to assemble than a single signature, the 1 hour cadence caps worst-case exposure regardless of how long the quorum takes.

6. What Weight Custody Manifest Deliberately Does Not Do

  • It does not evaluate model quality or capability. A manifest describes custody terms, not whether the model is good at its job.
  • It is not a federated, host agnostic protocol. Unlike a passport-style protocol, it assumes a custodian and enforcement point, with an operator-hosted custodian as the default, and room for customer self-custody where the deployment requires it. That default is deliberate, not an oversight.
  • It does not replace the deployment agreement's legal terms. The manifest is the machine checkable expression of terms legal has already negotiated, not a substitute for that negotiation.
  • It handles BYOM in two forms and stops short of a third. Symmetric BYOM (deployment_model: byom-symmetric, section 3.1) is a first-class, verifier-recognized posture; multi-stage sequential re-custody (a model passing through several parties' environments in turn) is specified as a protocol over the lineage and transparency-log primitives (section 3.8). What remains out of scope is broad multi-party policy co-governance, arbitrary approval graphs across many stakeholders beyond the sequential chain and the sovereign_profile quorum. That is the co-governance work flagged in resolved decision 7.

7. Resolved Design Decisions

  1. Naming: this document is the Weight Custody Manifest, renamed from "Model Manifest" in v0.2 because it governs release and custody, not model identity. The "Model *" naming space is left to the agentrust-io teams with no dependency on this document. Section 4.
  2. Runtime control (the crux): the party that can read decrypted weights is the party that signs the in-enclave serving stack. In this architecture that party is the builder: required_serving_image is builder-signed, and the key decrypts only under that measured stack. The customer, sovereign included, runs builder-signed code and verifies it by measurement rather than authoring it. This is what lets "no raw weight export path" be a real property instead of a promise. Section 3.1, 3.3.
  3. Custodian exclusivity: an operator-hosted custodian is the default, not the only possible one. Customer self-custody of the key release service is achieved by running the KBS inside its own attested enclave with a builder-verified measurement (section 3.5), which is what lets the hosted operator leave the runtime release path without the builder having to trust the customer's word. Note this is separate from runtime control: even a self-custody customer still runs the builder-signed serving image. Sections 3.1, 3.5, section 2. Detail still open, question 8.2.
  4. Buildability and the GPU reality (assessed): Layer 2 is buildable today on the cMCP and enclave stack. NVIDIA CC maturity, precisely: single-GPU CC is GA on Hopper (H100/H200); on Hopper, multi-GPU rides Protected PCIe and NVLink traffic is unencrypted; encrypted-NVLink multi-GPU is a Blackwell feature. Frontier models are multi-GPU, so the near-term Hopper surface is single-GPU / smaller-model and the multi-GPU frontier case waits on Blackwell. Overhead is regime-dependent, not a single number: near-zero for large models and long prompts, but up to ~19% time-to-first-token for small models and short prompts on single-GPU Hopper (arXiv 2409.03992), because the cost is I/O-bound, not GPU-compute. NVIDIA CC is two evidence chains (a CVM report plus a separate GPU report against RIM golden values); the composite verification and CPU-GPU binding are in section 3.2. The guarantee is silicon-enforced against software theft and accountability-grade against a physical operator (section 3.6). Buildable; the claim is reframed, not withdrawn.
  5. Applicability: this is a forward-looking design for the builder-into-customer-infrastructure case (a builder's weights deployed into a customer's own or sovereign environment). It is not tied to any specific deployment.
  6. Revocation: default profile, joint signature is standard, either party can trigger a unilateral emergency revocation with mandatory reconciliation within 24 hours. Sovereign profile: revocation requires a quorum including the sovereign signer, no unilateral path. Underneath both, wipe-on-lapse zeroizes the key on any cadence lapse, bounding worst-case exposure to one cadence window in the semi-trusted posture and assuming a trusted time source (SecureTSC or a KBS-issued lease, section 3.2). Against a hardware owner who can forge attestation, the floor gives no bound; there the guarantee rests on the quorum, physical hardening, and the transparency log. This makes attestation_cadence a security parameter for the semi-trusted case. Sections 3.1, 3.2.
  7. Scope of this draft: four layers is the right level of resolution for now. Symmetric BYOM (one org holding both roles) is a named posture (deployment_model, section 3.1), and multi-stage sequential re-custody is now specified as a protocol over lineage and the transparency log (section 3.8). What stays deliberately unspecified is broad multi-party policy co-governance (arbitrary approval graphs beyond the sequential chain and the sovereign quorum). In-envelope distillation resistance beyond rate ceilings (watermarking, response perturbation) is explicitly out of scope, section 3.3.
  8. Replay protection: the Layer 2 release handshake is nonce-bound: the KBS issues a fresh single-use challenge, the enclave attests over it, and a stale or reused nonce hard-fails. Closes the quote-replay threat (threat model T4.1). Section 3.2, release_policy.replay_protection.
  9. KBS attestation is universal: the key release service runs in an attested enclave in every profile, not only self-custody, so the release logic is measured and a custodian insider cannot alter it (threat model ADV-3). Self-custody changes the operator, not whether the KBS is attested. Sections 3.1, 3.2, 3.5, custody.kbs_image.
  10. Serving-image measurement rotation: required_serving_image.accepted_measurements carries a small set of currently-valid measurements with a retire window, so a serving-stack patch adds a measurement rather than invalidating every live manifest. Sections 3.1, 3.2.
  11. Dedicated tenancy is an opt-in profile: tenancy: dedicated forbids co-located workloads, the operational mitigation for the side-channel residual (threat model ADV-6). Default is shared; the control is opt-in for high-value deployments. Section 3.1.
  12. Custody is scoped to the operator-trust model: the GPU and CPU-CVM assessments established that no current confidential-computing silicon delivers custody against an operator who owns the hardware: the key is extractable and attestation is forgeable with cheap published attacks. WCM therefore names two guarantees, never blended: cryptographic custody in the semi-trusted posture (default, silicon holds in practice) and accountability-grade in the hostile-owner posture (physical hardening mandatory: deterrence plus detection plus containment plus legal). "Custody" unqualified must never carry the weaker meaning; the product name is kept because the artifact governs custody terms. It never claims silicon-enforced custody against an unhardened hardware owner. Sections 1, 3.1, 3.6. This is the central honesty of the specification.
  13. Open-core, with agentrust-io as the spec's home: the spec, threat model, and reproducible reference KBS image are open and destined for agentrust-io, alongside TRACE/cMCP/Agent Manifest/cA2A; an operated custodian service, gateway integration, and enclave engineering are left to implementers. The value is operation and implementation, not a secret format, and an auditable spec is a trust requirement for builders and sovereigns. Publication is not gated on closing the key-extraction half of 8.8: the open spec and SDK ship with that limit disclosed and scoped out of the operator-trust model (section 3.6), because a format published for scrutiny beats one withheld pending a silicon fix. Section 4.
  14. Transparency log for authority-layer integrity: every manifest, revocation, and measurement-set change registers on an append-only transparency log (SCITT or Rekor-style, with inclusion/consistency proofs and independent monitors); re-attestation binds to an inclusion proof, so equivocation and suppressed revocations become detectable. Mandatory under sovereign_profile, recommended in the default. This is the Certificate-Transparency obligation the CA analogy in 3.1 inherits. Section 3.7.
  15. Threshold is a prerequisite for sovereign self-custody: single-key self-custody is sound only for a semi-trusted self-custodian. A hardware-owning sovereign can forge its own KBS quote and self-release, so sovereign self-custody requires threshold split-key release (no single party can assemble the key alone) plus physical hardening on the KBS host. Threshold stays a later v2 hardening for the semi-trusted case but is a hard prerequisite for the sovereign case. Section 3.5.
  16. Standards home is IETF SCITT (technical) and CoSAI (positioning): the manifest-plus-signed-receipts design is an application of SCITT, with WCM constructs mapped to SCITT roles (section 3.4), not a bespoke format; the earlier five-framework list is demoted to an auditor crosswalk. Resolves open question 11(a).
  17. required_hw_platform is a profile list, and the attestation interface is silicon-agnostic. "Any environment" means any platform satisfying an accepted profile, not literally any silicon. Section 3.1 specifies the abstract interface (hardware-rooted nonce-bound quote over firmware plus measured runtime image, verifiable against a builder-pinned reference, plus a host-unreadable execution boundary); TPU/ASIC/other CVMs are addable profiles, concrete implementations are follow-up. Resolves open question 11(c).
  18. Sovereign hardening is framed as dual-protection, audited by the sovereign's own body: the mandatory tamper-audit and physical hardening protect the sovereign's own classified data in the same facility, and the audit is run by the sovereign's accreditation body attesting outward, not by a foreign vendor auditing a facility it casts as the adversary (section 8.3). Direction resolved; validate with a real sovereign buyer. Resolves open question 11(d).
  19. Trusted time is named per deployment, not assumed: release_policy.trusted_time_source names the clock the wipe-on-lapse floor trusts: secure-tsc (hardware-rooted monotonic clock, full floor, where the silicon provides it), lease-with-op-count-hybrid (fallback for platforms without one, operation-count renewal plus a KBS-signed idle lease, marked as the weaker guarantee), or none-best-effort (no floor, disclosed). The requirement is disclosure of the source, not a single assumed one. Resolves open question 8.9. Sections 3.1, 3.2.
  20. Forged attestation splits into a closed half and an open half: measurement forgery (BadRAM-class, key intact) is closed by memory_fingerprint_challenge, a full-DRAM write/readback challenge whose collisions detect address aliasing, required in the hostile-owner posture (sections 3.1, 3.6). Key extraction (TEE.fail-class, a lifted signing key producing a cryptographically valid quote for a fabricated environment) is not detectable at the gate and stays honestly open, compensated by a mandatory attestation_revocation_check (live-per-release, short cache age), inherited vendor short-lived certs, mandatory physical hardening as prevention, and out-of-band fleet anomaly monitoring. Resolves the measurement-forgery half of open question 8.8; the key-extraction half stays honestly open and is disclosed as a scoped limit (a hardware owner outside the operator-trust model) rather than gating publication of the open spec. Sections 3.1, 3.2, 3.6.

8. Open Questions Still Standing

  1. Reconciliation window, set to 24h: the window for a unilateral revocation to be confirmed or reversed is set to 24 hours, down from the 72h placeholder. Wipe-on-lapse already bounds the security exposure independently of this window, so 24h is about the human confirm-or-reverse process and about not letting a wrongful revocation stand long, not about containing weight exposure. Residual: validate 24h against an actual incident response timeline at a large regulated customer, and confirm it survives a weekend or cross-timezone review without forcing a rushed confirmation. If it does not, the fallback is a tiered window (shorter default, documented extension on mutual request) rather than a blanket return to 72h. Sections 3.2, 5.1.
  2. Self-custody attestation parity: resolved. The reference design is an attested KBS: the customer's key release service runs inside its own attested enclave whose builder-signed measurement the builder verifies (section 3.5). The last remaining detail, the KBS enclave image contents and its threat model to implementable detail, is now specified in section 3.5 (the minimal release-path TCB, what is excluded from it, and what it does and does not defend against). Self-custody moves from "described" to specified; the reference KBS image and an independent build-to-measurement audit are the implementation follow-up, not a spec gap.
  3. Will the sovereign accept builder-signed in-enclave code, in two places? The v0.2 decision has the sovereign customer running a builder-signed, customer-unauditable serving image inside its own jurisdiction, with verification limited to matching a disclosed measurement. If the sovereign also self-custodies (section 3.5), that is now two such enclaves in-environment, the serving image and the KBS image, not one. Both are verify-by-measurement, neither is customer-authored. That is the correct security choice but an untested commercial and political one, and the surface it asks the sovereign to accept is larger than a single opaque component. It needs a real conversation with a sovereign buyer before it is assumed acceptable, because a sovereign that rejects opaque foreign code in-environment rejects the whole architecture, not just a parameter. The opening posture into that conversation is reproducible builds plus independent third-party audit for both images: neither image's source is handed to the customer, but both are built reproducibly and an agreed independent auditor certifies that the running measurement corresponds to certified source. That gives the sovereign verifiable assurance about what the foreign code does without the builder surrendering the weights-serving IP, and it moves the trust from the vendor's word to the auditor. This is distinct from, and not in tension with, the reproducible-build option rejected in section 3.5: there it was rejected as a custody mechanism, because an audit log does not stop a forked KBS from self-releasing, whereas here it is a disclosure and verification mechanism for accepting builder-signed image contents, layered on top of attestation rather than replacing it. Two moves de-radioactive the "you are the adversary" framing that otherwise sinks the conversation. First, the mandatory tamper-audit and physical hardening are sold as dual-protection: the same enclosure and controls protect the sovereign's own classified data in that facility, not only the foreign builder's weights, so it is a mutual control, not a one-way imposition. Second, the audit is run by the sovereign's own accreditation body, attesting outward, not by a foreign vendor auditing a facility it casts as the threat; the builder gets an attestation from an authority it can check, and the sovereign is never asked to admit a foreign auditor into a top-secret site. Both are go-to-market positioning to validate with a real sovereign buyer, not settled architecture.
  4. Confidential GPU maturity (assessed, closed): resolved by the deep-research assessment folded into section 3.6 and resolved decision 4. NVIDIA CC is custody-grade against software and remote adversaries but not against a physical operator (access-control firewalling, not HBM encryption; sophisticated physical attacks out of scope). The guarantee is reframed in 3.6 rather than asserted. Attestation phone-home (NRAS/RIM dependency) is now a documented deployment requirement for sovereign/air-gapped cases (3.6).
  5. KBS-to-inference cadence coupling (self-custody only). Resolved: KBS runs longer. When the customer self-custodies, every inference enclave depends on the KBS for key renewal, so a KBS that lapses and wipes darks its dependents at their next cadence by cascade. That cascade is a feature (a degraded release service should drop its dependents rather than serve keys it can no longer stand behind), but it makes a short-cadence fleet only as available as its KBS. Resolution: the KBS runs a deliberately longer, more conservative cadence than the inference enclaves it serves (illustratively 6h KBS against 15m inference), so the release service is the stable anchor and its normal re-attestation blips do not cascade into the fleet. The security cost, that the KBS's own trust standing is refreshed less often, is acceptable because the KBS attack surface is small and measured, and the inference enclaves enforce their own short cadence and wipe-on-lapse independently of the KBS. Residual: pick the concrete ratio per deployment; the 6h:15m figures are illustrative, not fixed.
  6. Does the physical-operator gap extend to the CPU CVM? Assessed: yes, and to attestation. Physical bus-interposer attacks (TEE.fail, sub-$1000; BadRAM, ~$10) defeat SEV-SNP/TDX today: they extract keys from live CVM memory and forge attestation quotes at the highest trust level, and the root cause (deterministic unauthenticated full-DRAM encryption without freshness) needs new silicon to fix (3.6). Software-only variants (CipherLeaks, Heracles) do it from a malicious hypervisor. So against the operator-owns-the-box adversary the CPU CVM protects neither the key nor attestation integrity, which reaches the anchor primitive (Principle 2). What remains open is not technical but strategic: how WCM positions given the anchor does not hold against a hardware owner. That decision is 8.7.
  7. Positioning given the anchor does not hold against a hardware owner. Resolved: scope custody to the operator-trust model. WCM claims two postures, never blended (section 3.6): semi-trusted operator (default; silicon holds in practice) and hostile-owner (sovereign / on-prem bare metal), where physical hardening is mandatory and the honest claim is raise-cost plus detect plus contain plus legal, backed by hardening, not silicon-absolute custody. Silicon-enforced custody against a bare-metal owner with no hardening is explicitly out of scope. Residual: validate that the mandatory hardening tier (tamper-responsive enclosure, locked SPD, access control, chain-of-custody) is procurable and auditable for a real sovereign deployment, and price it.
  8. Forged attestation at the Layer 2 gate. Resolved into a closed half and an honestly-open half. The single question conflated two attacks. Measurement forgery (BadRAM-class: aliased DRAM, clean-reading measurement, key intact) is now closed by the memory_fingerprint_challenge (sections 3.1, 3.6): aliased memory collides under a full-range write/readback challenge in a way genuine DRAM cannot, so the KBS gets a second evidence type that detects it, required in the hostile-owner posture. Key extraction (TEE.fail-class: an interposer lifts the signing key and signs a cryptographically valid quote for a fabricated environment) stays open, because no gate-side verification can distinguish that quote from a real one. Its compensating controls are now named and, where WCM can enforce them, made requirements: mandatory attestation_revocation_check (live-per-release, short cache age) on the attestation-key certificate, inherited vendor short-lived certs, mandatory physical hardening as prevention (the enclosure must stop the interposer attaching), and fleet anomaly monitoring in the custodian's stack, not the protocol. This half is disclosed, not closed, and it does not gate publication: it narrows under hardening but is not provably closed, and it is scoped out of the operator-trust model WCM targets (a hardware owner a builder self-selects against at deal time) rather than held as a reason to withhold the open spec. Any real bound in the hostile-owner posture must come from something the interposer cannot forge, physical hardening today and extraction-resistant silicon on the CC-vendor roadmap, not from gate-side logic on adversary-owned hardware.
  9. Trusted time for wipe-on-lapse. Resolved: name the source per deployment. The cadence floor assumes a trusted monotonic clock the host cannot stall (section 3.2), and neither candidate design was sufficient alone: a hardware clock is silicon-specific, and a pure lease still needs some clock to check the lease deadline against. The resolution is to name the source explicitly in the manifest (release_policy.trusted_time_source, sections 3.1, 3.2) rather than assume one: secure-tsc where the silicon provides a hardware-rooted monotonic clock (full floor), lease-with-op-count-hybrid as the fallback for platforms without one (operation-count-anchored renewal for the serving case plus a KBS-signed wall-clock lease for the idle case, at a clearly-marked weaker guarantee), or none-best-effort (no floor, disclosed as such). Residual: pin concrete parameters per profile (the operation count N, the idle lease window) when Layer 2 is implemented.
  10. Transparency-log mechanism and governance: decision 14 requires the log; the mechanism (IETF SCITT vs a Rekor-style log), who runs the witnesses and monitors, and how a sovereign runs its own monitor are unspecified. Resolve before the sovereign profile is offered.
  11. Strategy calls (three resolved, one still flagged). (a) Standards home, resolved: manifest-plus-signed-receipts is standardized through IETF SCITT (roles mapped in section 3.4), positioning through CoSAI; the five-framework list is demoted to an auditor crosswalk. (c) "Any environment", resolved: required_hw_platform is a profile list, not a universality claim, and section 3.1 specifies the silicon-agnostic attestation interface a TPU/ASIC/other platform must satisfy to be added; concrete non-CVM/non-NVIDIA profiles are follow-up. (d) Sovereign go-to-market, resolved in direction: hardening is sold as dual-protection and the audit runs through the sovereign's own accreditation body attesting outward (section 8.3); validate with a real sovereign buyer. (b) Still flagged: how deeply to lean on the RAND OC/SL vocabulary in buyer-facing material. WCM is a measure holding against OC1-OC3, never its own "security level"; the placement is in sections 1/3.6, but the depth of RAND framing in decks and one-pagers is a marketing judgment left open.

v0.16, pre-1.0 open specification. Companion: THREAT-MODEL.md. Sections 3 and 5 are load-bearing.

Version history: v0.1 initial draft. v0.2 established the runtime-control crux (builder-signed serving image), wipe-on-lapse, the sovereign revocation profile, and the attested-KBS self-custody design. v0.3 folded in a confidential-GPU assessment and reframed the guarantee as silicon-enforced against software theft but cost-plus-detection against a physical operator (section 3.6). v0.4 folded in a CPU-CVM assessment (TEE.fail / BadRAM defeat SEV-SNP/TDX and forge attestation), scoped custody to the operator-trust model, and made physical hardening mandatory for the hostile-owner posture. v0.5 set the open-core model. v0.6 applied an external panel assessment: corrected the commercial-posture overclaim (a malicious hypervisor extracts keys via ciphertext side channels, so the by-construction claim now excludes hypervisor-privileged operators absent ciphertext-hiding); added a trusted-time requirement for wipe-on-lapse; carried the forged-attestation concession through to the revocation floor and self-custody (threshold now a prerequisite for sovereign self-custody); added a transparency log (§3.7) and a revoked-measurement status; split the NVIDIA maturity claim (single-GPU Hopper GA vs Blackwell multi-GPU) and specified composite CPU+GPU attestation; reframed §1's false-novelty claim (attestation-gated release is prior art); introduced the cryptographic-custody vs accountability-grade distinction; and generalized references to an unannounced companion project. v0.7 resolved three of the flagged strategy calls: standards home is IETF SCITT plus CoSAI with WCM mapped to SCITT roles (section 3.4); required_hw_platform is a profile list with a silicon-agnostic attestation interface specified (section 3.1); and the sovereign go-to-market is reframed as dual-protection with a sovereign-run outward-attesting audit (section 8.3). The sovereign_profile name is scoped to a quorum veto, not full sovereignty. RAND-vocabulary depth in buyer material remains flagged. v0.8 resolved two build decisions: trusted time for wipe-on-lapse is named per deployment (trusted_time_source, three tiers: secure-tsc, an op-count/lease hybrid fallback, or disclosed best-effort), closing open question 8.9; and the forged-attestation question is split, with the measurement-forgery half closed by a memory_fingerprint_challenge (full-DRAM write/readback detecting BadRAM-class aliasing) and a mandatory attestation_revocation_check, while the key-extraction half (TEE.fail-class) stays honestly open with named compensating controls and remains the reason publication is staged. v0.9 is an editorial sync of Layer 4 (section 3.4): the manifest example now shows a derivative's derived_from and rights_holder fields (both under the joint signature), and release_terms gains a machine-checkable derivatives field (none | fine-tune-only | unrestricted) alongside the freeform permitted_derivatives legal text, so a verifier can resolve the lineage chain and enforce whether a derivative is permitted. No normative change to the release, attestation, or custody semantics. v0.10 makes two things explicit that were previously assumed or scoped out. base_confidentiality (confidential | gated-open | open, section 3.1) states whether the base weights are actually secret, so a manifest over a public open-weight base is not read as promising secrecy it cannot deliver; the four layers still do integrity, license, derivative-custody, and kill-switch work, and the reference verifier reports a non-blocking consistency note where an open declaration carries secrecy-only controls. deployment_model (builder-to-customer | byom-symmetric, section 3.1) makes the symmetric case, one org holding both the builder and custodian roles for its own model, a first-class verifier-recognized posture (requiring customer-self-custody), turning the section-2 principle 4 into a concrete field rather than a deferred capability. Both fields are under the joint signature. The multi-stage BYOM pipeline (sequential re-custody) remains co-governance work out of scope here. v0.11 hardens two areas with no new manifest fields. Section 3.5 now specifies the KBS enclave image to implementable detail (the minimal release-path TCB, what is excluded from it, and its threat model), resolving open question 8.2, so self-custody moves from described to specified. Section 3.8 specifies multi-stage BYOM as a sequential re-custody protocol over the existing lineage (3.4) and transparency-log (3.7) primitives: chained derived_from manifests, release gated on every upstream being logged, monotone rights that narrow but never widen down the chain, and revocation that cascades along the lineage; only broad multi-party policy co-governance stays deliberately open. Reference-SDK enforcement of the new lineage checks (monotone rights, upstream-logged gating, cascade) is a tracked follow-up. v0.12 reframes the publication posture: closing the key-extraction half of open question 8.8 is not a precondition for publishing the open spec and SDK. That half is an honestly-disclosed limit against a hardware owner outside WCM's operator-trust model, a party a builder self-selects against at deal time, addressed by physical hardening and accountability today and by extraction-resistant silicon on the CC-vendor roadmap. The security claims are unchanged; only the "therefore withhold the document" logic is dropped, in favour of leading with the limit. v0.13 adds channel binding to the Layer 2 release handshake (section 3.2): the enclave folds a transport public key into the quote's REPORT_DATA under the nonce, and the KBS seals the released key to that transport key rather than returning it on the channel. This closes the quote-relay / key-diversion gap (the intra-handshake binding gap, CVE-2026-33697) that nonce binding alone left open: a relayed quote yields only ciphertext the relay cannot open, and substituting a transport key breaks quote verification. No new manifest fields; the evidence carries the transport key. v0.14 adds provenance interop (section 3.9): an optional provenance field, under the joint signature, references an OpenSSF model-signing signature over the base weights, and verify_provenance cryptographically checks that signature and binds it to the manifest by re-deriving the signed digest. WCM composes with model signing (the provenance layer) rather than replacing it, and it does not re-sign the model files. v0.15 records that the reference SDK's NVIDIA H100 GPU CC verification is now validated against a real confidential-compute attestation captured on live silicon (device cert chain to the NVIDIA Device Identity CA, ECDSA-P384/SHA384 report signature, raw-nonce binding); a maturity note, no normative protocol change. v0.16 adds vendor-neutral spellings for two enum values, builder-and-custodian-joint (revocation_authority) and custodian-hosted (custodian_type), and deprecates builder-and-opaque-joint and opaque-hosted as aliases that remain valid in v1 and mean the same thing (section 3.1). Pre-1.0: published openly for review and comment, still evolving, not yet a frozen build target.