A nightly image rebuilds against node:20. Nothing in the Dockerfile changed. But a comparison of today’s SBOM against yesterday’s shows  fourteen modified packages and two removed ones, none of which anyone touched on purpose. That’s SBOM drift, and it happens on pipelines that are working exactly as designed.

An introduction to SBOM drift

SBOM drift is the divergence between the components contained in a software bill of materials (SBOM) and what’s actually running at a later point in time. This article explains why drift happens, where it shows up between build and production, and how to detect it at both points, from comparing successive builds of an image tag to continuously monitoring running workloads. Anchore Enterprise puts these practices into action with the tag_drift policy gate and the anchore-k8s-inventory agent. 

Key takeaways

  • SBOM drift is the gap between the components an SBOM records and what’s actually running later.
  • It shows up in two places: between successive builds of an image tag, and in running workloads after deployment.
  • Anchore Enterprise detects build-time drift with the tag_drift policy gate and runtime drift with the anchore-k8s-inventory agent.
  • tag_drift applies to container image rule sets and needs a previous image with the same tag to compare against.

Why SBOM drift happens

SBOM drift occurs when the software contents associated with an image reference change over time. This commonly happens with floating image tags, which can point to different images as new versions are published.

Example: The latest tag initially points to image_001, containing OpenSSL 3.0.10. Later, latest is updated to image_002, containing OpenSSL 3.0.11. Although the tag remains latest, the underlying image, and therefore its SBOM, has changed.

Floating tags aren’t the only cause. A rebuilt base image or a transitive dependency resolving to a newer version changes an image’s contents the same way, with no change to the application code. None of it requires anyone to edit anything, which is why the SBOM goes stale unnoticed.

Why SBOM drift is a security risk

SBOM drift is a security risk because vulnerability scans run against a component list that no longer matches what’s deployed. A CVE in a package that drifted into production after the last SBOM was generated never gets flagged, and a report built on that stale SBOM shows a clean posture that isn’t accurate. Neither failure requires an attacker, only a routine rebuild. Closing that gap is a core part of software supply chain security best practices.

Two places SBOM drift shows up

Drift happens at two structurally different points, and they require different detection mechanisms:

  1. Build and registry time: Between one build of an image tag and the next. This is detectable by comparing two SBOMs that already exist, generated at two points in your pipeline.
  2. Runtime: Between when an image was deployed and right now, while it’s still running. This isn’t a comparison between two build artifacts. It requires something that continuously knows what’s actually executing in your cluster, independent of what your CI pipeline thinks it deployed.

The next two sections cover each in turn, along with the Anchore Enterprise capability that handles it.

Build-time drift detection 

Build-time drift appears when two builds of the same image tag contain different packages. Catching it means comparing the SBOMs from successive builds and flagging what changed.

Detect changed packages with Anchore’s tag_drift gate

Anchore Enterprise detects build-time SBOM drift with the tag_drift gate, which compares the SBOM of the image being evaluated against the SBOM of the previous image with the same tag, if one exists. The gate is part of the policy engine’s gate-and-trigger model: a rule combines a gate (a category of check), a trigger (a specific condition inside that gate), optional parameters, and an action (STOP, WARN, or GO) that fires when the trigger matches. Anchore Enterprise generates the SBOM automatically when it analyzes an image, and SBOMs can be exported in SPDX or CycloneDX formats.

The gate exposes three triggers:

TriggerChecks forOptional parameter
packages_addedPackages present in the new SBOM that weren’t in the previous onepackage_type
packages_removedPackages present in the previous SBOM that are gone from the new onepackage_type
packages_modifiedPackages present in both, but at a different versionpackage_type

Scope drift detection by package type

The package_type parameter limits a trigger to one kind of package. Without it, every trigger fires against every package type Anchore Enterprise detects, which on a typical image means OS packages (apk, rpm, deb), language packages (npm, pip, gem, and so on), and anything else in the SBOM. Scoping a rule to package_type: apk (or rpm, deb) limits alerts to changes in  the base image’s OS-level packages. That’s where the CVE exposure tends to concentrate, and language-level dependency bumps happen far more often and are frequently intentional.

A rule that fails a build outright when packages change looks like this:

