Engineers with a laptop at automation test rigs in a bright production hall

SBOM

AI-BOM for embedded AI devices: what it is, and what CycloneDX and SPDX actually define

Last updated:

An AI-BOM (AI bill of materials) is a structured, machine-readable inventory of the models, training data and AI-specific configuration a piece of software or firmware embeds, defined today by two independent, concrete schema extensions: CycloneDX's own implementation, called an ML-BOM (machine learning bill of materials), added in CycloneDX v1.5 (26 June 2023), and SPDX 3.0's AIPackage profile. Both build on the same idea as a software SBOM but aim at a component a software SBOM doesn't describe — a trained model baked into the device itself — and as more devices run inference on-device rather than only in the cloud, that gap matters for exactly the same reasons a missing software SBOM does: you can't assess, patch or disclose a component you haven't inventoried.

This guide draws on CycloneDX's own capabilities page, the CycloneDX 1.6 JSON schema and the SPDX 3.0.1 specification pages for schema detail, cross-checked against the OWASP CycloneDX Authoritative Guide to AI/ML-BOM and the Linux Foundation's SPDX AI-BOM research paper. Where this guide and a primary schema differ, the schema wins.

Key takeaways

  • In the CycloneDX 1.6 JSON reference, a model is a component with "type": "machine-learning-model" and an inline modelCard.
  • The two formats model the same facts differently.
  • The document below is synthetic: the camera, firmware, model, dataset and hash are invented for this guide.
  • The runtime is ordinary software with ordinary CVEs, and it parses the model file.

Why doesn't a software SBOM cover an embedded model?

A software bill of materials — see firmware SBOM for how that works on an embedded image without source access — answers "what packages and versions make up this build." It has no concept of a trained model: a binary blob of weights that was produced by a training process, on a specific dataset, to do a specific job, with specific documented limitations. A device that embeds an on-device model for object detection, wake-word recognition, anomaly scoring or similar has real supply-chain and disclosure surface in that model that a software SBOM simply doesn't have a field for — which dataset trained it, whether that dataset's license or provenance is clean, what the model was validated to do versus what it's actually used for in the field, and what inference runtime (and that runtime's own dependencies) loads and executes it.

How do CycloneDX and SPDX each define an AI-BOM?

CycloneDX, an OWASP project and Ecma International standard now at v1.7 (October 2025, Ecma-424 2nd edition), added machine learning support in v1.5 (released 26 June 2023) — see the CycloneDX specification's release history — a machine-learning-model component type sitting alongside the software components CycloneDX already modeled, and a model-card external-reference type whose schema describes covering "the intended uses of a machine learning model, potential limitations, biases, ethical considerations, training parameters, datasets used to train the model, performance metrics, and other relevant data useful for ML transparency." ML-BOM sits in the same family as CBOM (see cryptographic bill of materials), HBOM and SaaSBOM — CycloneDX's broader approach of extending one document model to cover different kinds of components rather than inventing a separate standard per component type.

SPDX 3.0.1 took a parallel but independent path: its AI profile defines an AIPackage class the spec itself summarizes as a class that "specifies an AI package and its associated information," providing metadata that can be added to a package to describe an AI application or trained model. Its properties include domain, autonomyType, standardCompliance and typeOfModel, plus energyConsumption (training and inference energy use) and safetyRiskAssessment, an enumerated High/Medium/Low/Serious categorization the spec ties explicitly to Article 20 of EC Regulation No 765/2008 on accreditation and market surveillance. CycloneDX covers energy use too, but only from v1.6 (9 April 2024), which added environmentalConsiderations.energyConsumptions to the model card; it has no dedicated safety-risk or autonomy field. Neither format is currently named as mandatory by a device-security regulation — see CycloneDX vs SPDX for how the same two-standard situation already plays out for ordinary software SBOMs.

Which CycloneDX fields describe a model and its data?

In the CycloneDX 1.6 JSON reference, a model is a component with "type": "machine-learning-model" and an inline modelCard. Training and evaluation data are separate components with "type": "data", which the model card references by bom-ref:

Field What it records Embedded-device example
name, version, hashes Model identity and a content hash of the shipped file person-detect 3.2.0, SHA-256 of the .tflite file
modelCard.modelParameters.approach.type Learning type: supervised, unsupervised, reinforcement-learning, semi-supervised or self-supervised supervised
modelParameters.task, architectureFamily, modelArchitecture What the model does and how it is built object detection; convolutional neural network; MobileNetV2-SSD
modelParameters.datasets Inline data descriptions or references to data components reference to ds-train
modelParameters.inputs / outputs Input and output formats 320×320 RGB frame in; boxes and scores out
quantitativeAnalysis.performanceMetrics Metric type, value and the data slice it was measured on recall 0.91 on indoor daylight images
considerations users, useCases, technicalLimitations, performanceTradeoffs, ethicalConsiderations, environmentalConsiderations (1.6), fairnessAssessments "recall drops in low light"
data[] on a data component Dataset type (dataset, configuration, source-code, definition, other), classification, sensitiveData, governance internal dataset containing images of people

