Updated on November 4, 2026
To pick a container vulnerability scanner, test candidates against your own images and choose the one that covers your base images and language packages, cuts noise with fix availability, exploitability and runtime context, and fits where your team builds, stores and runs containers. Most scanners read the same public advisories, so headline CVE counts tell you little. The real differences are how accurately a scanner matches packages to distro advisories, whether it finds the Java, Python or Go dependencies buried inside an image, how it handles unfixed vulnerabilities, and whether it can show which findings matter in production. This guide, updated for November 2026, sets out an evaluation framework, compares 10 tools side by side and ends with a shortlist by use case.
Key takeaways
- ✓A container vulnerability scanner is only as useful as its advisory matching, because a scanner that ignores distro-specific fixes or language packages produces both false positives and blind spots.
- ✓Open-source scanners cover build-time image checks well, while commercial platforms add runtime context, policy governance and remediation workflows.
- ✓Runtime evidence of which packages are loaded and which workloads are reachable is the most effective way to shrink a CVE backlog to the findings worth fixing.
- ✓CI gates should fail builds on exploitability and fix availability, not on severity alone, or developers will learn to bypass them.
- ✓Images must be rescanned continuously after they ship, because new CVEs land on old images every day.
How we evaluated container vulnerability scanners
We judged each tool on what it finds, how accurately it finds it, and how well its output leads to a fix, using documented capabilities, published comparisons and Gartner Peer Insights reviews. Before comparing tools, be clear about what container security scanning reports, because “findings” covers five different things.
| Finding type | What it is | Example |
|---|---|---|
| Vulnerability | A known flaw (CVE) in an OS or language package | An outdated OpenSSL in a Debian base layer |
| Misconfiguration | An unsafe setting in a Dockerfile, manifest or IaC | Container running as root, privileged pod |
| Malware | Malicious binaries or scripts baked into a layer | A cryptominer in a typosquatted public image |
| Secret | Credentials left in the image filesystem or history | An AWS access key in a copied .env file |
| Compliance finding | A failed control against a framework or benchmark | A CIS Docker Benchmark check |
Our criteria, which you can reuse in your own bake-off:
- Scan the same images with every tool: an Alpine image, a Debian or Ubuntu image, a UBI (Red Hat family) image, a distroless image and a Wolfi or Chainguard image, each carrying npm, PyPI, Maven and Go dependencies.
- Compare accuracy: duplicate CVEs reported once per layer, matches that ignore the distro’s backported fix, and how “won’t fix” or unfixed CVEs are labelled.
- Check scan depth: OS packages only, or also language packages, static binaries, secrets and malware.
- Measure speed on a 2 GB image, and how fresh the vulnerability database is (hourly versus daily updates matter during a zero-day).
- Review output quality: SBOM export (SPDX, CycloneDX), VEX handling, fixed-in versions and package paths.
- Test policy controls: severity and fix-based gates, waivers with expiry dates, and exceptions scoped to a package path.
Container vulnerability scanning tools compared
Container vulnerability scanning tools split into commercial platforms that add runtime and cloud context, and open-source scanners focused on build-time image analysis.
| Tool | Model | Scope | Runtime / Kubernetes context | Prioritisation signals | Best for |
|---|---|---|---|---|---|
| Upwind | Commercial CNAPP, eBPF sensor plus agentless | Vulnerabilities, configuration, code scanning, APIs, data and AI | Yes: loaded packages, reachability, live process behaviour | Runtime loading, reachability, exposure | Kubernetes teams with a large CVE backlog |
| Wiz | Commercial CNAPP, agentless | Vulnerabilities, misconfigurations, identity, imported SCA/SAST | Snapshot-based | Toxic combinations, attack paths | Broad multi-cloud estates |
| Aqua Security | Commercial, full agent | Image scanning, secrets, malware, virtual patching | Yes: runtime enforcement | Runtime and exploitation context | Large enterprises with experienced staff |
| Sysdig Secure | Commercial, agent with Falco rules | Pipeline, registry and runtime vulnerability management | Yes | In-use packages, known exploits, fixability | Kubernetes runtime security |
| Clair | Open source | OS packages in images | No | Severity | Registry-side scanning |
| Anchore Engine | Open source (superseded) | Image analysis with policy evaluation | No | User-defined policies | Policy-driven gates |
| Aqua MicroScanner | Free (superseded by Trivy) | Build-time image scan | No | Severity threshold | Legacy pipelines |
| Dagda | Open source | Images, multiple vulnerability sources | Monitors running containers | Severity | Research and labs |
| Trivy | Open source | OS and language packages, IaC, secrets, SBOM | Cluster scanning via an operator | Severity, fix status | Teams wanting one free CLI |
| Grype | Open source | OS and language packages, SBOM input via Syft | No | Severity, fix status | SBOM-first pipelines |
Best container vulnerability scanners for 2026
The best scanners pair accurate image analysis with a clear signal on what to fix first. Each entry below covers what the tool does, where it falls short and who it suits.
Upwind
Upwind is a runtime-first CNAPP whose lightweight eBPF sensor shows which vulnerable packages are loaded, which workloads are reachable, which process just spawned a shell, and which registry and build source a running container came from. It adds agentless coverage in a hybrid model across AWS and Google Cloud, covering hosts, containers and serverless functions. Gartner Peer Insights rates it 4.8/5 from 88 reviews, with reviewers saying it found significant vulnerabilities that their other scanning products missed.
- ✓Prioritises CVEs by runtime loading and reachability, not severity alone
- ✓Vulnerability management, configuration, code scanning, API, data and AI visibility under one SKU, per reviewers
- ✓AI agents (the Agentic Pack) investigate threats, validate exposure and generate fixes
Best for: platform and DevSecOps teams on Kubernetes who need a short, defensible fix list.
Wiz
Wiz is an agentless CNAPP covering AWS, Azure, GCP and OCI. It correlates vulnerabilities with misconfigurations, identities and exposure to find “toxic combinations” and attack paths. It accepts exported SCA and SAST findings into its Security Graph and integrates natively with GitHub, GitLab, Jenkins, Azure DevOps, Terraform, Jira and ServiceNow, including ServiceNow Container Vulnerability Response. Gartner Peer Insights: 4.8/5 from 285 reviews.
- ✓Over 100 built-in compliance frameworks, including PCI DSS, FedRAMP and SOC 2
- ✗Snapshot scanning lacks live execution context; reviewers say detection and response is still maturing
Best for: large multi-cloud organisations consolidating posture tools.
Aqua Security
Aqua Security uses a full agent architecture for runtime visibility and real-time enforcement inside running workloads. It also provides image scanning, secrets management, virtual patching and malware detection across Docker and Kubernetes on AWS, Azure and Google Cloud. Gartner Peer Insights: 4.3/5 from 48 reviews, with several reviewers saying it finds Kubernetes vulnerabilities other assessment tools miss.
- ✓Build-to-runtime coverage with multiple CI/CD assurance points
- ✗Reviewers report onboarding, tuning and scaling friction that needs experienced administrators
Best for: regulated enterprises that want runtime enforcement.
Sysdig Secure
Sysdig Secure prioritises vulnerabilities in packages loaded and running in production, then ranks those with known exploits and available fixes. Runtime detection uses machine learning and Falco-based rules, with pipeline and registry scanning integrations. Gartner Peer Insights: 4.8/5 from 308 reviews; one reviewer noted they can now “prioritize by filtering only the vulnerabilities that are actually in use.”
- ✓In-use filtering cuts the backlog sharply
- ✗Reviewers cite a steep learning curve, premium pricing and time spent tuning threat-detection false positives
Best for: Kubernetes-heavy teams focused on runtime security.
Clair
Clair is an open-source static analyser for container image layers. In a CROZ comparison of Docker image security scanning tools, Clair found the most unique vulnerabilities and was easy to install and integrate into CI/CD pipelines.
- ✓Strong fit for registry-side scanning, as in Quay
- ✗Runs as an API service, so it needs a client for pipeline use, and offers no runtime context
Best for: teams running their own registry.
Anchore Engine
Anchore Engine was the strongest alternative in the same CROZ comparison. It stood out for user-defined policies, broad analysis, a rich API and strong reporting. It has been superseded by Grype, Syft and the commercial Anchore Enterprise.
- ✓Policy-as-code gates that predate most competitors
- ✗New deployments should start on its successors
Best for: existing installs migrating to policy-driven gates.
Aqua MicroScanner
MicroScanner was a free scanner that ran inside the image build and could fail builds on high-severity issues, per the CROZ comparison. Aqua has since replaced it with Trivy.
- ✓Simple severity gate in CI/CD
- ✗No longer the recommended path for new pipelines
Best for: teams maintaining older pipelines.
Dagda
Dagda is an open-source tool that checks images against multiple vulnerability sources and can monitor running containers.
- ✓Combines static analysis with basic runtime monitoring at no cost
- ✗Limited maintenance makes it a poor fit for production governance
Best for: labs, research and learning.
Trivy
Trivy is Aqua’s open-source scanner for images, filesystems, repositories and Kubernetes clusters. It covers OS packages, language dependencies, IaC misconfigurations and secrets, and generates SBOMs in SPDX and CycloneDX.
- ✓One CLI that runs on laptops, in CI and in clusters
- ✗No runtime loading or reachability context, so prioritisation stops at severity and fix status
Best for: startups and teams that want a capable open-source vulnerability scanner.
Grype
Grype is Anchore’s open-source scanner for images and filesystems. It pairs with Syft, so teams can generate an SBOM once and rescan it as new CVEs appear.
- ✓SBOM-first rescanning without pulling images again
- ✗Image scanning only; no misconfiguration or runtime coverage
Best for: pipelines built around SBOMs and attestations.
What to look for in a container security scanner
A good container security scanner matches packages to the right advisories, covers every layer and ecosystem in your images, and turns findings into gates and fixes your developers accept. Whether you’re choosing a Docker vulnerability scanner for one pipeline or a platform for container vulnerability management across clusters, check these points.
Accuracy and coverage
- ✓Distro-specific matching: Debian, Ubuntu and Red Hat backport fixes without changing upstream versions, so generic NVD matching flags patched packages.
- ✓Minimal images: distroless and scratch images have no package manager database, and Wolfi and Chainguard publish their own security feeds; confirm the scanner reads them.
- ✓Language packages and static binaries: Go binaries, fat JARs and vendored Python wheels hide dependencies OS-only scanners never see.
- ✓Deduplication: one CVE present in three layers should be one finding.
- ✓Database freshness: check sources (NVD, GitHub Advisory Database, OSV, distro feeds) and update cadence.
Prioritisation and policy
Good container image scanning should rank by exploitability as well as CVSS, using CISA’s Known Exploited Vulnerabilities (KEV) catalog, EPSS probability, fix availability and runtime reachability. An example CI gate policy:
- Fail the build on any CVE listed in KEV, regardless of severity.
- Fail on critical or high CVEs with a fix available in a package the image actually ships.
- Warn, without failing, when EPSS exceeds an example threshold of 0.1 and no fix exists.
- Allow waivers only with an owner, a reason and an expiry (for example, 30 days), scoped to the package path.
- Accept VEX statements marking a CVE “not affected” to suppress it across every image.
Editor’s tip: Watch for red flags in trials: scanners that inspect only OS packages, tools that need inbound registry access a locked-down or air-gapped network can’t allow, private registry authentication that breaks on token rotation, and vendors who can’t explain how they handle unfixed CVEs.
Supply chain and 2026 readiness
Expect SBOM generation and import, VEX support, scanning of OCI artifacts such as Helm charts, and verification of signed attestations (Sigstore cosign, in-toto) with SLSA provenance, so a scan result can be tied to the exact build that produced the image.
Continuous scanning and container vulnerability remediation
Continuous vulnerability scanning means rescanning images at every stage and after they ship, then routing each finding to a specific fix and owner. An image that passed CI in March can carry a critical CVE by November, so scanning belongs at every point in the lifecycle:
- ✓Developer laptops and pull requests, for fast feedback before merge
- ✓CI pipelines, with the gate policy above
- ✓Registries and artifact stores, rescanning stored images or their SBOMs daily as advisories change
- ✓Admission control in Kubernetes, blocking unsigned or failing images at deploy time
- ✓Runtime, flagging base image drift and confirming which vulnerable packages actually load
For container vulnerability remediation, the strongest tools show the inclusion path of a vulnerable package so developers know how it entered the image. They recommend the minimal upgrade that resolves it, list the fixed-in version and integrate with CI/CD so fixes ship through the normal pipeline. Some can automatically fix vulnerabilities in images and Kubernetes workloads. Look also for base image replacement guidance, fix pull requests, Jira or ServiceNow ticketing and AI-assisted fixes.
Where does an image scanner stop? Scanners report on image contents. Cluster misconfigurations belong to Kubernetes posture tools, cloud exposure to CSPM, and live attacks to runtime detection; a CNAPP joins them so a CVE can be judged against real exposure. Scanning also misses unknown flaws and bugs in your own code, so pair it with application testing. For network and host coverage, see our comparison of broader vulnerability scanning tools.
How Upwind fits your container scanning workflow
Upwind sits after your existing CI scan and turns a long list of image CVEs into the short list that is loaded, reachable and exposed in production. Keep your pipeline scanner for fast developer feedback, and let Upwind’s eBPF sensor connect each running container to its registry and build source so findings reach the team that owns the image. Upwind’s AI agents then validate exposure and draft the fix, so platform engineers spend time on remediation rather than triage. Some Gartner Peer Insights reviewers say Upwind’s SBOM functionality needs further development, so teams whose compliance programme centres on SBOM management should check that fit.
- ✓Runtime evidence of loaded packages and reachable workloads
- ✓Running container traced back to registry and build
- ✓Detection and response on the same sensor as vulnerability data
Which container vulnerability scanner should you pick?
Pick the scanner that matches your team’s scale, environment and risk model. The longest feature list is a poor guide.
| Use case | Shortlist |
|---|---|
| Startups and small teams | Trivy or Grype in CI, adding runtime context as clusters grow |
| Open-source only | Trivy, Grype with Syft, Clair for registry scanning |
| Platform and GitOps teams on Kubernetes | Upwind, Sysdig Secure |
| Regulated enterprises | Upwind, Aqua Security, Wiz |
| Large multi-cloud estates | Upwind, Wiz |
Open-source container image vulnerability scanning covers build-time checks well and costs nothing but engineering time; commercial platforms earn their price once the backlog outgrows your team’s capacity to triage. Run the six-step bake-off above on your own images, apply a KEV- and fix-based gate, and choose the container vulnerability scanner that shows which vulnerabilities are running and reachable, because that is where remediation time pays off.
FAQ
How should you choose a container vulnerability scanner?
Test scanners against your own images and compare advisory matching accuracy, language package coverage, handling of unfixed CVEs, runtime context, policy controls, SBOM and VEX support, and how well each tool fits your CI, registry and runtime workflow.
Why are raw CVE counts a poor way to compare container scanners?
Because most scanners use many of the same public advisory sources, headline CVE totals reveal little. The real differences are package-to-advisory matching, coverage of OS and language dependencies, deduplication, fix status, and whether the tool can show which findings matter in production.
What should CI gates for container vulnerabilities be based on?
The article recommends gating on exploitability and fix availability rather than severity alone. Example rules include failing builds for KEV-listed CVEs, failing on high or critical CVEs with a fix available, warning on high EPSS findings without a fix, and allowing only time-limited waivers with an owner and reason.
Why does runtime context matter in container vulnerability scanning?
Runtime context helps reduce noise by showing which vulnerable packages are actually loaded, which workloads are reachable, and which findings are exposed in production. That makes it easier to shrink a large CVE backlog into a shorter, more defensible remediation list.
Do container images need to be rescanned after deployment?
Yes. New vulnerabilities are disclosed constantly, so an image that passed CI earlier can become vulnerable later. The guide recommends continuous rescanning in developer workflows, CI, registries, admission control, and runtime after images ship.
