Container images have long been the standard delivery format for many web applications: an image bundles the application, runtime environment and system libraries into a fixed package that starts the same way on every host.However, this very bundling creates ongoing maintenance work, because every bundled library may at some point contain a reported security vulnerability.
A report from practice now describes how Red Hat uses AI agents for this work with the Hummingbird project.The stated goal is images without known vulnerabilities, so-called zero-CVE images.The experiences described also make it clear that humans remain indispensable in the process.
Why image maintenance costs so much effort
CVE stands for Common Vulnerabilities and Exposures – a public directory in which known security vulnerabilities are listed with a unique identifier.Scanners check a container image against this directory and report every component for which an entry exists.
The effort arises less during scanning than in everything that follows.Typically this includes:
- Assessing whether a reported vulnerability is even reachable in the specific use case
- Searching for a patched version of the affected library
- Rebuilding the image including dependency resolution
- Regression tests so that the update does not break the application
- Documentation for audit, customers or internal compliance
With a handful of images this is feasible.With several dozen images across different projects, it becomes a permanent task that is rarely prioritised – until a customer demands a release list or a critical vulnerability becomes public.
What agentic AI means in this context
Agentic AI refers to an AI system that not only provides individual answers but independently plans a multi-step task, calls tools and verifies the result.Instead of a chat history, the focus is on a chain of work steps: capture state, propose change, execute change, validate result.
Applied to container security, this pattern fits well because the individual steps are clearly defined and machine-verifiable.Whether an image still produces scanner hits after a rebuild is not a matter of judgement but a clear result.Whether the application still starts afterwards is shown by the test pipeline.An agent therefore receives immediate, objective feedback on its own work – a prerequisite that is missing in many other automation scenarios.
Zero CVE is a goal, not a state
The term zero-CVE image sounds like an end state but describes a snapshot.An image without known vulnerabilities is free of hits only until the next vulnerability in a contained component is published.The value therefore lies not in the label but in the ability to restore the state at short notice.
This shifts the actual metric: what matters less is how many findings an image has today, but how long it takes to build, test and roll out a patched image.Automation contributes directly to this lead time.
Where humans remain in the process
The practical experiences described emphasise that the human role does not disappear.This is consistent with the nature of the task: a scanner hit is a claim about a risk, not a decision.Whether a vulnerability is relevant in one's own operating context, whether a version jump has functional side effects, whether an emergency rollout is justified – these are considerations requiring contextual knowledge that lies outside the image.
A division of labour is therefore sensible: the agent takes over the reproducible, tedious parts – updating dependencies, rebuilding images, cross-checking results, preparing changes as a traceable proposal.Approval and risk assessment remain with people who know the product and its operating environment.
Prerequisites in your own operations
Anyone considering such automation should first check the foundations.An agent can only automate what would be scriptable anyway:
- Reproducible builds: images must be automatically rebuildable from a versioned definition, not through manual steps.
- Meaningful tests: without automated checks, the agent lacks the signal as to whether an update damages the application.
- Inventory: it must be known which images are in use, where they run and who is responsible for them.
- Controlled rollout paths: an automatically built image is of little use if the path to production is manual and rarely taken.
- Traceability: every machine-generated change needs the same audit trail as a human one – via version control and review.
If these building blocks are missing, the first step is not the AI agent but the pipeline underneath.Otherwise you are automating a process that does not work reliably by hand either.
Assessment for web and software projects
For containerised web applications, the development means above all one thing: security maintenance shifts more strongly into the build pipeline and away from irregular manual maintenance windows.Anyone who already has reproducible and tested builds can gradually add agentic automation and significantly shorten the time to a patched deployment.
Anyone who does not yet have this foundation should establish it first – it pays off regardless of any AI tool.
Sources
- AI agents in container security: practical experience — heise developer News