A model card in CycloneDX is part of the same JSON document as the firmware SBOM, so one validator, one signature and one release pipeline cover both.

How do CycloneDX ML-BOM fields map to SPDX 3.0.1?

The two formats model the same facts differently. SPDX puts AI metadata on an AIPackage and describes datasets with a separate DatasetPackage, linked through relationship types such as trainedOn and testedOn. The mapping below is SoftWSP's reading of the two specifications, not an official crosswalk:

Fact CycloneDX 1.6 SPDX 3.0.1
Model identity component name, version, hashes name, packageVersion, verifiedUsing
Training data modelParameters.datasets → data component DatasetPackage + trainedOn relationship
Test data datasets plus performanceMetrics.slice DatasetPackage + testedOn relationship
Known limitations considerations.technicalLimitations limitation
Metrics quantitativeAnalysis.performanceMetrics metric, metricDecisionThreshold
Energy use considerations.environmentalConsiderations energyConsumption
Personal data data[].sensitiveData useSensitivePersonalInformation, hasSensitivePersonalInformation
Safety risk level properties (no dedicated field) safetyRiskAssessment
Human oversight properties (no dedicated field) autonomyType

One practical difference: an SPDX 3.0.1 AIPackage must carry releaseTime, suppliedBy, downloadLocation, packageVersion and primaryPurpose, so a converter that only has CycloneDX input needs those values from somewhere.

What does an ML-BOM for a device firmware image look like?

The document below is synthetic: the camera, firmware, model, dataset and hash are invented for this guide. It describes a home camera whose firmware ships a quantized person-detection model and the runtime that executes it, and it validates against the official bom-1.6.schema.json:

{
  "bomFormat": "CycloneDX",
  "specVersion": "1.6",
  "serialNumber": "urn:uuid:3e671687-395b-41f5-a30f-a58921a69b79",
  "version": 1,
  "metadata": {
    "component": { "type": "firmware", "bom-ref": "fw",
                   "name": "examplecam-c200-firmware", "version": "2.4.1" }
  },
  "components": [
    { "type": "library", "bom-ref": "rt", "name": "tflite-runtime",
      "version": "2.14.0", "purl": "pkg:pypi/[email protected]" },
    { "type": "machine-learning-model", "bom-ref": "model",
      "name": "person-detect", "version": "3.2.0",
      "hashes": [ { "alg": "SHA-256", "content": "0000000000000000000000000000000000000000000000000000000000000000" } ],
      "modelCard": {
        "modelParameters": {
          "approach": { "type": "supervised" },
          "task": "object-detection",
          "architectureFamily": "convolutional neural network",
          "modelArchitecture": "MobileNetV2-SSD, int8 quantized",
          "datasets": [ { "ref": "ds-train" } ],
          "inputs": [ { "format": "image, 320x320 RGB" } ],
          "outputs": [ { "format": "bounding boxes with person score" } ]
        },
        "quantitativeAnalysis": {
          "performanceMetrics": [ { "type": "recall", "value": "0.91", "slice": "indoor, daylight" } ]
        },
        "considerations": {
          "useCases": [ "Trigger recording when a person enters the frame" ],
          "technicalLimitations": [ "Recall drops in low light and for partially occluded people" ]
        }
      } },
    { "type": "data", "bom-ref": "ds-train", "name": "indoor-people-v5",
      "data": [ { "type": "dataset", "name": "indoor-people-v5",
                  "classification": "internal", "sensitiveData": [ "images of people" ] } ] }
  ],
  "dependencies": [
    { "ref": "fw", "dependsOn": [ "rt", "model" ] },
    { "ref": "model", "dependsOn": [ "rt" ] }
  ]
}

Three details carry most of the value. The hashes entry lets anyone confirm that the model file in a given image is the one described. The dependencies block records that the model needs that exact runtime, so a runtime CVE can be traced to the model and the firmware. And technicalLimitations turns a lab observation into something a support or safety team can read. The runtime's package URL is what vulnerability matching keys on.

Why does the inference runtime matter as much as the model?

