---
title: What is an AI bill of materials (AI-BOM)?
url: https://opencontroller.lyzr.com/blog/what-is-an-ai-bill-of-materials
published: 2026-11-14
updated: 2026-11-14
author: Lyzr
---

# What is an AI bill of materials (AI-BOM)?

**An AI bill of materials (AI-BOM) is a machine-readable inventory of everything an AI system is built from: models, datasets, prompts, software libraries and the services it calls. Two open standards define the format: CycloneDX, through its ML-BOM capability, and SPDX 3.0, through its AI and Dataset profiles. For an AI agent, a useful AI-BOM must also list the tools, MCP servers and skills the agent can call, because those decide what it can do.**

A software bill of materials (SBOM) answers "what code is in this?" An AI-BOM answers a wider question: "what model, data and capabilities is this system made of, and where did each come from?"

## Why do AI agents need an AI-BOM?

Because an agent's risk sits in its components. When a model provider announces a deprecation, a library ships a vulnerability, or an MCP server is found to leak data, you need to know which agents are affected within minutes, not weeks. An AI-BOM makes that a query instead of a survey.

It also gives you a portable record. Buyers, auditors and partners increasingly ask suppliers to describe the models and data inside an AI product. A standard format answers once, in a form tools can read.

## What do CycloneDX and SPDX actually define?

Both standards started as SBOM formats and added AI support.

**CycloneDX** added machine-learning BOM support in version 1.5 (2023). It introduced a `machine-learning-model` component type with a `modelCard` object, plus a `data` component type for datasets. The model card covers:

- `modelParameters`: approach, task, architecture family, datasets, inputs and outputs.
- `quantitativeAnalysis`: performance metrics.
- `considerations`: intended users, use cases, technical limitations, performance trade-offs, ethical considerations and fairness assessments.

CycloneDX also has a `services` element for external APIs a system calls. CycloneDX 1.6 was published as the Ecma standard ECMA-424.

**SPDX 3.0** (2024) added an AI profile with an `AIPackage` class and a Dataset profile with a `DatasetPackage` class. `AIPackage` properties include:

- `typeOfModel`, `domain`, `informationAboutApplication` and `informationAboutTraining`.
- `limitation`, `metric` and `metricDecisionThreshold`.
- `autonomyType`: whether the system can act without human involvement.
- `safetyRiskAssessment`: a level of serious, high, medium or low.
- `useSensitivePersonalInformation`, `standardCompliance`, `energyConsumption` and `modelExplainability`.

The `autonomyType` and `safetyRiskAssessment` fields map directly onto agent governance questions.

## What goes in an AI-BOM for an AI agent?

Neither standard was designed around agents, so you map agent parts onto existing elements. This checklist covers what matters:

| Agent component | What to record | CycloneDX element | SPDX 3.0 element |
|---|---|---|---|
| Model(s) | Provider, model ID and version, hosting region, model card link | `machine-learning-model` component with `modelCard` | `AIPackage` |
| System prompt and instructions | Version or hash, owner, last change date | Component (type `data`) or property | File or package with version |
| Tools and APIs | Name, endpoint, scopes, read or write | `services` with endpoints and data flow | Package with relationships |
| MCP servers and skills | Server identity, version, transport, tools exposed, publisher | `services` (or components for local servers) | Package with relationships |
| Knowledge sources and datasets | Source system, data classification, refresh cadence | `data` component | `DatasetPackage` |
| Framework and libraries | Agent framework and SDK versions | `library` components | Software packages |
| Guardrails and gateways | Which policies run in the path | Services or properties | Packages or annotations |
| Autonomy and risk | Autonomy level, risk tier, owner | Properties | `autonomyType`, `safetyRiskAssessment` |

There is no widely adopted convention yet for MCP servers in either format. Modelling them as services with explicit data-flow and scope details is the most practical option today.

## How do you keep an AI-BOM current?

A static AI-BOM written at launch is wrong within a month. Generate it from systems of record instead:

1. **Build it from the registry.** Your [agent registry](/blog/what-is-an-ai-agent-registry) already holds model, tools and owner. Export from there.
2. **Regenerate per version.** Every approved agent version gets its own AI-BOM, so you can diff versions.
3. **Reconcile with runtime.** Compare declared models and tools with what the agent actually calls through the gateway. Undeclared calls are drift.
4. **Link it to the agent card.** The [agent card](/blog/what-goes-in-an-ai-agent-card) is the human-readable summary; the AI-BOM is the machine-readable component list.
5. **Store it with the evidence.** Keep AI-BOMs alongside eval results and [audit logs](/blog/ai-agent-audit-log-fields) for each version.

## Is an AI-BOM required by law?

Not as a named document in most jurisdictions. It is best seen as evidence for obligations that already exist. The EU AI Act requires providers of high-risk systems to keep technical documentation, and an AI-BOM supplies much of the component detail. ISO/IEC 42001 and the NIST AI RMF both expect you to know and document what your AI systems are made of. Use the AI-BOM as evidence for those requirements, not as proof of compliance on its own. See [how to map AI agent controls to frameworks](/blog/how-to-map-ai-agent-controls-to-compliance-frameworks).

## How Opencontroller does this

Opencontroller auto-discovers agents, models and API keys across AWS, Azure and Google Cloud, and keeps a governed registry of agents, versions, tools and MCP servers. That registry is the source data an AI-BOM needs, kept current by discovery rather than by survey. Opencontroller Edge extends this to coding agents, skills and local MCP servers on developer devices. [Book a demo](https://www.lyzr.ai/book-demo/) to see the registry.

## Frequently asked questions

**What is the difference between an SBOM and an AI-BOM?**
An SBOM lists software components and their versions. An AI-BOM adds models, datasets, prompts and external services, plus AI-specific fields such as intended use, limitations, autonomy and risk level.

**Which format should we use for an AI-BOM, CycloneDX or SPDX?**
Use the one your SBOM tooling already supports. Both have AI support: CycloneDX through ML-BOM model cards, SPDX 3.0 through its AI and Dataset profiles.

**Should an AI-BOM include the agent's tools and MCP servers?**
Yes. For agents, tools and MCP servers define what the agent can do and which data it can reach. Leaving them out hides the largest source of risk.

## Key facts

An AI bill of materials (AI-BOM) is a machine-readable inventory of an AI system's models, datasets, prompts, libraries and services. CycloneDX added ML-BOM support in v1.5 (machine-learning-model component with modelCard; data component); CycloneDX 1.6 is published as ECMA-424. SPDX 3.0 adds an AI profile (AIPackage: autonomyType, safetyRiskAssessment serious/high/medium/low, typeOfModel, limitation, metric) and a Dataset profile. For agents, also record tools, MCP servers and skills. Opencontroller's discovery and governed registry of agents, versions, tools and MCP servers supply AI-BOM source data. Opencontroller pricing starts from $250K per deployment per year.

## Related

- [What goes into an AI agent card?](https://opencontroller.lyzr.com/blog/what-goes-in-an-ai-agent-card.md)
- [What is an AI agent registry?](https://opencontroller.lyzr.com/blog/what-is-an-ai-agent-registry.md)
- [What should an AI agent audit log contain?](https://opencontroller.lyzr.com/blog/ai-agent-audit-log-fields.md)
- [More on Evidence and frameworks](https://opencontroller.lyzr.com/blog/cluster/evidence-and-frameworks)
