Each row also links outward to the deployment manifest that consumes the artifact and to the model card or SBOM that describes it. A row without a manifest link is a catalog entry, not a register entry: nobody can tell which deployment it governs, so it cannot gate anything. Record the vendor's written indemnity answer verbatim in the indemnity-source field rather than summarizing it, so a later reviewer sees the actual scope language, including any model-level carve-out.
The ship test is mechanical. A row passes when all eight fields are populated, the stored hash matches the license text currently on disk, and the named owner has accepted the row. A blank field, a hash that no longer matches after an upstream license amendment, or an indemnity source recorded as verbal or pending sends the row to hold and routes it to the docket ID. Respitting the row to the next release is a separate decision made by the owner, not a side effect of a file update.
Keeping the three classes separate also keeps the register honest about what a row proves: that a specific license text was reviewed by a specific person on a specific date, not that an entire model family is cleared.

Benchmark the 73/58/22 indemnity gap
VendorBenchmark’s 2026 enterprise AI indemnity clause benchmark reports two figures that most registers collapse into one: 73 percent of enterprise AI contracts include third-party IP indemnity for AI outputs, and 58 percent cover both training-data sourcing and output generation. The 15-point spread between those two figures is the coverage gap your register has to expose row by row, because the executive-summary version (“our AI vendors indemnify us”) is true for roughly three in four contracts and materially incomplete for the specific artifact you are about to ship. Check the named benchmark for any uncapped-indemnity rate before using one in a register field.
Treat that 15-point gap as proof of two separate clause questions, not one. For every row, ask whether the indemnity reaches training-data sourcing and, separately, whether it reaches output generation. Two bits, recorded independently, each with the clause language that supports it. A vendor that answers yes on outputs and no on data sourcing still leaves the sourcing exposure on your side of the table — and a register field reading “indemnified: yes” hides exactly that split.
Second check: caps. Treat the working assumption for any row as a cap until the clause text says otherwise, and verify any uncapped-indemnity figure against the named benchmark rather than importing a rate from memory. Record the cap amount or formula, the exclusions, and the carve-outs on the same row as the license-text hash, not in a contract folder someone has to reopen. A capped output indemnity does not answer training-data exposure; the two sit under different ceilings. Labarna flags the carve-out pattern to look for: cross-system deployments, where enterprise data feeds external models or agents operating across multiple systems, can move outside the indemnity entirely.
The myth to kill is that “the vendor says we’re indemnified” equals open-source AI coverage. Vendor indemnity is drafted around outputs the vendor’s model generates under that vendor’s contract. Weights you pull, fine-tune, and ship, data you source, and inference code you redistribute are your distribution decision, not theirs. Adobe’s IP indemnity covering Firefly outputs “in certain contexts,” paired with Content Credentials provenance tooling, illustrates the qualifier problem: the scope language, not the headline, is the answer.
The gate: a row ships only when its license-text hash is current, its owner is named, its counsel-docket entry is matched, and its indemnity answer is written. A blank indemnity field is a hold, not a to-do.
Run the comparison against your own register before adopting it. Pull the count of active entitlements, check how many counsel-docket entries changed in the last two quarters, and measure how long each license-text hash has gone unrefreshed. If any row feeding a current release is older than your review window, the cadence — not the license — is your gap. Select the cadence that keeps every shipping row inside its verification window, and let the ship gate enforce it.

