Skip to content
The State of Exposed AgentsRead the report
Guard0

AI Agent Supply Chain Security: From ClawHavoc to SKILL-INJECT

The AI agent supply chain is under attack. From malicious skill marketplaces to compromised dependencies, here's what's happening and how to defend against it.

· Updated · 12 min read · Guard0 Team

AI Agent Supply Chain Security: From ClawHavoc to SKILL-INJECT

In December 2020, SolarWinds customers discovered that routine software updates had been installing a backdoor called SUNBURST into their networks. The attackers had compromised the build pipeline itself, so doing everything right (applying patches promptly, trusting a known vendor) was exactly what got you infected. Critical infrastructure, large enterprises and multiple US government agencies were hit before anyone noticed.

A year later, Log4j showed the other side of the same problem: a single vulnerable open-source library, embedded in an enormous number of products, opened a path to remote code execution. CISA's director at the time said the vulnerability "poses a severe risk." The attack surface was not a specific product. It was the dependency graph of modern software.

Both incidents share a structure: the attacker did not breach the perimeter. They poisoned the supply chain, meaning the libraries, updates and components that software consumes and trusts without checking.

That structure is now appearing in AI agent ecosystems. The patterns are the same. The stakes are higher, because of what agents are allowed to do.

341
Malicious skills found (ClawHavoc, of 2,857 audited)
1,467
Skills with security flaws (Snyk ToxicSkills, of 3,984 scanned)
36.82%
Skills with at least one security flaw (ToxicSkills)
* * *

Why Agents Change the Calculus

When a compromised npm package runs in a traditional application, the blast radius is typically constrained. The code can read files it has access to, make network requests and possibly escalate privileges, but it operates within what the application is designed to do.

When a compromised component runs inside an AI agent, those limits are much weaker. Agents are, by design, general-purpose autonomous executors. They browse the web, write and execute code, send emails, interact with APIs, manage files, and make decisions across long multi-step task chains. A malicious skill installed in an agent does not affect one function. It is present for every action the agent takes.

This is not a theoretical concern. The incidents and research below document it happening in public marketplaces and package registries.

* * *

Mapping the Agent Supply Chain Attack Surface

To understand where attacks enter, it helps to enumerate every layer at which an agent depends on external components.

AI AGENT SUPPLY CHAIN ATTACK SURFACE
Skill MarketplacesMCP Registriesnpm/pip PackagesAI AgentModel WeightsRAG / Vector StorePrompt Templates

Skill and plugin marketplaces. Agent frameworks and platforms, OpenClaw among them, come with marketplaces where developers publish tools that agents can call. These work like browser extension stores or mobile app marketplaces: centralized distribution points with varying levels of vetting. A malicious actor who can publish to such a marketplace immediately gains a delivery channel into any agent that installs their skill.

MCP server registries. The Model Context Protocol (MCP) has rapidly become a standard interface for connecting agents to external tools and data sources. As organizations build and share MCP servers, informal registries and package repositories have emerged. There is no universal standard for MCP server vetting, signing, or verification, so the distribution layer is widely trusted and largely unaudited.

npm, pip, and agent framework packages. Agent frameworks like LangChain, CrewAI, and Semantic Kernel are themselves distributed through standard package managers. The agent tooling ecosystem has grown quickly and includes many third-party packages with integration code, tool wrappers, and utility libraries. The same dependency chain vulnerabilities that affect traditional software affect this layer, with the added dimension that the packages in question are wiring up capabilities to a general-purpose autonomous executor.

Pre-trained model weights. Model weights distributed through repositories like Hugging Face can contain embedded malicious behavior, either through fine-tuning on poisoned datasets or through techniques that encode backdoor triggers into the weights themselves. An agent built on a compromised base model may behave correctly under normal conditions and activate malicious behavior only when specific inputs appear.

RAG knowledge bases and vector stores. Agents augmented with retrieval systems pull context from external document stores during inference. If those documents are compromised, either through direct poisoning of the knowledge base or through prompt injection embedded in retrieved content, the agent's behavior can be manipulated without touching any code.

Shared prompt templates and system prompts. Organizations increasingly share and reuse system prompts through internal repositories, community libraries, and commercial tools. A poisoned prompt template that subtly alters an agent's behavior or disables safety constraints is a class of supply chain attack with no close equivalent in traditional software security.

Each of these layers is a trust boundary, and each is usually managed with less rigor than the equivalent layer in traditional software.

Supply Chain Trust Hierarchy
AI AgentWeightsModel ProviderChecksum VerifyProvenance AuditToolsTool / MCP Serv…Server SigningPermission ScopeDepsPackage RegistryDep PinningSBOM TrackingPromptsPrompt TemplatesVersion ControlIntegrity Hash
* * *

ClawHavoc: When the Marketplace Is the Attack Vector

The clearest example of marketplace risk is the ClawHavoc campaign on OpenClaw, the open-source personal AI agent whose skill marketplace is called ClawHub.

