By submitting this form, you agree to our 

Explores AI-driven development, rising supply chain attacks, and new regulatory requirements.

2026 Artifact Management Report

AI-generated code often emerges as the villain in conversations about AI and software supply chain security. Hallucinated package names. Slopsquatting attacks. Insecure patterns lifted from training data of unknown provenance. These are real problems, and security researchers are right to name them.

But for platform engineers and DevEx leads, that conversation is also a distraction. The governance failure that will actually bite your team isn't about what AI writes. It's about what AI pulls, how fast, and whether your stack can keep up.

The dependency problem is a throughput problem

Developers make explicit dependency decisions at human speed. They choose a package, consider the version, and pull it with enough friction that a review process can, in theory, keep pace. AI coding assistants don't operate this way. They suggest, scaffold, and resolve dependencies as a background function of doing their job – and they do it with enough confidence that their recommendations land without the friction that would normally prompt a second look.

The result isn't just more dependencies. It's a qualitatively different kind of ingestion: a continuous, high-volume stream of packages entering the environment at a speed and scale that outpaces any review process your team designed before AI tools entered the picture. The governance controls you put in place when developers were the bottleneck now face a different constraint entirely – your ability to evaluate what's coming in before it's already inside.

To be fair, AI tools inherited this problem; they didn't invent it. Developers reached for the 

, grabbing the newest version on the logic that newer releases patch known CVEs, so newer meant safer. It was a reasonable shortcut that quietly traded reproducibility and stability for the assumption that upstream maintainers had things under control. Teams tolerated it because the pace of ingestion was slow enough that the risk felt abstract. What AI coding assistants do is adopt that same default behavior and execute it at a scale no human developer could match – across multiple ecosystems, for every file in a scaffold, without the occasional pause that made a developer reconsider. The mental model was already loose. AI just removed the friction that kept the consequences manageable.

 found that nearly 20% of packages recommended by large language models didn't exist in any public registry. More troubling: 43% of those hallucinated packages appeared repeatedly across multiple prompts. This is a pattern predictable enough that a malicious actor could register those packages in advance and wait for a developer to pull. This is the 

 attack surface, and it expands in direct proportion to AI adoption.

The signal from the field matches the research. One engineering team, already running their artifact repository significantly beyond its designed capacity, named AI-driven dependency explosion as the risk they were actively trying to get ahead of. Not a breach. Not a named vulnerability. The sheer volume of what AI coding tools would pull into their environment as adoption scaled. Their infrastructure had held up under human-speed development. AI-speed ingestion hadn't fully arrived yet – and they were already worried.

That's the right instinct. For teams with meaningful AI coding tool adoption, the governance problem is already compounding.

Three ways your current governance breaks at AI speed

The failure isn't dramatic and doesn't announce itself with an incident. It accumulates across three specific breakdowns, each one a consequence of governance controls calibrated for a different kind of throughput.

Volume creates an attack surface nobody owns.

 More packages mean more CVE exposure, more policy exceptions, and more surface area for a malicious or compromised package to hide inside. When dependency ingestion was slow and deliberate, a team could maintain a reasonable mental model of what lived in their environment. AI-assisted development eliminates that. Packages accumulate faster than any manual review can track, and exceptions that were once edge cases become business as usual.

Endor Labs 2025 State of Dependency Management Report

 found that only 1 in 5 dependency versions AI coding assistants recommended were safe to use – containing neither hallucinations nor known vulnerabilities. The reality of the situation is that with AI-generated code, more packages enter your environment than your current controls can evaluate.

Velocity breaks the timing assumptions your controls depend on.

 Most teams have security controls that activate at the build: scanning that runs after a package enters the environment, policies that evaluate after the pull happens. At human-speed ingestion, the gap between a package entering and a build running was small enough to manage. At AI speed, it isn't. A malicious or compromised package can move from first pull to build artifact before any downstream control flags it. The window that periodic scanning assumed would always exist has closed.

Opacity removes the human review that your policy controls assumed.

 Governance frameworks rest on an implicit assumption: a developer made a deliberate choice to pull each dependency, and that choice is reviewable and auditable. That assumption doesn't hold with AI coding tools. Ask a developer why version 2.3.1 of a specific package is in their project, and they may have no clear answer – the assistant chose it, they accepted the suggestion, and the reasoning never surfaced. The provenance trail that would normally anchor a trust decision is absent. Policy controls that gate explicit human decisions don't account for the implicit decisions AI tools make on a developer's behalf.