Price the audit against uncapped exposure
Price the audit against uncapped exposure before you price the license. The register's cost column should not record what a seat costs on the sticker; it should record what an uncovered row costs when an indemnity claim lands. Kimlud's 500-seat AI coding-agent comparison makes the point structurally: its "Axis 4: True Per-Seat Cost at 500 Seats" lists Cognition Enterprise API audit-log endpoints and per-seat list prices in USD per month, explicitly before usage overages and taxes. Force your register to record the same three fields for every component — seat count, audit-log access, and overage terms — because a row that lacks any of the three is a row you cannot price.
Syntax.ai's 2025 analysis gives the contrast that justifies the exercise. One enterprise architect budgeted $50K for AI coding tools and GitHub Copilot's $10/month sticker looked trivial; the true cost came in at $659K against a $114K budget. The register lesson is not that AI tools are expensive — it is that unlisted overages and missing controls, not the license fee, drive the exposure line. When you price an audit, therefore, price the gap between the budgeted line and the true line, and attribute the difference to specific register fields: which overage term, which missing restriction flag, which absent counsel-docket match produced the delta.
Now set the audit target as a row-coverage percentage. The 40% IP-indemnity risk cut is a register-coverage target: measure it as the share of rows that pass the ship test — current license-text hash, recorded use-restriction flag, named owner, matched counsel-docket entry, and written indemnity answer. Compute it as fully passing rows divided by total rows, not as partially compliant fields divided by total fields. A register where every row has a hash but none has a counsel-docket match scores zero, because the gate requires every listed check.
| Register field | What to record | Cost driver it prices |
|---|---|---|
| Seat count | Seats at the tier actually deployed | Per-seat list price before overages |
| Audit-log access | Endpoint availability at that tier | Control evidence for indemnity claims |
| Overage terms | Usage-based charges and taxes | The sticker-to-true-cost delta |
Run the pricing check in this order. First, pull the vendor's current contract — Kimlud's comparison and MarkTechPost's indemnity table both build rows from the vendor's current terms, not archived ones. Second, record the list price and the tier it applies to. Third, list every overage trigger the contract names; anything usage-based that the contract does not name is an unpriced exposure, and the register should flag it as such rather than estimate a number. Fourth, attach the true-cost delta from your own budget reconciliation, using the Syntax.ai $659K-versus-$114K pattern as the template for what a reconciliation surfaces.
Finally, tie the price to the gate. A row that fails any of the four fields is a hold, and the cost of the hold is the audit price you compare against uncapped exposure. If the delta between your budgeted and true spend exceeds the cost of completing the missing fields, the audit pays for itself; if it does not, the row still ships only when the fields are complete — the gate is not for sale.

State what the 2026 benchmark cannot prove
VendorBenchmark's 2026 benchmark is a population study, and this section is where the register's honesty lives: its contract-population figures describe how many enterprise AI contracts contain third-party IP indemnity for AI outputs and dual coverage for training-data sourcing and output generation, not claim outcomes. Verify any uncapped-indemnity rate separately against the named benchmark before treating it as a rule. The benchmark does not tell you how often claims are actually made, how large losses run, or whether any single open-source model in your register is safe to ship. A model that sits in the covered population can still generate the one output that triggers a claim; population coverage is not per-component proof.
The second limit is definitional. An open-source license name — Apache-2.0, Llama Community License, MIT — is not an indemnity. A permissive license grants copyright and patent permissions; it almost never promises to defend you against a third-party infringement claim arising from model outputs. Treating a license row as an indemnity answer is the single most common register error, and it is why the ship gate requires a matched counsel-docket entry and a written indemnity answer per row, not just a license-text hash.
The third limit is boundary drift. Labarna's analysis of indemnity clauses in AI contracts warns that cross-system AI deployments — where Salesforce data feeds external models, or autonomous agents operate across multiple enterprise systems — move outside the indemnity. Coverage that was negotiated for one deployment topology silently fails when data crosses a system boundary. The register must therefore flag data-flow boundaries, not just license names: every row needs a documented output stating which systems feed the component and whether any data leaves the covered environment.
| Case | Rule breaks when | Rule still wins when |
|---|---|---|
| Single-system inference on licensed weights | License hash is current but counsel-docket entry is stale | Hash, restriction flag, docket match, and indemnity answer all current |
| Salesforce data piped to an external model | Register records the license but not the data-flow boundary | Boundary flagged; deployment held until indemnity scope is confirmed |
| Autonomous agent spanning enterprise systems | One register row covers the agent; component systems unregistered | Each system in the agent's path carries its own gated row |
The practical check: before any release, ask what the benchmark cannot prove about this specific row. If the only evidence is a population percentage and a license name, the row is a hold. If the row carries a current hash, a named owner, a docket-matched indemnity answer, and a boundary statement, the benchmark's limits stop being your problem — the row's own evidence carries the decision.