Koi Security audited all 2,857 skills on ClawHub at the time of its investigation and identified 341 malicious skills, of which 335 were traced to a single coordinated operation now tracked as ClawHavoc. The skills posed as legitimate tools: cryptocurrency wallet trackers, Polymarket trading bots, YouTube utilities, Google Workspace connectors. 335 of the 341 used fake prerequisites to install Atomic Stealer (AMOS), a commodity macOS infostealer.

The marketplace model created the opening: at the time of the campaign, the only requirement to publish a skill on ClawHub was a GitHub account at least one week old. No static analysis, no code review, no signing. Once an organization permitted skill installation, every skill in the marketplace became part of its attack surface. The trust granted to the platform propagated to every publisher on the platform.

We covered this incident in detail in our OpenClaw Security Crisis post. The lesson holds beyond OpenClaw: any marketplace that allows third-party skill publication without rigorous vetting and ongoing monitoring is an attack surface that adversaries will find and exploit.

* * *

The Cline npm Compromise: Code Execution Amplified

On 17 February 2026, someone used a compromised npm publish token to release an unauthorized version of the Cline command line tool, cline@2.3.0. Cline is an AI coding assistant. According to the maintainers' advisory, the only change was a postinstall script that installed OpenClaw on any machine that installed the package. A corrected version was published about eight hours later and 2.3.0 was deprecated. The VS Code extension and JetBrains plugin were not affected. The Register covered the incident.

The payload in this case was another agent, not an infostealer. That is the part worth noticing. A developer who ran one install command ended up with a second autonomous agent on their machine, with broad access, that they never chose to install.

In a traditional supply chain attack, a compromised npm package might exfiltrate environment variables, steal credentials stored in files, or open a reverse shell. Those are serious, but bounded.

When the compromised package belongs to, or installs, an agent that has code execution as a normal feature, the attacker inherits that capability. Reading environment variables is easy because the agent already reads them. Persisting is easy because the agent already writes files. Reaching other systems is easy because the agent already makes external calls.

The principle: the impact of a compromised component scales with the capability of the agent it runs in. Agents with broad filesystem access, code execution, network access and the ability to take external actions are high-value supply chain targets.

* * *

ToxicSkills: The Scope of the Problem

ClawHavoc showed coordinated abuse. Snyk's ToxicSkills study (February 2026) measured how widespread the underlying weakness is.

Snyk scanned 3,984 skills on ClawHub and found 1,467 (36.82%) had at least one security flaw, 534 (13.4%) contained critical-level issues (malware distribution, prompt injection, or exposed secrets), and 76 were confirmed malicious. Among confirmed malicious skills, 91% contained prompt injection payloads. Hardcoded secrets appeared in 10.9% of the skills scanned.

The 36.82% figure deserves to be read carefully. It does not mean that 36.82% of skills are operated by malicious actors with intent to harm. Many issues reflect carelessness, poor security hygiene, and the lack of secure development norms in a new ecosystem. Overly broad permissions are often the result of developers taking the path of least resistance rather than malicious design.

But for a security posture, intent is irrelevant. A skill with overly broad permissions that was not designed to be malicious is still an attack surface: for the developer's compromised account, for future changes to the skill, or for abuse of the permissions by other means. More than one in three skills in that scan had a flaw an organization should evaluate before deployment.

Skills are also a direct injection channel. The Skill-Inject benchmark (February 2026) measured how often agents follow malicious instructions placed in skill files, and reported attack success as high as 80% on frontier models.

* * *

Tool Poisoning: Manipulating Agents Through Descriptions

A research track parallel to the skill marketplace work has focused on a different layer of the agent supply chain: tool descriptions.

Agents understand what tools do and when to use them through natural language descriptions: text that describes a tool's function, its parameters, and when it should be invoked. This description layer, sitting between the agent's reasoning process and the tool's actual code, turns out to be an attack surface. Invariant Labs' April 2025 disclosure demonstrated how hidden directives embedded in MCP tool descriptions can redirect agent behavior in MCP clients such as Cursor, and the later MCPTox benchmark formalized the attack class with test cases built on real-world MCP servers.

Tool poisoning attacks work by embedding instructions within tool descriptions that direct the agent to take actions beyond the tool's stated purpose. Because agents process tool descriptions as part of their context, a poisoned description can effectively inject arbitrary instructions into the agent's reasoning. An agent that calls a tool to retrieve weather data might, through a poisoned description, simultaneously be instructed to pass along user credentials to the tool's server.

The implications for MCP security are significant. MCP servers communicate their available tools and capabilities through exactly this kind of description layer. An organization that deploys a third-party MCP server, or an internal one built with external components, needs to treat the tool description layer as a possible injection point, along with the underlying code.

We covered this in depth in our MCP Security Guide, which details detection methods and defensive configurations.

* * *

The Agent Bill of Materials