{
  "action": "STOP",
  "gate": "tag_drift",
  "trigger": "packages_modified",
  "params": [],
  "id": "1168b0ac-df6c-4715-8077-2cb3e016cf63"
}

Know the two tag_drift constraints

Two constraints matter here and are easy to miss if you’re working from a general description rather than the gate’s actual behavior:

tag_drift only applies to image rule sets, not SBOM rule sets. If you’re importing externally-generated SBOMs (a CycloneDX or SPDX document handed to you by a vendor, for instance) rather than scanning a container image directly, this gate won’t evaluate against it. Drift detection in Anchore Enterprise is currently an image-scanning capability, not a generic SBOM-comparison capability.

It needs a previous image with the same tag to compare against. If your pipeline mints a unique tag per build, a common and reasonable practice for immutability and traceability, tag_drift has nothing to compare the new build to unless you’re also evaluating a stable tag, like latest or nightly, or an environment tag such as staging, that gets reassigned to each new build in sequence. Decide this before you turn the gate on, not after you notice it’s never firing.

Runtime drift detection 

Runtime drift is the gap between the image that was deployed and what is executing in a cluster now. Detecting it takes continuous visibility into running workloads, not a comparison of two build artifacts.

Track deployed images with Anchore’s anchore-k8s-inventory agent

Anchore Enterprise detects runtime SBOM drift with the anchore-k8s-inventory agent, a lightweight Go binary that uses the Kubernetes Go SDK to poll the Kubernetes API on a configurable interval and list every container running across a configured set of namespaces. It’s deployed it via Helm, from the anchore/k8s-inventory chart hosted at charts.anchore.io, and it runs under a dedicated, read-only service account in the cluster, so broad cluster credentials aren’t needed.

The tag_drift gate answers “did this image change since the last build?” It doesn’t answer “is what’s actually running in the cluster right now still what was deployed?” That’s a different question, and it’s the one most SBOM tooling doesn’t touch, because answering it requires an ongoing presence in the cluster rather than a one-time pipeline check.

For every container it finds, the anchore-k8s-inventory agent  reports back the image digest, the image tag, the pod UID, and the cluster name, for example:

{
  "id": "docker://911d2cf6351cbafc349f131aeef1b1fb295a889504d38c89a065da1a91d828b9",
  "image_digest": "sha256:76049887f07a0476dc93efc2d3569b9529bf982b22d29f356092ce206e98765c",
  "image_tag": "docker.io/kubernetesui/metrics-scraper:v1.0.8",
  "name": "dashboard-metrics-scraper",
  "pod_uid": "c5b40099-20a5-4b46-8062-cf84f9d6ac23"
}

Once you activate a runtime_inventory subscription for your account, Anchore Enterprise automatically analyzes the images the agent reports and surfaces the resulting vulnerability and policy findings on a Kubernetes-aware view in the GUI, broken down by cluster, namespace, node, and pod. This is what actually closes the runtime drift gap: instead of trusting that what got deployed six weeks ago is what’s still running, you get an independent, continuously refreshed answer to that question, sourced from the cluster’s own API rather than your deployment records.

The agent is a licensed add-on and requires a valid runtime license entitlement.

Prevent blind spots with continuous monitoring 

Continuous monitoring of software components means re-checking what’s deployed on an ongoing basis, not only when a new build is produced. Most discussion of SBOM drift treats it as a build-pipeline problem: generate an SBOM with open-source tools, generate another one later, diff them. That’s real, and it’s what tag_drift does. But it only reveals drift between two builds. It says nothing about a container that’s been running unchanged in a cluster for two months while its base image quietly accumulated newly-disclosed CVEs, or one that was patched in place by an on-call engineer outside the pipeline entirely.

Pairing tag_drift with anchore-k8s-inventory is what turns drift detection into continuous monitoring, rather than a checkpoint passed once. One catches drift between artifacts. The other catches drift between what’s assumed to be deployed and what’s actually executing, for as long as it keeps executing. That’s the difference a platform engineer feels at 2 a.m., when a diff shows up outside of any merge trigger, not just the difference a diff report shows at merge time.

How to set up SBOM drift detection