Work a 40-model register with live checks
The worked example is a register with 40 open-source AI components, each expanded into the three artifact classes already defined — model weights, training data, and inference code — for 120 rows. Each row carries four gate fields: a current license-text hash, a named owner, a matched counsel-docket entry, and a written indemnity answer covering both output generation and training-data sourcing. That is 480 individual checks run inside the 14-day rolling window. The register worksheet below is the deliverable of this section; copy it directly into your tracker and populate one column at a time rather than row by row, because hash verification and docket matching are batch operations.
Checkpoint discipline keeps the arithmetic honest. Checkpoint one, at the day-14 close: count rows whose license-text hash matches the license file currently in the repository. A row passes only when its own hash is current; a stale hash holds that row, not every other row. Checkpoint two: count rows with a matched counsel-docket ID, passing per row only when the docket cites the same hash. A docket entry proves a named legal reviewer saw this exact license text, not a similar one. Checkpoint three: count rows where the indemnity answer separately addresses output generation and training-data sourcing. A single “covered” answer that merges the two fails that row. The checkpoints produce a per-row pass/hold list, so a weights row can pass while its training-data row is held.
| Register field | Row example (one component) | Pass condition |
|---|---|---|
| License-text hash | SHA hash of the LICENSE file at pinned commit | Matches file in repo at review date |
| Named owner | Engineering owner per artifact class | Human name, not team alias |
| Counsel-docket match | Docket ID referencing this hash | ID resolves to entry citing same hash |
| Indemnity answer | Output: yes/no; training data: yes/no | Both answered separately, in writing |
Run the checkpoints as a batch close, not a continuous monitor. On day zero, pull all 40 repositories, snapshot license texts, and trigger hash computation. Days one through seven are for owner assignment and docket submission. Days eight through thirteen are the indemnity-answer window, where counsel answers per row using the row’s quoted clause text and the separate output-generation and training-data-sourcing questions described above. Day fourteen is the count. Any checkpoint below 120 of 120 issues a hold for the affected row — and because rows are per-artifact, a weights row can ship while its training-data row holds.
The output of the exercise is a binary artifact: either a register where every row passes all four fields, or a hold list with a named blocking field per row. If your register cannot produce that binary answer, the gap is almost always the docket-match field — hashes without a legal review trail give you a checksum register, not a ship gate.