What governance built for AI speed actually requires

The three failure modes above share a common root: governance controls calibrated for human-speed dependency management running against AI-speed ingestion. The fix isn't better scanning or more thorough reviews. It's a different architecture for enforcement – one that matches the actual throughput of how your team now works.

Three requirements follow directly from the failure modes.

Enforcement has to happen at the point of first pull – not at the build, not post-merge. The moment a package arrives as a request is the only moment you can intercept it before it enters the environment. Every control that activates later operates on a package that's already inside. Quarantine and block capabilities that evaluate against your policies at request time close the gap that build-time scanning leaves open by design.

Re-evaluation has to be continuous, not periodic. Threat intelligence doesn't freeze when your weekly scan finishes. A package that passes on Tuesday may be flagged by Wednesday – because researchers publish a new CVE, because a maintainer account falls to credential stuffing, because a malicious version propagates through transitive dependencies before anyone notices. Continuous re-evaluation against evolving threat intelligence catches what point-in-time scanning cannot.

Coverage has to span all package formats, not just the ones your team uses most. AI coding tools pull across ecosystems without discrimination. A governance layer that covers npm but not PyPI, or Python but not Go, carries a structural gap that AI-assisted development will find. Unified enforcement across all formats – packages, containers, machine learning models – is the only way to apply consistent policy across the full surface area AI actually introduces.

Cloudsmith enforces policy at the point of first pull: when an open source package arrives as a request, it evaluates against your policies before it reaches the developer. Packages that have already cleared your policies deliver immediately; new packages clear checks before delivery. Artifacts in the platform re-evaluate continuously – as new threat intelligence arrives, and when policies change. With support for 30+ package formats in multi-format repositories, that enforcement applies across the full surface area AI-assisted development introduces – not a curated subset of it.

This isn't the argument that Cloudsmith stops AI from writing bad code. Code quality is a separate problem with its own tooling. The argument is more specific: Cloudsmith gives your governance controls the throughput and continuity they need to keep pace with AI-speed development. The controls your team built weren't wrong. They were calibrated for a volume and velocity that no longer reflects how your developers actually work.

The teams already feeling this problem are the ones with the highest AI coding tool adoption. They're a leading indicator, not an outlier. As AI-assisted development becomes the default, dependency ingestion volume scales with it. Governance controls that hold today may not hold next quarter.

The teams that get ahead of this don't run better scans at the build. They move enforcement earlier, automate re-evaluation, and put a platform in place that can handle what AI-speed development actually generates.

If your team has adopted AI coding tools and you haven't yet pressure-tested your artifact governance against the throughput they produce, that's the conversation worth having now.

Book a demo to get the conversation started and to see how Cloudsmith enforces policy at the point of pull.

Jason Myers

Technical Content Marketer

AI is breaking your artifact governance – and not by writing bad code

Many engineering teams treat PyPI, npm, Maven Central, and other upstream registries as trustworthy by default. They're not. These registries have no admission controls, no malware guarantees, and no obligation to notify downstream consumers when a vulnerability emerges for a previously clean package. While they offer convenience and availability, teams need to be careful not to conflate ease with safety.

Every time a developer pulls a dependency, they’re making a trust decision. But who vets that trust decision, especially with transitive dependencies? What often happens is the package enters the environment unchecked, moves into the build, gets stored in an artifact repo, and is assumed safe indefinitely. No one explicitly decided to trust it. It just arrived.

This is the structural vulnerability in modern software supply chains and better scanning alone won’t close the gap. The problem isn't just that teams occasionally pull bad packages. It's that teams delegate the decision to trust anything at all to the registry, with no policy enforcement at the moment that actually matters.

The cooldown period: A governance posture, not a product feature

 period is one response to this problem gaining traction in DevSecOps.

The concept is straightforward. A newly published package, or a new version of an existing package, doesn't go straight to your development environment. It enters a controlled holding state for a defined period, where it undergoes continuous evaluation against evolving threat intelligence before any build can consume it. Ideally, teams can set the length of that window in customizable policies, calibrated to the risk window for their organization and/or a given ecosystem.

