Implementation Guide

    AI Coding Tool Indemnity Gap Assessment: A Step-by-Step Method

    An AI coding tool indemnity gap assessment inventories every AI coding tool in your toolchain, turns each tool's indemnity terms into a matrix of conditions and exclusions, maps those conditions to how the tool is actually configured and used, and compares the demonstrable coverage with the IP warranties you give customers. Where a condition cannot be shown to have been met, the code is effectively uncovered. This guide is not legal advice; counsel should interpret the actual terms.

    The assessment in six steps

    1. 1

      1. Inventory the tools

      List every AI coding tool, tier and model option in use, who approved it, and which parts of the SDLC it touches. Include tools adopted informally. NIST describes a coding assistant as acting on the enterprise codebase through natural language commands, so inventory by what each tool can access and modify.

    2. 2

      2. Extract the conditions

      From each tool's current contract documents, record every condition, exclusion and eligibility requirement. Note the document version and date, because terms change.

    3. 3

      3. Normalize into a matrix

      Use one row per condition and one column per tool, with common categories such as configuration, tier, output handling, model source and chaining. Flag conditions that are ambiguous for legal review.

    4. 4

      4. Map to configuration and usage

      For each condition, record the setting or practice that satisfies it, who controls it, and whether it can be changed per user or per project. Mark each cell as met, unmet or unknown.

    5. 5

      5. Trace the handoffs

      Identify points where code moves between tools, models or people, and test whether a condition could be broken there.

    6. 6

      6. Compare with downstream commitments

      Set the demonstrable coverage against the IP warranties and indemnities in customer contracts, and record the difference as residual exposure.

    Indemnity is a set of conditions, not a blanket assurance

    A software vendor rarely uses one AI coding tool. Developers may use an IDE assistant, a code review agent, a chat interface and an agentic tool on the same codebase. Each vendor publishes its own indemnity terms, and those terms differ in their conditions, exclusions and eligibility requirements. Typical examples include required filter settings, use of a specific product tier, unmodified output, and exclusion of code produced by third-party models or by tools chained together.

    The practical consequence is that indemnity applies to a contribution only if its conditions were met when the code was generated. Most organizations cannot say which code in a shipped product came from which tool under which configuration. That gap matters most when the vendor gives its own customers IP warranties or indemnities for the software it ships.

    NIST guidance points the same way. The NIST Generative AI Profile includes an action to update third-party contracts, service agreements and warranties to address generative AI risks, and notes that these may include GAI-specific indemnity clauses. AI RMF GOVERN 6.1 calls for policies and procedures that address third-party AI risk, including the risk of infringing a third party's intellectual property. An indemnity gap assessment applies that guidance to the coding toolchain.

    Handoff points where coverage can break

    Conditions that hold for a single tool in isolation can fail once tools are combined. The SSDF draft version 1.2, practice PO.3.1, says to specify which tools belong in each toolchain and how their components are integrated. Its examples include specifying what data passes between tools and in what format. Apply the same discipline to AI coding tools, because the handoff is where a per-tool condition is most likely to be affected.

    Four patterns deserve explicit review. First, several assistants contributing to the same file or repository. Second, a developer selecting a third-party model within a tool, which may fall under an exclusion for third-party models. Third, an agent that opens pull requests, where a human may later edit the output. Fourth, one tool's output being fed into another, which may trigger chaining exclusions. For each pattern, decide whether your matrix gives a clear answer. If it does not, treat the pattern as unresolved until counsel and the tool vendor have clarified it.

    Also check that tool use is consistent across the organization. SSDF community guidance notes that toolchains can be organization-wide or project-specific. A condition met in one team's configuration may not be met in another's.

    Evidence needed for each condition

    For every condition in the matrix, define the evidence that would show it was met for a specific code contribution. A policy document stating that filters should be on is weaker than a record showing they were on when the code was generated.

    In practice this means evidence at four levels. For configuration conditions, a time-stamped record of the setting in force. For tier or licensing conditions, a record tying the user or agent to the approved product tier. For output conditions, a record of whether the output was accepted as generated or modified before commit. For model and chaining conditions, a record of which model or tool produced the contribution and whether any other tool touched it.

    The SSDF draft supports this approach. Its PO.3 examples include evaluating whether tools can sign records so they create immutable logs for auditability, and continuously monitoring tool logs for policy violations and anomalous behavior. Ask each vendor whether its tooling supports signed or immutable records, how long they are retained, and whether you can export them. Where a tool cannot produce evidence for a condition, record the condition as unverifiable rather than met.

    Comparing upstream coverage with downstream commitments

    Once the matrix shows which conditions are demonstrably met, compare the result with what you promise customers. Collect the IP warranties, indemnities and open source licence commitments in your customer agreements, and note their scope: whether they cover all software delivered or only specified components, and whether they depend on how the code was produced.

    The gap is the set of commitments that exceed the upstream coverage you can demonstrate. Upstream indemnity may be narrower than your downstream promise, may depend on conditions you cannot prove, or may not address licence obligations attached to the code itself. NIST SP 800-161r1 advises reviewing the risks of open source and commercially licensed components and understanding provenance, so licence and origin context for generated code belongs in this comparison.

    Treat each gap as third-party IP risk under GOVERN 6.1 and assign an owner. Options include tightening configuration, restricting a tool to projects without strict warranties, renegotiating vendor or customer terms, or accepting the risk explicitly. SP 800-161r1 also recommends supply chain risk assessment at enterprise, programme and operational levels, including development environments, so record decisions at each level.

    Where runtime enforcement and code provenance help

    The assessment will usually show that the hardest conditions to prove are the ones tied to configuration and usage at the moment of generation. Reviewing settings after the fact does not show what happened on a given day. This is where runtime policy enforcement can supply evidence.

    Trussed enforces policy in the execution path across coding assistants, with actions to allow, redact, block or escalate for human approval, at the level of individual interactions and tool calls. A rule can, for example, block use of a non-approved tool configuration. Because enforcement happens at runtime, not after the fact, it produces audit-ready evidence that the configuration and usage rules were applied. Trussed also provides code provenance, covering the origin, licence and security context of code, which supports the licence and origin questions in the downstream comparison.

    These capabilities do not create or replace any vendor indemnity, and they do not decide whether a condition is satisfied under a contract. They supply evidence that your own rules were enforced. Trussed does not currently provide model provenance or end-to-end tracing of agentic workflows, so keep handoff analysis and chaining conditions in your manual review.

    Assessment flow

    Inventory

    Every IDE assistant, review agent, chat interface and agentic tool, with an owner.

    Conditions

    Each tool's indemnity terms normalized into one matrix.

    Mapping

    Conditions compared with actual configuration and usage.

    Exposure

    Demonstrable coverage compared with downstream customer commitments.

    Test your matrix against runtime evidence

    See how policy enforcement and code provenance produce audit-ready evidence for AI coding assistants in a regulated enterprise.

    Request a Demo
    Next step

    How does your AI governance program compare?

    See where your program has gaps in less than 2 minutes.