Security teams have invested heavily in software supply chain security. They scan for vulnerabilities, generate software bills of materials (SBOMs), track dependencies and enforce policies to understand and control the software running inside their environments. These capabilities have improved visibility into known risks. Yet an important question remains: how much do organizations really know about the software before deciding to bring it into their applications?
Where did a component come from? How was it built? Is it actively maintained? Can its integrity be verified, and does it meet the requirements of the environment in which it will be used? These questions are becoming harder to answer as software estates grow, dependencies arrive indirectly and AI tools increasingly influence what developers select.
Our new report, State of Software Dependency Trust 2026: From Dependency Management to Verified Software Foundations, examines this challenge through industry research, ecosystem telemetry, documented supply-chain incidents, maintainer research and studies of AI-assisted dependency selection. Its findings point to a growing gap between the security controls organizations have invested in and the evidence available when software is selected.
These findings come from different studies and datasets. They are not a single combined industry benchmark.
How much of your software did your team never actually choose?
In a typical audited commercial application, a significant part of the software estate was never selected directly by its developers. An analysis of 947 commercial codebases found an average of 1,180 open-source components per application. Of those observed components, 64% were transitive dependencies, meaning they entered applications through other dependencies rather than being selected directly. Another 17% sat outside conventional package managers.
A developer may deliberately add one package, but that package can bring in other components, which in turn introduce more dependencies. Over time, the software estate expands well beyond the components anyone explicitly selected or evaluated. This makes it difficult to establish a complete picture of what an application actually contains, let alone assess the origin and condition of every component.
A dependency graph can include inherited packages, vendored material, copied snippets and binaries that may not have passed through the same selection and approval processes as direct dependencies. As the graph grows, organizations have to account for software that entered their applications without an explicit decision by the teams now responsible for maintaining and securing it.
This is where the first gap emerges. Visibility remains an essential starting point, but knowing what is present is not the same as knowing whether it was the right software to bring in.
Are AI-recommended dependencies safe?
Not consistently. Research across more than 10,000 repositories found that only 20% of tested AI-recommended dependency versions were both valid and free of known vulnerabilities. Depending on the model, 44–49% of recommendations carried known vulnerabilities.
The problem goes beyond recommending an outdated or vulnerable version. AI models can also invent package names. Package-name hallucination rates ranged from 4.6% to 6.1% across five frontier models. Researchers found 127 invented package names repeated by all five models, and 53 remained registrable. In a separate sample of 36,870 unique upgrade recommendations, 27.8% of the recommended versions did not exist.
This creates a different kind of software supply-chain risk. A developer following an AI recommendation could attempt to install a package or version that does not exist, or potentially select an attacker-controlled package using a name suggested by a model. This is related to a technique often called slopsquatting, where attackers register package names that AI tools may hallucinate.
The counterpoint is equally important. Grounding recommendations in live registry data reduced high- and critical-risk recommendations by roughly 70%. Adding security tooling increased the safe recommendation rate from 20% to 57%. These results show that the quality of dependency selection can improve when relevant evidence is introduced into the workflow. The findings concern tested models and scenarios, not every AI coding assistant. In this research, safe recommendations were assessed based on validity and known vulnerability status, not every possible compatibility or policy consideration.
AI does not create the underlying dependency-trust problem. It makes the consequences of weak selection evidence more immediate. The selection process itself is increasingly influenced by systems that can recommend and introduce dependencies at machine speed. Authoritative, machine-readable information about package identity, versions and vulnerabilities needs to inform those recommendations at the point of selection. Relying on downstream checks alone risks allowing questionable choices to become embedded before they are evaluated.
The question is no longer just whether developers are choosing secure dependencies. It is whether the tools helping them choose are working with reliable evidence.
Explore the research behind these findings. Our latest report examines how dependency complexity, AI-assisted selection and gaps in verification are changing risk.
Download the ReportIf the fix is available, why does the risk remain?
Approximately 95% of vulnerable component downloads in 2024 registry telemetry had a fixed version available at the time of download. Yet a fix being available does not mean it has been adopted. Compatibility constraints, regression risk, release windows and unclear ownership can all delay remediation.
The broader maintenance picture makes this challenge harder. Across the audited components, 68% were more than two years old, with a median component age of 42 months. Only 7% were running the latest version, while 41% were ten or more versions behind.
The report also found that the mean number of vulnerabilities per audited codebase increased 107%, from 280 to 581. However, the share of codebases containing vulnerabilities moved only from 86% to 87%. The increase in the average count should not be mistaken for a doubling in the proportion of affected codebases.
Dependency risk is partly a lifecycle-capacity problem. Organizations still have to determine whether an update is compatible with their applications, test it, coordinate ownership and deploy it without disrupting production. In older systems, even a relatively straightforward update can involve significant engineering effort. In other cases, the component may no longer be actively maintained, leaving migration, replacement or forking as the only viable options.
The gap between an available fix and an adopted fix tells us something important. Security is not just about identifying a problem. It is also about having the capacity to act on it. Starting with more current, evidence-backed components can help reduce the amount of dependency and remediation debt introduced at adoption. It does not remove the need to maintain and monitor software already in use.
Can software pass a vulnerability scan and still be compromised?
Yes. A component can have no known vulnerabilities and still present a software supply-chain risk. Software reaches organizations through a chain of maintainers, repositories, build systems, publishing accounts and distribution infrastructure. If one of these points is compromised, attackers may be able to alter software before it reaches downstream users.
Recent supply-chain incidents, including the Shai-Hulud campaign and compromises involving widely used developer tooling, have demonstrated how attackers target the channels through which software is built and distributed.
There is another dimension to this problem: the people and processes behind the software. In a review of 47 leading non-npm open-source projects, one or two developers accounted for more than 80% of commits in 40% of projects. This does not mean those projects are compromised. It highlights how concentrated maintenance responsibility can create dependencies on a small number of people and accounts.
These risks expose a limitation in vulnerability-focused security. A vulnerability scan can identify known weaknesses in the software it examines, but it cannot by itself establish that an artifact came from the expected source, was built through the expected process or has remained intact throughout distribution. Those questions require different, complementary forms of evidence:
- Vulnerability status: Does the component have known security weaknesses?
- Authenticity and origin: Is this the expected component, from the expected source?
- Build and delivery integrity: Can we establish how the artifact was produced and whether it remained intact?
A valid signature can help verify the integrity of a signed artifact and associate it with a signing identity. Provenance can provide evidence about its production process. But neither should be treated as a blanket guarantee of security or policy suitability. The absence of known vulnerabilities is not proof that software is authentic or that its production path was secure.
Organizations need to evaluate both the software itself and the evidence behind how it was produced and delivered. Otherwise, a component can pass the checks designed to identify known vulnerabilities while the integrity of the software supply chain remains uncertain.
We generate SBOMs. But are we using them?
SBOM adoption is growing, but organizations still struggle to turn generated inventories into actionable security information. A survey of 334 organizations found that 78% had started their SBOM adoption journey. Yet only 9% had reached a mature, fully automated implementation.
A further 44% reported a moderate gap between generating and consuming SBOMs, while 23% reported a significant gap. Just 7% said they had closed that gap. Supplier transparency was another challenge: 39% of organizations said they never received SBOMs from commercial suppliers, while another 39% received them rarely. Only 10% had mandatory SBOM requirements in supplier contracts.
SBOMs have become an important part of software supply chain security. They help organizations understand the components present in their applications and provide a foundation for software composition analysis (SCA), vulnerability management, compliance and risk management. But generating an SBOM is only the beginning. Its value depends on whether organizations can consume it, connect it to decisions and act on the information it contains.
An SBOM tells us what is in a piece of software. It does not, on its own, establish where that software came from, how it was built or whether it is suitable for a particular use. The objective should not simply be to generate more evidence, but to make relevant evidence accessible and actionable throughout the software lifecycle.
The challenge, then, is not a lack of security tools or information. It is that the evidence produced by these tools often remains fragmented across teams, workflows and stages of the software lifecycle.
What is dependency trust?
Dependency trust is the ability to verify a software component's identity, origin, provenance, integrity, security posture, maintenance condition and suitability before adopting it.
It is not a universal score or a binary label that can be applied to every component regardless of context. The evidence required may differ depending on the component and its intended use. A production component in a regulated application may need a different level of assurance from an internal development tool. What matters is that the basis for the decision is clear, relevant and verifiable.
Organizations have invested in inventory, scanning, signing, provenance, vulnerability management and governance. These controls remain necessary, and each addresses a different part of the software supply-chain problem. But they do not automatically come together to establish whether a specific component or artifact is suitable for adoption.
An SBOM describes composition. Software composition analysis identifies known vulnerabilities. A signature can establish a signing identity and verify the integrity of the signed artifact. Provenance records aspects of how software was produced, while governance defines what is permitted. Each capability contributes valuable evidence, but the challenge is bringing the relevant evidence together early enough to inform the decision.
Effective software supply chain security therefore needs to extend beyond vulnerability detection and include the verification of software identity, origin, provenance, integrity and suitability before adoption.
This is the shift from repeatedly investigating dependencies after they have been adopted to establishing stronger foundations before teams build on them. Evidence can then be assessed, maintained and reused across applications, teams and workflows.
This does not eliminate the need for ongoing monitoring or replace engineering judgment. A verified artifact can still age out of policy, require updates or need additional controls in a particular deployment context. Verification is meaningful only when its scope, evidence, review process and remaining uncertainty are understood.
The central change is not simply adding another security check. It is moving the point at which evidence informs a decision. Instead of treating verification as an investigation that begins after software has entered an environment, organizations can make it part of how components and artifacts are evaluated before adoption.
From dependency management to verified software foundations
The next step in software supply-chain security is not to abandon open source or replace the controls organizations have already built. It is to make verification a more practical part of the foundations on which software is built. Rather than asking every application team to independently investigate commonly consumed components, organizations can make evidence-backed software artifacts available for repeated use, while continuing to monitor and assess the software already in their environments.
At CleanStart, we are working to make verified software artifacts available across modern software development workflows. Clean Images provide hardened, verified container image foundations for applications, while Clean Libraries bring verified libraries and components into developer and AI-assisted workflows. Together, they address two important points in the software lifecycle: the foundations applications run on and the components developers choose to build with.
Both reflect the same direction: making verifiable software foundations easier to consume, so teams can build on components with relevant evidence rather than repeatedly starting their assessment from scratch.
The findings in this report point to a change in where software supply-chain confidence needs to be established. Organizations have made meaningful progress in understanding what is already inside their software. The next challenge is to strengthen the evidence behind what they choose to consume, before those choices become embedded in applications and workflows.
We've invested in knowing what's inside our software. Now we need to know whether the software we're bringing in deserves to be there.
The State of Software Dependency Trust 2026 report examines the evidence behind this shift, the gaps that remain and what it takes to move to a verified software foundations.
Download the ReportAbout the research: The State of Software Dependency Trust 2026 is a secondary-research synthesis drawing on published industry studies, ecosystem telemetry, maintainer and governance research, documented software supply-chain incidents, AI dependency-selection research and official policy sources. It identifies structural patterns rather than creating a composite industry score or a population estimate for all organizations. Findings are drawn from different datasets and should be interpreted within their stated scope and limitations.