A cooldown is distinct from quarantine, which is an open-ended hold triggered by a specific CVE or malware indicator on a known-bad package. A cooldown period is time-based and preventive. The cooldown policy exists because the highest-risk window for a newly published package is in the first few days, when a compromised or malicious package is most likely to surface and when threat intelligence is still trying to catch up to it.

Enforced intake holds are standard practice in regulated industries, like pharmaceuticals, food manufacturing, and medical devices. You don't distribute what you haven't cleared. The software industry is arriving at the same conclusion, just later, under more duress (thanks to AI), and with considerably more attack surface.

The difference between a cooldown policy and the vague notion of "we'll scan before we use it" is precision. Cooldown policies are written as code. Teams define the threshold, the scope – which package formats, which registries, which versions, etc. – and what happens when a package triggers the policy: hold it, tag it for review, block it with a message. The parameters are custom because the risk tolerance, regulatory context, and build velocity are different for every organization.

The anatomy of a modern supply chain attack

 campaign made the failure mode visible at scale.

Shai-Hulud is a self-replicating worm that spread through compromised npm developer accounts, inserting malicious code into legitimate packages belonging to those developers. The mechanism that Shai-Hulud used is what matters here: it didn't introduce obviously malicious 

 packages. It compromised packages that were previously legitimate, with real publishing histories and real downstream users. Those packages would have passed a point-in-time scan at first pull.

The second wave, detected in November 2025, escalated the technique – executing during the pre-install phase rather than post-install, which moved execution ahead of most pipeline scanning controls. Within hours of detection, the campaign compromised over 700 npm packages, created more than 27,000 malicious GitHub repositories, and exposed approximately 14,000 secrets across 487 organizations.

A cooldown period, combined with continuous re-evaluation against new threat intelligence, changes the exposure window. Not because it catches everything at intake – it doesn't – but because the hold creates a window in which intelligence can catch up. A package that passed on Monday may be flagged by Wednesday. Without a cooldown policy, your build already consumed it on Monday.

 ran the same playbook on a package with an even larger blast radius. Axios is the dominant HTTP client library in the JavaScript ecosystem – present in roughly 

 of cloud and code environments and downloaded approximately 100 million times per week. The attacker compromised the npm account of the project's primary maintainer and published two backdoored versions within a 39-minute window. Both versions introduced a hidden dependency that deployed a cross-platform remote access trojan to macOS, Windows, and Linux, targeting developer secrets, cloud credentials, SSH keys, and CI/CD pipeline tokens. The malicious versions were live for roughly three hours. Due to the short exposure window but high prevalence of axios, even limited availability resulted in measurable execution across environments.

, compromised by a separate threat group in the same period, demonstrated what that blast radius looks like in the AI stack specifically. LiteLLM is a unified proxy layer used to route requests across over 100 LLM providers, like OpenAI, Anthropic, AWS Bedrock, Google Vertex, etc. Compromising LiteLLM didn't just expose a build environment, it could provide attackers with credentials that span an organization's entire AI infrastructure. The attack reached LiteLLM indirectly, through another attack event against Trivy, a security scanner that LiteLLM's CI/CD pipeline trusted. The attacker poisoned that trusted dependency, harvested PyPI publishing credentials through it, and published malicious versions from there.

The vector changes across every one of these campaigns. The tactic – compromise something the ecosystem already trusts and weaponize dependency resolution – does not. The scope, speed, and cross-registry reach of these attacks show the limits of manual review in the Age of AI. When attackers can weaponize 100 million weekly downloads inside a three-hour window, the response requires automation and enforcement at the point of pull.

Cooldown policies and developer experience

Security teams that propose cooldown policies consistently encounter the same pushback: they add delays to developer workflows, create friction in the build process, and slow down teams already under delivery pressure.

These are legitimate concerns from engineering teams, even when they buy into a tighter risk posture. Fortunately, the right tooling provides a real solution.

The goal of a cooldown policy isn't to hard-stop every new dependency. It's to introduce a controlled hold with a clear, automated release path. Done correctly, a cooldown policy is largely invisible to developers working with packages that already cleared policy. The friction targets new packages in their highest-risk window, not on the entirety of the dependency graph on every build. For packages that pass continuously without incident, the cooldown period is a one-time delay on first use.