The runtime is ordinary software with ordinary CVEs, and it parses the model file. CVE-2022-23559 (GitHub advisory GHSA-98p5-x8x4-c9m5) is a typical case: a crafted TensorFlow Lite model could trigger an integer overflow in embedding lookup and, in some cases, a heap out-of-bounds read or write; it was fixed in TensorFlow 2.5.3, 2.6.3 and 2.7.1 (NVD lists a CVSS 3.1 base score of 8.8). Runtimes in this space include Google's LiteRT (Google publishes a migration path from TensorFlow Lite to it) and ONNX Runtime, plus vendor-specific NPU libraries.

Treat the model file as input. If a device can download or accept a new model, the runtime's parser is attack surface, exactly like an image or firmware-update parser. Sign models and verify them before loading; see model signing with Sigstore.

Why does this matter for a device maker?

On-device inference in cameras, voice-enabled appliances, predictive-maintenance sensors and industrial gateways means the model and its runtime are now part of what ships, not an external service call a software SBOM would already catch. Customers asking for an SBOM increasingly ask what the AI component is, where it came from and how it was tested. Where that device also meets the definition of a high-risk AI system under a regime like the EU AI Act, its documentation duties around training data and methodology add a legal reason to have this inventory, on top of the security one.

What should a device maker record first?

  1. Record model identity first: version, a content hash, and where the model file actually lives in the firmware image — the same baseline discipline firmware SBOM applies to every other component.
  2. Capture training-data provenance and license, even at a summary level, before a customer or auditor asks and you have to reconstruct it after the fact.
  3. Keep the model card fields— intended use, known limitations, documented biases — next to the model, not in a separate document nobody updates when the model changes.
  4. Track the inference runtime as a normal software component: it has its own version, its own CVEs, and belongs in the same SBOM process as everything else in the image.
  5. Flag embedded AI API keys or cloud-inference endpoints explicitlyA key baked into firmware is a credential-management problem with the same blast radius as any other hard-coded secret.
  6. Reuse your existing SBOM tooling if you canIf you already emit CycloneDX, adding ML-BOM components to the same document is less overhead than adopting a second, AI-only format.

What are the common pitfalls?

  • A model with no hash. Without one, "version 3.2.0" cannot be tied to the bytes in a given image, and a silent retrain looks identical.
  • The runtime is missing from the SBOM. When a runtime is compiled in as a static library, package-based extraction may not see it. Add it by hand with a version and identifier.
  • Model cards written once. A retrain changes metrics and limitations; regenerate the card with each model release.
  • Dataset descriptions that expose data. Describe the dataset (source, licence, sensitivity), do not embed or link the raw data in a document you share with customers.
  • Two formats, two truths. If a customer needs SPDX as well, generate it from the same source record rather than maintaining both by hand.
  • Vulnerability status left implicit. When a runtime CVE does not affect the device, say so in a VEX statement with the engineer's justification.

Which parts can a firmware SBOM tool cover?

SoftWSP extracts an SBOM from the firmware image, writes it as CycloneDX 1.6 JSON, and matches the components against NVD, CISA KEV, FIRST EPSS and CISA's CSAF ICS advisories; the AI-drafted report cites the record behind each finding for an engineer to check. An inference runtime that the extractor identifies as a package is matched like any other component. SoftWSP does not write machine-learning-model components or model cards: model identity, dataset provenance and limitations come from the team that trained or integrated the model, and are added to the same CycloneDX document. See device firmware security.

This guide draws on CycloneDX's own published capability page, JSON schema and GitHub release history and the SPDX 3.0.1 specification's AIPackage and DatasetPackage pages, cross-checked against the OWASP CycloneDX Authoritative Guide to AI/ML-BOM and Linux Foundation Research's SPDX AI-BOM paper. This guide is not a substitute for the CycloneDX or SPDX specifications themselves, or a specific regulation's own documentation requirements.

Put this guide to work

Frequently asked questions

What is an AI-BOM, and how is it different from a regular SBOM?

A software bill of materials lists the packages, versions and licenses that make up a piece of software — exactly what [firmware SBOM](/guides/firmware-sbom/) covers for an embedded image. It says nothing about a trained machine learning model that firmware might also embed: which dataset trained it, what it was built to do, what its documented limitations or biases are, or what runtime loads and executes it. An AI-BOM (CycloneDX calls its implementation an ML-BOM, Machine Learning Bill of Materials) extends the same component-inventory idea to that model. CycloneDX's own capabilities page describes the goal as "model and dataset transparency for security, privacy, safety and ethical considerations," covering datasets (with their provenance and ethical considerations), models (training methodology and configuration) and the AI frameworks that run them — the same kind of structured, machine-readable inventory a software SBOM provides, aimed at a different kind of component.

Which standard actually defines an AI-BOM — CycloneDX or SPDX?

