Creating an AI BOM with CycloneDX: Recording and Validating Models and Data

Yuta Matsuyama

Security Researcher, TECHFUND Inc.

Updated:

Who this is for: For AI application developers and those responsible for ML infrastructure and security. Information current as of November 13, 2026.

The practical answer

First, identify the model and any datasets for which you have verified supporting evidence, and record them as CycloneDX components. In addition to validating the format, separately check for duplicate IDs, broken references, and whether the recorded information matches the actual configuration. Passing validation alone does not guarantee that an AI BOM is complete or safe.

Decide what to record first

For an internal question-answering application, for example, check the model name and version, provider, data used for evaluation, software dependencies, deployment environment, and responsible people according to your purpose. This article covers a minimal example that expresses the relationship between a model and its evaluation data. It does not cover the configuration of the entire application.

The CycloneDX specification allows models to be represented by the component type machine-learning-model and data by the type data. A model's modelCard can record references to datasets you have verified, among other information. The official CycloneDX examples of models and datasets show how to link them. The existence of a field in the format does not mean its value is actually available.

Start by recording two fictional components

Save the following as ai-bom.json. The model name, versions, and data name are all fictional. This example assumes that a fictional model used fictional evaluation data. The data contents, training data, licenses, and providers have not been verified, so they are not recorded. Omission does not mean that something does not exist.

bom-ref identifies a component within the document. The ref in modelCard.modelParameters.datasets points to dataset-1. Defining the data as a separate component and referencing it, rather than merely describing it in prose in modelCard, makes the relationship easier to check.

A fictional CycloneDX 1.6 AI/ML-BOM example
{
  "bomFormat": "CycloneDX",
  "specVersion": "1.6",
  "version": 1,
  "components": [
    {
      "type": "machine-learning-model",
      "bom-ref": "model-1",
      "name": "fictional-model",
      "version": "1.0",
      "modelCard": {
        "modelParameters": {
          "datasets": [{ "ref": "dataset-1" }]
        }
      }
    },
    {
      "type": "data",
      "bom-ref": "dataset-1",
      "name": "fictional-evaluation-data",
      "version": "1.0",
      "data": [{ "type": "dataset" }]
    }
  ]
}

Validate the format and check the references too

The CycloneDX CLI validate command can validate the format of a specified file. The following example uses CLI 0.33.1. On November 13, 2026, we used that version on macOS arm64 and confirmed that the example JSON passed validation. --input-version v1_6 specifies a version 1.6 file, and --fail-on-errors configures the command to exit with a nonzero status if validation errors occur.

The next two experiments test changing a reference to a nonexistent ID and giving two components the same bom-ref. In the same environment, both displayed “BOM validated successfully.” and returned exit code 0. The CycloneDX specification requires bom-ref to be unique within the document. Do not rely solely on successful format validation: separately check that reference targets exist and that IDs are unique. These results are observations for CLI 0.33.1 with the inputs shown, not conclusions about other validators or future versions.

Commands for validation and for testing broken references and duplicate IDs
cyclonedx-cli --version
cyclonedx-cli validate --input-file ai-bom.json --input-format json --input-version v1_6 --fail-on-errors

# 架空のデータ参照を存在しないIDに変更
python3 -c 'import json; d=json.load(open("ai-bom.json")); d["components"][0]["modelCard"]["modelParameters"]["datasets"][0]["ref"]="missing-reference"; print(json.dumps(d))' > dangling.json
cyclonedx-cli validate --input-file dangling.json --input-format json --input-version v1_6 --fail-on-errors

# 架空のデータIDをモデルIDと重複させる
python3 -c 'import json; d=json.load(open("ai-bom.json")); d["components"][1]["bom-ref"]="model-1"; print(json.dumps(d))' > duplicate.json
cyclonedx-cli validate --input-file duplicate.json --input-format json --input-version v1_6 --fail-on-errors

Check the IDs and references in this example

Save the following small script as check-example.py and run it with python3 check-example.py ai-bom.json. Run the same command with dangling.json and duplicate.json from the previous experiment as well: they report missing-reference and a duplicate model-1, respectively, and both return exit code 1. For the valid example, both results are empty and the exit code is 0.

This code is for illustration only and covers only the structure of this fictional example. It checks only the bom-ref IDs of top-level components directly under components and whether the datasets references in modelCard resolve to existing IDs. It does not validate target types, nested components, BOM-Link, other reference formats, or the accuracy of actual data. For real systems, perform separate checks using methods suited to the relevant structure and specification.

A simple reference check limited to this example
import collections
import json
import sys

data = json.load(open(sys.argv[1], encoding="utf-8"))
components = data.get("components", [])
ids = [item["bom-ref"] for item in components if "bom-ref" in item]
duplicates = [key for key, count in collections.Counter(ids).items() if count > 1]
refs = [
    dataset["ref"]
    for item in components
    for dataset in item.get("modelCard", {}).get("modelParameters", {}).get("datasets", [])
    if "ref" in dataset
]
missing = [ref for ref in refs if ref not in ids]
print("duplicates:", duplicates, "missing:", missing)
sys.exit(1 if duplicates or missing else 0)

Distinguish “recorded” from “correct”

For a real-world AI BOM, cross-check model identifiers and versions against configuration and usage records, and record relationships with evaluation data only when supporting evidence can be verified, such as model cards or evaluation job records. Keep statements in external providers' model cards separate from facts you have directly observed. If training data is not disclosed, do not assume it does not exist. Record it as unverified in a separate tracking sheet or ticket and ask the provider.

Static analysis of a repository alone may miss external models selected through environment variables or runtime routing. Reconcile configuration with usage records, and decide who will update the BOM and what will trigger an update when versions or service destinations change. You do not need to put confidential prompts or user data directly into a BOM intended for sharing.

Before integrating it into operations

Once you have checked the format and references for the first case, gradually expand coverage to the necessary applications, software dependencies, external services, and other relevant items. Even when using a generation tool, check what it discovers and what it misses against the target repository and actual operations. A related article covers tool selection when integrating with an existing DevSecOps pipeline.

Common questions

Is an AI BOM complete once its JSON passes validation?

No. In addition to syntax and specification compliance, separately check the consistency of IDs and references, the evidence supporting the recorded information, and its agreement with the configuration actually running.

Should I use a fictional name if a dataset is not publicly disclosed?

No. Do not invent unverified values. Record only what you can verify, track unverified items separately, and ask the provider.

How Hi AUDIT Agent can help

After putting the BOM into the appropriate format, it is also worth reviewing the application code that supports the AI features recorded in it. With Hi AUDIT Agent, you can request a security analysis from a development environment connected to MCP—for example, a review of a RAG application's search API. You can examine the context around flagged locations and suggested fixes right there, then move on to team review and corrections. BOM generation and validation against its specification should be handled separately, and a person should also verify the analysis results.

Create a Hi AUDIT Agent account