There's also a practical counterargument that often goes unmade: most engineering teams aren't looking to upgrade packages on zero-day. Unless teams configure a pipeline to pull the latest version automatically – an explicit choice, not a universal default – a developer may not know an update is available for days or weeks after publication. For those teams, a cooldown period introduces no meaningful delay. The package sits in its hold state and when it clears policy it is available when the team is ready to consume it. In this case, the friction becomes largely theoretical.

The objection to cooldown policies becomes harder to sustain when considering the alternative. The delay from a cooldown period is likely hours or days when first pulling a new package. Compare that to the blast radius from a compromised dependency that entered your environment unchecked. Teams measure the impact in incident response hours, remediation scope, and, increasingly, regulatory exposure under compliance frameworks, like DORA, CRA, and SOC 2, that treat supply chain controls as auditable requirements, not optional best practices.

The friction argument also assumes that the 

 alternative is speed. It isn't. Uncertainty is a significant factor as well. A supply chain where teams can answer the "are we affected?" question when a CVE drops because they tracked everything on entry mitigates the uncertainty factor drastically.

Building a mature supply chain governance posture

Cooldown policies are one layer in an enforcement stack, not a standalone fix. A mature posture has four components:

 Evaluate every package against policy before it reaches the developer – not after the build, not in a separate scanning tool downstream, but at the moment the request occurs. This is where cooldown and quarantine policies activate.

Today’s threat intelligence is different from that of last week so packages need on-going re-evaluation to stay up-to-date. CVEs don't announce themselves in advance. Malware indicators evolve. The assumption that a package is safe because it passed once is precisely the assumption that Shai-Hulud exploited.

 Context matters. Block with a message. Hold with a tag. Allow with a warning. Developers need clear, actionable answers – not a silent failure that sends them looking for a workaround that bypasses your controls entirely.

Unified visibility across formats and registries:

 "Are we affected?" needs a fast, authoritative answer. That's only possible if there's a single source of truth for what's in the environment and what state it's in based on policy.

Making cooldown policies operationally viable at scale

The conceptual case for cooldown periods isn't difficult to make to a CISO. The operational challenge is implementing them in a way that doesn't break builds, generate alert fatigue, or require a dedicated team to manage exceptions.

This is where the underlying platform matters. Cloudsmith prioritizes enforcement. It evaluates packages against your policies at the point of first pull, before it reaches the environment or developer. Cooldown policies, quarantine actions, and blocking responses are configurable and written as code, giving security teams precise control over parameters without creating blanket friction for engineering.

The critical piece is what happens after intake: continuous re-evaluation. A cooldown period without ongoing re-evaluation is still a point-in-time scan – just one with a delay attached. Cloudsmith’s vulnerability data sources update multiple times per hour. The platform uses a lightweight matching process to associate new vulnerability data with existing packages in your registry continuously. When the threat landscape changes for one of your packages, this triggers your policies to run and take action on the impacted package(s). That combination – policy enforcement at intake plus continuous monitoring after the fact – is what narrows the exposure window.

For organizations with DORA, CRA, or SOC 2 obligations, this also produces the audit trail that auditors will ask for: a traceable record of what entered the environment, when, under what policy conditions, and whether it is still safe.

The gate doesn't protect you if it only checks once. Supply chain governance is not a point-in-time moment – it's a discipline. Cooldown periods are one piece of that discipline: a concrete, policy-driven practice that treats trust as something that has to be earned constantly, not assumed at the point of first pull.

Want to talk through what supply chain governance looks like for your organization?

 Whether you're building the case internally or evaluating tooling, we're happy to help you tackle the problem. 

Your upstream registry is not your friend: Why security teams are demanding package cooldown policies

The threat research team at Socket have today identified over 84 malicious 

 package artifacts across 42 packages in the 

 has over 12 million weekly downloads - giving you an idea of the global impact of these software dependencies. 

 have attributed the behaviour to an ongoing TeamPCP supply chain attack called “

”. The self-propagating malware, which has been seen in other supply chain attacks, spreads by stealing CI/CD secrets.

Thankfully all of these compromised packages were identified only minutes after the packages were published. The problem for the industry is whether organisations had inadvertently consumed those malicious software artifacts before they were removed from the 

 upstream registry. As always a way that 

 registry users can stay ahead of this type of attack is by defining a 

 registry. In Cloudsmith, we solve this problem through automated 