Both, as separate, independently maintained extensions to formats SoftWSP's audience likely already produces software SBOMs in. CycloneDX, an OWASP project and Ecma International standard (Ecma-424), added machine learning support in version 1.5, released 26 June 2023: a dedicated machine-learning-model component type, and a model-card external-reference type the schema describes as covering "the intended uses of a machine learning model, potential limitations, biases, ethical considerations, training parameters, datasets used to train the model, performance metrics, and other relevant data useful for ML transparency." The current specification is v1.7 (October 2025). Separately, SPDX 3.0.1 defines an AIPackage class in its AI profile, which its own specification summarizes as a class that "specifies an AI package and its associated information," with properties including domain, autonomyType, standardCompliance, typeOfModel, and two notable fields: energyConsumption (training and inference energy use) and safetyRiskAssessment (a High/Medium/Low/Serious categorization the spec ties to Article 20 of EC Regulation No 765/2008). As of 20 November 2026 neither format is named as mandatory by a specific device-security regulation: the EU [Cyber Resilience Act](https://eur-lex.europa.eu/eli/reg/2024/2847/oj) asks for an SBOM "in a commonly used and machine-readable format" and leaves any specific format to later Commission implementing acts. They are the two concrete, machine-readable candidates a buyer, auditor or regulator asking for AI transparency can point at, much as [CycloneDX and SPDX](/guides/cyclonedx-vs-spdx-sbom-formats/) are for software SBOMs generally.

Why would a device or firmware maker need an AI-BOM specifically?

Because more devices now ship with an embedded model doing real work on the device itself — on-device object or anomaly detection in a camera, wake-word and voice processing in a smart speaker or appliance, predictive-maintenance scoring in an industrial sensor or gateway — and none of that is visible in a conventional software SBOM. The model file, any bundled or referenced training/fine-tuning data, the inference runtime (such as a TensorFlow Lite, ONNX Runtime or vendor-specific library) and any API keys or endpoints the firmware uses to reach a cloud inference service are all supply-chain surface a software-only SBOM misses entirely — which is exactly why SoftWSP's own firmware security assessment treats "AI models, inference runtimes and API keys or tokens embedded in the image" as a distinct check alongside the software SBOM, not a subset of it. Where a product also happens to be a high-risk AI system under a regulation like the [EU AI Act](/guides/eu-ai-act-cybersecurity-requirements/), the documentation duties that regime imposes on training data and methodology are a separate, legal driver pointing at the same underlying inventory.

What should a device maker actually record in an AI-BOM today?

Start with what both standards already define fields for, even before picking one: the model's identity, version and a content hash; where its training or fine-tuning data came from and under what license or usage terms; its documented intended use and known limitations (the same information a model card captures); the inference runtime and any software dependencies it pulls in, which belong in a software SBOM either way; and whether the firmware calls out to a hosted inference API, and with what credential. If the device maker already emits CycloneDX SBOMs for its firmware, adding ML-BOM's machine-learning-model components to the same document is the lower-effort path, since a CycloneDX AI-BOM is, in practice, an ML-BOM emitted in the same document model as the software SBOM — one inventory covering both, rather than two separate processes to maintain. [Cryptographic bill of materials](/guides/cryptographic-bill-of-materials-cbom/) is the closest precedent for how fast a narrow, device-focused BOM extension can go from "optional CycloneDX feature" to something buyers and regulators specifically ask for by name.

Sources

  1. CycloneDX: AI/ML-BOM capability (cyclonedx.org)
  2. OWASP CycloneDX: Authoritative Guide to AI/ML-BOM (PDF)
  3. CycloneDX/specification: Releases (GitHub) — v1.5 (26 June 2023) ML-BOM addition, current v1.7
  4. SPDX Specification 3.0.1: AIPackage class (AI profile)
  5. Linux Foundation Research: Implementing AI Bill of Materials (AI BOM) with SPDX 3.0
  6. CycloneDX 1.6 JSON reference (modelCard, componentData, environmentalConsiderations)
  7. SPDX Specification 3.0.1: DatasetPackage class (Dataset profile)
  8. GitHub Advisory GHSA-98p5-x8x4-c9m5 / CVE-2022-23559: Integer overflow in TFLite
  9. Google AI Edge: LiteRT on-device runtime (with TensorFlow Lite migration guide)
  10. ONNX Runtime project site
  11. Regulation (EU) 2024/2847 (Cyber Resilience Act), Official Journal — Annex I Part II(1) SBOM requirement
Was this guide helpful?

In this cluster

AI-BOM for embedded AI devices: what it is, and what CycloneDX and SPDX actually define