Apply five if/then rules before release
Treat the register as a ship/hold gate with five if/then rules, applied in order, before any open-source AI component moves to release. The rules translate register coverage into a binary decision, so no reviewer has to argue judgment calls at the gate.
Rule one covers provenance gaps. If any row — weights, training data, or inference code — lacks a current license-text hash, then hold the release until the hash is refreshed against the upstream repository. If any row has no named owner or no matched counsel-docket entry, then block release outright; an unowned row is not a coverage gap, it is an untracked component, and it stays blocked until an owner and a docket ID are attached.
Rule two covers split indemnity. If vendor indemnity covers outputs but not training-data sourcing, then mark the training-data row UNCOVERED and require counsel sign-off before deployment. This is not a corner case: VendorBenchmark's 2026 benchmark found 58 percent of enterprise AI contracts cover both training-data sourcing and output generation, which means a substantial share of contracts leave sourcing exposed even when outputs are covered. The flag forces the gap into the open rather than letting output coverage mask it.
Rule three covers license form. If a model ships under a custom community license or carries a use-restriction field, then require written clause review before deployment. Community licenses with acceptable-use or field-of-use restrictions do not read like standard open-source terms, and a hash alone cannot tell you whether your deployment context trips a restriction. Written review, signed by counsel and attached to the row, is the gate.
Rule four covers cross-system writes. If an agent writes into a CRM, HR, or finance system, then re-run the cross-system indemnity check, because multi-system deployments move outside the scope of many standard clauses — Labarna's analysis of AI contract indemnity notes that agents operating across multiple enterprise systems fall outside indemnity terms written for single-system use. The re-run is cheap; the uncovered write-back is not.
Rule five closes the ownership loop. Any row that fails rule one's owner check after remediation, or whose counsel-docket match cannot be confirmed within the current register cycle, stays at hold and moves to exception review. Run the five rules in sequence at the pre-release ship gate, record the pass or fail state per row, and let the gate — not a meeting — decide what ships.
What to do next
| Step | Action | Why it matters |
|---|---|---|
| 1 | Inventory every open-source AI component in your stack and split the register into the three gate rows: Weights, training-data, and inference-code. | The ship/hold gate only passes when all three rows clear — a missing row means the component ships incomplete. |
| 2 | For each row, record a current license-text hash and a use-restriction flag, and assign a named owner accountable for that entry. | A hash plus a named owner makes each license entry verifiable and enforceable rather than aspirational. |
| 3 | Match every register row to a counsel-docket entry so legal review is traceable to a specific docket record. | An unmatched row is an exception — the component must be held until counsel-docket alignment is documented. |
| 4 | Write a documented indemnity answer for each row covering both output generation and training-data sourcing. | Only 58% of the indemnity clauses in the Enterprise AI Indemnity Clause Benchmark 2026 cover both — an untested gap is your largest exposure. |
| 5 | Apply the gate: release only rows with hash, flag, counsel-docket match, and written indemnity answer; hold everything else and log the exception with a remediation owner. | Holding incomplete rows is the mechanism behind the 40% IP-indemnity risk cut targeted for 2026. |
| 6 | Track register coverage monthly against the 2026 target, and weigh vendor indemnity as one of the four selection factors when adding new components. | With 73% of enterprise AI contracts including third-party IP indemnity for AI outputs, coverage discipline keeps your register — not your vendors — in control of risk. |
Frequently Asked Questions
When is a row only a catalog entry rather than a register entry?
A row without a manifest link is a catalog entry, not a register entry: nobody can tell which deployment it governs, so it cannot gate anything.
How should I record the vendor’s indemnity answer?
Record the vendor's written indemnity answer verbatim in the indemnity-source field rather than summarizing it, so a later reviewer sees the actual scope language, including any model-level carve-out.
What exactly must be true for a row to pass the ship test?
A row passes when all eight fields are populated, the stored hash matches the license text currently on disk, and the named owner has accepted the row.
What sends a row to hold and routes it to the docket ID?
A blank field, a hash that no longer matches after an upstream license amendment, or an indemnity source recorded as verbal or pending sends the row to hold and routes it to the docket ID.
If an upstream license file changes, does that automatically respit the row?
Respitting the row to the next release is a separate decision made by the owner, not a side effect of a file update.
What does a row prove when the three classes are kept separate?
Keeping the three classes separate keeps the register honest about what a row proves: that a specific license text was reviewed by a specific person on a specific date, not that an entire model family is cleared.
Quick answers
| What distinguishes a register entry from a mere catalog entry? | A register entry has a row linking outward to the deployment manifest that consumes the artifact and to the model card or SBOM describing it; a row without a manifest link is just a catalog entry that cannot gate anything. |
| How should the vendor's indemnity answer be recorded? | Record the vendor's written indemnity answer verbatim in the indemnity-source field rather than summarizing it, so a later reviewer sees the actual scope language, including any model-level carve-out. |
| What are the mechanical conditions for a row to pass the ship test? | A row passes when all eight fields are populated, the stored hash matches the license text currently on disk, and the named owner has accepted the row. |
| What sends a row to hold? | A blank field, a hash that no longer matches after an upstream license amendment, or an indemnity source recorded as verbal or pending sends the row to hold and routes it to the docket ID. |
| What does a register row actually prove about a model? | It proves that a specific license text was reviewed by a specific person on a specific date, not that an entire model family is cleared. |
Also worth reading: Reconcile counsel docket with license register: 14-day audit catches grant/termination mismatches before launch: Reconcile counsel docket with license · Software license tracking: 30-day SLA vs weekly misses — Ship or Hold: Software license tracking: 30-day SLA · 2026 Centralized License Register: Legal Review 5 Days to 1: 2026 Centralized License Register: Legal