. Cloudsmith also tracks the malicious packages under the 


Match new packages for a specific period (for example a couple of days) after the package was initially released. By enforcing a time lag before consuming a new package or package version, we are enforcing an effective safeguard to protect against zero-day attacks such as the compromised 


This simple policy checks if a package was part of a supply chain attack. If OSV.dev identifies the package as malicious in their advisories, for example, 

, Cloudsmith registries can automatically quarantine packages that start with the "

 by the TanStack team, the attackers successfully released 84 compromised versions of 42 different 

 packages. The breach was achieved through a multi-step exploit involving "

 workflows, GitHub Actions cache poisoning, and the extraction of OIDC tokens directly from the runner's process memory. Unfortunately, we expect to see more of this style of campaign from groups like TeamPCP in the coming months. As always, there are steps that we can take to stay safe.

Talk to Cloudsmith about protecting your software supply chain →

Nigel Douglas

Head of Developer Relations

TanStack npm packages compromised in Mini Shai-Hulud attack

On April 30, 2026, the Mini Shai-Hulud campaign moved beyond npm and into Packagist. Attackers replaced the contents of 

, Intercom's official PHP client, with over 20.7 million lifetime installs, with a credential-stealing payload that executed at install time, before any application code ever called the library. PHP teams, Laravel applications, and continuous integration (CI) pipelines that updated to that version may need to treat affected environments as compromised.

The attack exploited two properties of Packagist that most PHP developers have little reason to question.

Packagist versions are not immutable. The registry mirrors tags from upstream Git repositories, and those tags allow force-updates to point to a different commit. The attacker force-pushed a malicious commit behind the existing 

 tag, replacing a known-good release without changing its version number. Any developer or CI system that ran 

 after 20:53 UTC on April 30 received the compromised artifact, even with an explicit version pin.

 as a Composer plugin, subscribing it to the 

 hooks. Composer ran attacker-controlled code as a natural part of installation so it didn’t require an import. The plugin executed a shell script that downloaded Bun 1.3.13 from GitHub Releases and ran an 11.7 MB obfuscated JavaScript payload called 

 as a background daemon. A legitimate PHP SDK has no business doing any of that.

 harvests credentials broadly: GitHub CLI tokens, npm tokens, SSH private keys, cloud credentials across AWS, Azure, and Google Cloud Platform (GCP), Docker registry credentials, Kubernetes configuration, HashiCorp Vault tokens, and 

 files. It also queries cloud secret-management services directly, e.g., AWS Secrets Manager, Azure Key Vault, GCP Secret Manager, and Kubernetes Secrets.

The payload encrypts stolen data with AES-256-GCM before exfiltrating it to a hardcoded endpoint at 

. If that channel fails, it falls back to GitHub-based exfiltration using any GitHub credentials it has already harvested.

It also carries supply chain propagation logic. Stolen npm tokens let it republish modified packages with injected install-time scripts. It writes payload files into GitHub repositories using commit messages like 

, designed to disappear into normal developer workflows.

The Mini Shai-Hulud Packagist attack follows the same pattern as the 

: a trusted package, a payload injected silently at install time, and a detection window too narrow for teams pulling directly from public registries to rely on.

Cloudsmith sits between your teams and public registries, applying security controls before packages reach build environments or developer machines. Age-based (

) policies would have identified the compromised 

 artifact immediately on publication, blocking it from entering any build until it cleared a configured minimum age threshold. According to internal data, in 2025, 99% of malicious npm packages received official verification within 72 hours. A cooldown policy buys exactly that kind of margin.

Cloudsmith continuously ingests threat intelligence from OSV.dev and the OpenSSF Malicious Packages project. Continuous package enrichment matches cached packages to malicious identifiers. A positive match triggers security policies, which automatically take the prescribed action that users define, e.g., block, quarantine, tag, etc., without requiring manual triage. Routing all Composer requests through Cloudsmith as an upstream proxy also gives your team a full audit trail of which package versions entered your artifact store and when. These are the first questions you need to answer when scoping an incident like this.

If you want to understand how these controls apply to your current Packagist and Composer setup, 

Mini Shai-Hulud reaches Packagist: the intercom/intercom-php compromise explained