In practice, this comes together in four steps. (Full trigger and parameter reference is in Anchore’s SBOM Drift documentation.)

Configure tag_drift and runtime inventory in Anchore Enterprise

  1. Add a tag_drift rule to your policy, scoped with package_type if you want to start with OS-level packages only, and set to WARN rather than STOP initially so you can see actual drift volume before anything blocks a build.
  2. Make sure the images you’re evaluating share a stable tag across builds (an environment tag or latest) somewhere in your pipeline, even if your primary tagging strategy is per-build and immutable, since tag_drift needs a prior build with the same tag to compare against.
  3. Deploy anchore-k8s-inventory into the clusters you want runtime visibility into, using the inventory-agent role for its credentials rather than a broader admin account.
  4. Activate a runtime_inventory subscription against the relevant account so images the agent discovers get analyzed automatically, not just listed.

We treat this as one part of SBOM automation more broadly: once volume and noise are understood, WARN triggers on the packages that matter most (typically OS packages with known CVE exposure) can move to STOP, and admission control can layer on top for enforcement at deploy time. Anchore Enterprise Notifications can also alert the team that owns the pipeline, sending policy evaluation updates to Slack, Jira, GitHub, Microsoft Teams, email, or a webhook.

How drift detection helps maintain compliance evidence 

Software supply chain security depends on the SBOM being a reliable record of what’s actually deployed. CISA’s 2026 Minimum Elements for a Software Bill of Materials now requires SBOMs to capture generation context and tool provenance, data that only means something if the SBOM reflects a specific, current state rather than a stale build-day snapshot.

This is the exact problem PEO Digital’s DevSecOps platform, Black Pearl, had to solve for the US Navy. An Authorization to Operate under the Risk Management Framework (RMF) requires continuous compliance for the life of the system, not a one-time approval, and it’s the Authorizing Official, not the engineering team, who has to answer for it if a drifted package introduces a vulnerability after ATO was granted. 

The average application carries 500+ open-source components that keep changing underneath it, which is exactly the surface a compliance lead can’t manually track build over build. Using Anchore Enterprise’s continuous monitoring, Black Pearl moved from a slow, manual ATO process to achieving ATO in days by automating the OSS risk tracking that drift detection depends on.

Want to see how the tag_drift gate and runtime inventory would fit your own cluster setup? Talk to our team about walking through the configuration.


SBOM Drift FAQs

What is SBOM drift?
SBOM drift is the gap between the component inventory an SBOM records and the components actually present in the software later, whether that’s between two builds of the same image tag or between deployment and a later point in time. 

Why is SBOM drift a security concern?
SBOM drift means vulnerability scans can run against a component list that no longer matches what’s running, so a CVE in a drifted package goes unflagged. It also leaves a stale SBOM reporting a clean posture that is no longer accurate, which undermines software supply chain security because every downstream check depends on the SBOM matching what’s deployed.

Which tools are best for monitoring SBOM drift in enterprise environments?
Effective tooling for monitoring SBOM drift covers both build-time and runtime drift and alerts the right team when something changes. Anchore Enterprise is a strong fit for organizations running containerized workloads on Kubernetes: the tag_drift gate for successive builds of an image tag, the anchore-k8s-inventory agent for what’s running in a cluster, and Notifications to Slack, Jira, email and webhooks.

How can I detect SBOM drift in my software supply chain?
Compare the SBOM of each build against the previous build of the same image tag. In Anchore Enterprise, the tag_drift gate does this with packages_added, packages_removed, and packages_modified triggers. The older image_source_drift gate is deprecated in v6.x.

Does tag_drift work on imported SBOMs, or only container images?
Only container images. tag_drift is available for image rule sets, not SBOM rule sets, so externally-supplied SBOM documents imported directly aren’t evaluated by this gate.

How can I continuously monitor software components for changes after deployment?
Anchore Enterprise monitors running workloads through anchore-k8s-inventory, an in-cluster agent that polls the Kubernetes API on an interval and reports every running image for automatic analysis via a runtime_inventory subscription.

Should I block builds automatically when drift is detected?
Not immediately. Start tag_drift rules at WARN, scoped by package_type to OS packages first, to establish what normal drift volume looks like before moving specific triggers to STOP.