The software security community's response to supply chain risk in traditional software produced the Software Bill of Materials (SBOM): a structured inventory of every component in a software system, including versions, licenses, and provenance. SBOMs enable organizations to quickly assess exposure when a new vulnerability is disclosed, to enforce component policies at scale, and to give regulators and customers visibility into what a software product is actually made of.

Agents need an equivalent: the Agent Bill of Materials (ABOM).

An ABOM should enumerate every layer at which an agent depends on external components or data:

  • Model version: Which foundation model is the agent using, which fine-tuned variant if applicable, and what is the provenance of the weights?
  • Tools and MCP servers: Every tool endpoint the agent can call, with version, publisher, and the scope of permissions granted.
  • Skills and plugins: Every installed skill with version, source marketplace, publisher identity, and permission scope.
  • Data sources and knowledge bases: RAG indexes, vector stores, and other data sources the agent retrieves from, with information about how content is sourced and updated.
  • Prompt templates: System prompts and prompt templates, with versioning to detect unauthorized modifications.
  • Framework and dependency versions: The agent framework, tool libraries, and all transitive dependencies, equivalent to a traditional SBOM.

Without an ABOM, an organization cannot answer basic questions about its agent infrastructure: What would be exposed if a specific MCP server were compromised? Which agents are using the version of a skill library that was just found to be vulnerable? Has the system prompt for an agent been modified since last review?

The ABOM is also relevant to compliance. The EU AI Act imposes technical documentation and transparency requirements on AI systems in covered use cases. An inventory of an agent's components is a practical way to prepare that documentation. We covered the agent-specific implications of the EU AI Act in our EU AI Act for Agents post.

* * *

Defending Your Agent Supply Chain

Understanding the attack surface is the first step. The second is building systematic defenses across each layer.

Vendor assessment for MCP servers. Before deploying any MCP server, whether sourced externally or built internally using third-party libraries, conduct a structured security review that covers: publisher identity verification, code review of the tool description and implementation layers, permission scope analysis, network access patterns, and update and patch history. Treat MCP servers with the same vendor risk management process you apply to SaaS applications.

Skill and plugin security scanning. Implement automated scanning for agent skills before they are deployed. This means static analysis of skill code for permission requests, outbound network calls, and data access patterns, combined with dynamic analysis in sandboxed environments to observe actual runtime behavior. Skills that request permissions beyond what their advertised function requires should trigger manual review regardless of publisher reputation.

Dependency pinning and verification. Pin all agent framework dependencies to specific verified versions. Use package signing and verification to ensure that the packages you install match the packages that were published. Implement automated dependency scanning integrated with your CI/CD pipeline, so that newly disclosed vulnerabilities in your dependency chain are flagged before they reach production.

Prompt template version control and integrity checking. Store system prompts and prompt templates in version-controlled repositories with access controls equivalent to production code. Implement integrity verification so that agents detect when their prompt context has been modified from a known good state. Treat unexpected modifications to prompts as a potential indicator of compromise.

Runtime behavior monitoring. Static analysis of installed components is necessary but not sufficient. Agents should be monitored at runtime for behavior that deviates from expected patterns: unexpected outbound network calls, unusual data access, tool invocations inconsistent with the agent's current task, and anomalous sequences of actions. Runtime monitoring can catch supply chain compromises that were designed to evade static analysis by activating only under specific conditions.

g0 for agent supply chain visibility. The g0 inventory command produces a signed CycloneDX AI bill of materials listing the models, tools, agents and MCP servers in a project, so you can diff it between releases. The g0 mcp command assesses MCP servers from their configuration and source, including tool descriptions. g0 check compares the skills and MCP servers installed on a machine against a known-malicious database that includes ClawHavoc indicators. g0 is open source and runs locally. More in Introducing g0, and for how Guard0 handles this across a company, see MCP security.

* * *
See Guard0 in action

Live walkthrough of agent discovery, risk scoring, and policy enforcement.

Book a Demo
*Key Takeaways
  • The AI agent supply chain is under active attack: ClawHavoc (341 malicious skills out of 2,857 audited), Skill-Inject (attack success as high as 80% on frontier models), and ToxicSkills (36.82% of 3,984 skills with at least one flaw)
  • Attack patterns mirror SolarWinds and Log4j but target systems with more capability: agents that browse, execute code, send emails, and call APIs
  • Tool poisoning through description manipulation (Invariant Labs, April 2025) works against MCP clients
  • Organizations need an Agent Bill of Materials (ABOM) listing models, tools, MCP servers, skills, data sources, and prompt templates
  • Static analysis alone is not enough. Runtime monitoring catches supply chain compromises designed to evade pre-deployment checks
* * *

Request a free AI risk assessment. Guard0 tests the agents, MCP servers and AI applications you already run and sends you the findings. Request an assessment.

See what your agents depend on. Guard0 finds the agents in your company, maps what each one can reach, and records a named owner for each.

Start free

Supply Chain · Threat Intelligence · MCP · Dependencies · Security

Guard0 Team