Software delivery is often the last, yet frequently neglected, mile of the development lifecycle. For independent software vendors (ISVs), SDK providers, and teams shipping internal tools, the “how” of distribution is just as critical as the “what.” Too often, teams find themselves building and maintaining custom download pages, hosting infrastructure, and complex access controls that add zero value to their core product. These DIY systems are expensive to run, difficult to scale globally, and notoriously easy to misconfigure from a security standpoint.

When software downloads live on generic, third-party domains or lack clear, professional access controls, you risk losing the very thing your product depends on: developer trust. Distribution is an early trust checkpoint for many developers. If a developer hesitates to adopt your software because the delivery method feels disconnected or insecure, you’ve hit a roadblock that slows down your entire adoption funnel.

Software distribution should meet basic expectations for security, access control, and traceability without requiring you to become an infrastructure company. 

Cloudsmith Broadcasts

Broadcasts is Cloudsmith’s built-in, dedicated software distribution capability designed for delivering packages to customers and partners. It allows your team to publish software through secure, branded endpoints hosted under your own domain. Essentially, it acts as a professional front door for your artifacts, abstracting away the headache of building or maintaining custom download portals.

Built on Cloudsmith’s cloud-native architecture, Broadcasts handles the heavy lifting of global scaling and replication. Whether you are distributing a public CLI tool to thousands of developers or a proprietary SDK to a handful of enterprise partners, Broadcasts ensures your software delivery is available, secure, and on brand. It supports both open-source and commercial distribution, and manages access through granular entitlements and seamless integration with native developer tools.

Professional delivery with your own branding

Your brand shouldn’t stop at your documentation page. Many teams struggle with package endpoints that feel disconnected from their identity, leading to confusion and reduced trust among the developer community. Broadcasts solve this by enabling teams to present their distribution experience with their own identity, featuring the same branding, domain, and look and feel that users expect.

By using custom domains and tailored presentation settings, you provide extra reassurance. When a user decides whether to install a package, seeing your company’s domain and branding reinforces that the software is authentic and supported.

Beyond aesthetics, Broadcasts give you control over the technical presentation of your packages. You can configure how to display package information, download links, and license details to end-users. This flexibility ensures that you are providing the exact context a developer needs to successfully integrate your software, all without compromising Cloudsmith’s built-in security and reliability.

Not all software is meant for everyone. Whether you are protecting commercial IP or managing internal tools, Broadcasts provide a range of access models to fit your distribution strategy.

For community tools or public-facing software, public Broadcasts make all packages from a repository openly accessible. This is ideal for increasing the reach of your software without forcing users through unnecessary authentication hurdles.

Protecting proprietary content–like premium SDKs or internal artifacts–is a major challenge for many organizations. Setting up secure, access-controlled methods often requires significant engineering time.

Private Broadcasts provide a dedicated, access-controlled portal where you manage access through secure entitlement tokens. This ensures that only authorized partners or internal teams can view and download your packages. It guarantees robust security, compliance, and IP protection without compromising the end-user experience. You get the security of a private repository with the professional interface of a public one.

The best distribution platform is the one developers don’t have to think about. Developers expect to fetch packages through native tools, whether it’s npm, pip, maven, or a system-level CLI. If your distribution method doesn’t align with these workflows, you create friction that slows down adoption.

Broadcasts are built to integrate directly with native developer tooling. Users can access artifacts through their preferred CLI or CI/CD tools, creating a smooth, workflow-friendly experience. By meeting developers where they already work, you remove the roadblocks that can stall the rollout of new software versions.

Distributing software shouldn’t be a black box. Many teams ship artifacts without knowing which versions users actually download, who is using them, or whether adoption is trending up or down.

Broadcasts include built-in analytics that provide clear visibility into software distribution and adoption. You can track:

: Understand the raw volume of software consumption.

: See which versions are popular and which are being phased out.

: Identify where in the world your users are located.

: Monitor trends over time to predict infrastructure needs or marketing success.

These insights help teams optimize their delivery strategies and understand user behavior more deeply. This data is accessible through both the Cloudsmith web app and the API, allowing you to feed these metrics into your own internal business intelligence tools.

One of the primary differentiators of Broadcasts is its ease of use compared to DIY alternatives. You don’t need to spend weeks designing a portal or configuring web servers.

You can enable a Broadcast instantly from any existing Cloudsmith repository. This immediately creates a professional interface for your end-users without the need for additional infrastructure.

