· Ognyan Guglev

SBOM and LMBOM - what is the difference and why we need them

SBOM and LM-BOM - important building blocks for securing modern AI applications.

SBOM

Probably many of you already heard about SBOM. It stands for Software Bill Of Materials. It is a list of every component inside a piece of software, with its version.

Why every product nowadays needs to have an SBOM?

When a new vulnerability is published, the first question is simple: are we running that component? If you have no list, answering takes hours of guessing. An SBOM turns that question into a simple search.

A very popular that I use is called Syft and you can find it in the resources page You can run Syft against a container, folder or a single file (i.e. archive) and then create an output file with the findings.

Then you can use this output file to check each component for known vulnerabilities. One tool that make such scan is called Grype (also can be found in the resources page). It has a function that can work directly with SBOM files.

Practical notes:

  • Scan after every build. An SBOM describes one exact build. An old file does not describe a new image.
  • Keep the file with the release. Store it next to the image version and the commit it came from, so you can answer “what was in version X?” later.
  • Check the packages you expect. Syft finds operating system packages, language libraries that have lock files or metadata, and binaries it can recognise. A component it cannot recognise will be missing from the list, so an SBOM is a strong starting point, not a complete inventory.
  • Verify the tool before you trust its output. Check the checksum of each release, and keep the version number in your records.

What an SBOM does not do

  • It does not find bugs in your own code. Only a code review, tests and static analysis do that.
  • It does not fix anything. Updating the component does.
  • It is only as good as the scan that reads it. A list that is out of date gives a false answer.

LM-BOM

Now, there is another type of Bill of Materials that is becoming increasingly important in AI security: LM-BOM (Language Model Bill of Materials).

An LM-BOM is an inventory of the AI models and related components used inside an AI-powered product or application. It helps you understand exactly which models your application depends on, where they come from, and which versions are being used.

Why should we care about LM-BOM?

AI applications are rarely built around a single model. You might use one model for text generation, another for embeddings, and a third one for reranking or classification. Some might be downloaded from public repositories, others fine-tuned internally, and some consumed through external APIs.

Over time, it becomes difficult to answer a seemingly simple question: What exactly is powering our AI application?

This is where an LM-BOM comes into play.

It is like an inventory of the AI models behind your product. It gives you visibility into the models you use, their origins, versions, providers, licenses, and potentially their training or fine-tuning lineage.

Why does this matter? Because choosing a model is not a one-time decision. Models get updated, providers change their offerings, licenses come with different restrictions, and new security concerns emerge. Without proper documentation, even a small model replacement can introduce dependencies or risks that nobody has explicitly reviewed.

One important distinction worth mentioning is the difference between open-source and open-weight models. These terms are often used interchangeably, but they are not the same. Open-weight models make their trained parameters (weights) available for download and local use, but this does not necessarily mean that their training data, code, or training methodology are publicly available. Open-source models, on the other hand, aim to provide broader access to the components needed to use, study, modify, and redistribute the model, subject to their license. This distinction matters when building an LM-BOM because knowing that a model is downloadable does not automatically tell you how transparent, reproducible, or freely usable it actually is.

An LM-BOM gives development, security, and compliance teams a shared picture of the AI components they are responsible for. Instead of relying on scattered configuration files, deployment manifests, or someone’s memory, you have a documented starting point for understanding your AI supply chain.

Practical notes:

  • Track every model you use. Include locally hosted models, models accessed through APIs, fine-tuned models, and models embedded in third-party services.
  • Record exact versions and sources. Do not just write “Llama” or “Mistral”. Record the specific model, version, provider, and repository or API endpoint. Model aliases and tags can change over time.
  • Keep the file with the release. An LM-BOM should describe the exact models used by a particular application release. Store it next to your application version and build information.
  • Document fine-tuning. If you fine-tune an existing model, record the original model, the fine-tuning process, and the resulting model version. This makes it easier to understand where a model came from.
  • Include third-party dependencies. If your application relies on an external AI provider, document the provider, model identifier, and relevant API configuration. Remember that the provider may change the underlying model without changing the API name.
  • Keep it updated. Whenever you replace a model, change its version, or introduce a new AI provider, update your LM-BOM accordingly.

Tools for generating and inspecting AI BOMs

One interesting project worth checking out is Cisco AI BOM. It is an open-source tool designed to help you discover and document the AI components used in your applications. It can inspect source code, container images, and cloud environments to identify AI-related assets, including models, datasets, agents, and other dependencies. The result is an AI Bill of Materials that gives you a clearer picture of what your AI application actually relies on. You can find it on the resources page.

Another tool I find particularly interesting is AIsbom Inspector. While generating an inventory is important, we also need to inspect the actual model artifacts we download and use. AIsbom Inspector focuses on analyzing model files for potentially dangerous content and security issues. It supports formats such as PyTorch, Safetensors, and GGUF, and can identify risks like unsafe serialization, suspicious model structures, and potentially malicious content. This is especially useful when downloading models from public repositories, where you should not automatically assume that an artifact is safe just because it is publicly available. You can find it on the resources page

What an LM-BOM does not do

  • It does not guarantee that a model is secure. Knowing which model you use does not mean that the model has no vulnerabilities or security weaknesses.
  • It does not detect prompt injection, jailbreaks, or other LLM-specific attacks. You still need dedicated security testing and appropriate safeguards.
  • It does not explain everything about a model’s behaviour. An inventory cannot tell you whether a model will produce biased, harmful, or incorrect outputs.
  • It does not guarantee reproducibility. You also need to track model weights, configurations, dependencies, and other relevant artifacts.
  • It does not replace an SBOM. An AI application still contains regular software dependencies, such as Python packages, operating system libraries, and frameworks. You need an SBOM for those components and an LM-BOM for the AI models.

Summary

SBOM tells you what software components you are running, while an LM-BOM tells you what AI models your application depends on. Both are important building blocks for securing modern AI applications.