Upload your logo, set your brand colors, and configure your custom domain.

: Navigate to your repository and enable the Broadcast feature.

: Choose between public or private access and generate entitlement tokens for your users if necessary.

: Monitor your performance through the built-in analytics dashboard.

For more information about specific settings, check out the 

The goal of Cloudsmith Broadcasts is to remove the burden of distribution infrastructure. By reducing operational overhead and security risks, Broadcasts help your team stay focused on what matters most: building your core product.

By aligning distribution with your brand identity and providing the tools for secure, manageable access, you can deliver a professional experience that reinforces trust and accelerates adoption. Stop building custom portals and start broadcasting your software with Cloudsmith.

 to discuss your unique distribution needs.

Cloudsmith Broadcasts: Distribute software on your own terms

In a modern development environment, performance and security are inextricably linked. Our 

 reveals that software development in the age of AI is sitting on a fragile foundation of complex infrastructure and institutional inertia.

As teams become more distributed and the volume of artifacts, from standard containers to multi-gigabyte AI models, continues to grow, the “performance gap” between central hubs and remote regions is becoming a critical failure point for the global enterprise.

Maintaining artifact management systems isn't just a background task; for many, it’s a significant drain on high-value engineering resources. When your infrastructure is a legacy, self-hosted system, scaling is rarely a “set it and forget it” operation.

Our data shows that on-prem solutions remain common in otherwise cloud-centric industries. A significant portion of the industry remains stuck in a cycle of reactive maintenance – patching, upgrading, and manually provisioning storage just to keep pipelines moving.

 are now losing more than 20 hours every month to basic registry upkeep. This is time that could be spent on strategic product initiatives, rather than managing the plumbing of the software supply chain. When your infrastructure requires manual intervention to survive a release cycle, your operational overhead stifles your deployment speed.

For global organizations, the distance between a developer and their artifact registry translates directly into lost productivity. Legacy systems designed for a single data center struggle to provide parity for engineers in remote regions, leading to a two-tier developer experience.

A slow download or a registry timeout isn't just an annoyance; it's a blocker that causes CI/CD pipelines to fail. For teams distributed across continents, the performance problems at the edge result in inconsistent build times and frequent disruptions. Our report explores the depth of this performance imbalance and why centralizing your infrastructure in a single data center is no longer a viable strategy for the global stage.

Cloudsmith was built to solve the performance limitations of localized registries. By utilizing a genuinely cloud-native architecture, we move your artifacts closer to the people and machines that need them, regardless of where they are in the world.

 The user should not be concerned with provisioning storage or compute. Cloudsmith scales automatically with your usage, whether you are pushing a small patch or a massive AI model.

 By utilizing a dedicated Package Delivery Network (PDN), Cloudsmith ensures that a developer in Tokyo gets the same sub-second fetch speeds as a developer in London.

 Cloudsmith offloads your operational burden, ensuring that builds and releases remain available even during usage spikes or third-party outages.

As organizations start to deal with the increasing demands placed on development pipelines by AI, they require managed, high-performance solutions to keep up. Our data shows that 

 are already planning to migrate to managed cloud solutions in the next 12 months, while 

 want to migrate but are currently blocked..

Consolidating your infrastructure into a single, cloud-native source of truth isn’t just about speed; it’s about ensuring your delivery pipeline is resilient enough to handle the massive scale of AI-related development.

This post highlights just one part of the performance challenges facing modern DevOps teams. For a deep dive into regional latency issues, the impact of outages on release cycles, and more data on the true cost of legacy tech debt, 

Performance matters: How infrastructure impacts CI/CD

, with participation from our existing investors, to build the operating system for the modern software supply chain. The timing matters because AI is changing what it means to build software.

We’ve been doing it long enough to see the internet change how we distribute software. We’ve seen open source change how we reuse components. We’ve seen CI/CD change how we build and deploy. We’ve seen cloud change how we run infra. We’ve seen SaaS change how we architect applications.

With each evolution, we expand what developers can achieve and how quickly they can move. We evolve our way of working and the tools we use. AI may be the most consequential evolution yet because it touches every area I just listed.

Developers will always play a central role, even as bots update dependencies, CI/CD systems continuously consume artifacts, agents write code and push changes through systems at a scale that humans can’t manually review at the same pace. Developers know what to build and why, but there’s been a change in the laws of physics for software.

We want developers to move faster. We want teams spending less time fighting infrastructure and more time building things that matter. Our tools must make building software safe, so we trust developers to run at maximum tilt.

Software is becoming easier to create than to trust.

Cloudsmith sits at a critical point in the trust chain. That is why this Series C matters: it gives us the fuel to deliver on that promise at a time when software is becoming easier to create than to trust.

Artifact management was always the control point

When Cloudsmith began, artifact management was still seen as busywork and plumbing - necessary, but boring. You wrote code, pushed packages somewhere, pulled them into another system, and moved on. But Cloudsmith didn’t see it that way.

When you think about how we construct software, source code matters, but really, most software actually exists as “artifacts” - our word for packages, containers, dependencies, metadata, SBOMs, signatures, provenance, and builds.

Artifacts are the threads that connect modern software creation, consumption, governance, and delivery.

Artifact management was seen as repositories, storage, and developer convenience - a place to hold packages. But things have gotten… complicated. The explosion of open-source packages, evolving threats to the software supply chain, and the rise of agentic AI software development have shown that artifacts are, in fact, the critical control point.

Cloudsmithers are true believers. The market has now caught up with that belief.

There were easier ways to build Cloudsmith. But we had the conviction that artifact management is what ultimately mattered most. We chose to focus on the fundamentals: simple by design, secure by default, and genuinely cloud-native. We also chose to build a multi-tenant-only platform that would benefit everyone plugged into it. That was not always the cheapest approach, nor was it always the obvious one. But we believed it was the right one.

Software and AI have entered the age of assembly

Software is assembled far more than it’s authored. We build software by combining ingredients - what developers call “dependencies” - into something useful. The flow of ingredients is what we call the software supply chain. The shift from “write code myself” to “assemble software from components” has been happening for decades; AI agents have accelerated this to a breathtaking scale.

Think of this as the AI software factory - a place where we build pipelines for AI to assemble software. Humans decide what to build and oversee the process. Agents write and change the code. CI/CD systems build and test the components they produce. Partner tools inspect them. Registries and package managers supply additional ingredients. Deployment systems ship the final product.

 that over 1.1 million public repositories import LLM SDKs, with 518 million merged PRs, growing 29% annually. I’m certain that’s accelerated in the past 6 months.

Every dependency use is a trust decision, and every artifact has provenance: where it came from. Every artifact should also have a policy: how it should be used. And every artifact has ownership: who is responsible for it. Because every artifact has a blast radius: what happens if it is vulnerable, malicious, or misconfigured?

These decisions matter, whether you make them explicitly or you just let them happen. We’ve collectively let our guard down when it comes to software supply chain trust, and threat actors know it. Their attacks are increasing, they’re creative and ever-changing, and they’re effective enough that every serious organization has to care.

 in March 2025 affected more than 23,000 code repositories and exposed CI/CD secrets in workflow logs. Axios, one of the npm ecosystem’s most widely used HTTP clients, was 

 (April 2026) through malicious npm releases that deployed a cross-platform Remote Access Trojan (RAT), at a scale of 100 million downloads per week. Those represent huge surface areas of potential impact.

Despite these incidents, we’re going to keep building software using components, and if anything, we’re speeding up. “Don’t use dependencies” isn’t an option. The only viable path is forward - to control the flow of components (we’d say “artifacts” at Cloudsmith).

Automating the control point for the new age

Cloudsmith Blog

AI is breaking your artifact governance – and not by writing bad code

Your upstream registry is not your friend: Why security teams are demanding package cooldown policies

TanStack npm packages compromised in Mini Shai-Hulud attack

Mini Shai-Hulud reaches Packagist: the intercom/intercom-php compromise explained

Cloudsmith Broadcasts: Distribute software on your own terms

Performance matters: How infrastructure impacts CI/CD

We built Cloudsmith for this moment

Closing the enforcement gap: Why visibility isn’t enough for supply chain security

Stardrop: New cross-industry npm campaign

The AI speed trap: Securing the future of software supply chains

Cloudsmith in your IDE: Package intelligence, security remediation, and Infrastructure as Code inside your editor

The 2026 guide to software supply chain security: From static SBOMs to agentic governance