AI Agent Supply Chain Security: Securing Agentic Development
AI agents install packages, MCP servers and skills with developer credentials. Learn how to inventory, pin and verify every component they pull in.

Table of contents
- Key takeaways about ai agent supply chain security
- What Is AI Supply Chain Security?
- How AI Agents Expand the Software Supply Chain
- AI Supply Chain Security Risks in Agentic Development
- Securing AI Agents, MCP Servers, Skills, and Dependencies
- Protecting AI-Generated Code Across the Software Supply Chain
- AI Supply Chain Security Best Practices
- Building Supply Chain Security Into Agentic AppSec
- FAQs
AI Agent Supply Chain Security: Securing Agentic Development
Developer tooling used to sit outside the supply chain, but AI agents changed that. AI agent supply chain security covers the models, coding agents, MCP servers, skills and packages that now install, update, and run with developer credentials, plus the code they write. You didn't build any of them, and you trust all of them.
Agents widen the chain in two directions. They pull in new components, and they produce code that ships. Attackers have noticed: between August 2025 and March 2026, malicious releases hit an npm build tool, an MCP server package, and an AI proxy on PyPI. Securing that chain means extending the program you already run. Inventory every agent component, pin it, verify where it came from, and track what it produces.
Key takeaways about ai agent supply chain security
- SCA and SBOM programs already cover most of the mechanics. The gap is that agent components act with developer credentials, so a compromised one does its damage before any scanner reviews its output.
- A clean release history proves little. A package can publish many harmless versions and turn malicious in a routine update, so each new version deserves the review a first install gets.
- Unpinned tools in CI hand attackers the widest reach, because one poisoned binary can expose a publishing token that opens a different ecosystem downstream.
- Ownership belongs with the team that already runs supply chain security. A separate AI program duplicates the inventory and leaves both teams with partial visibility.
What Is AI Supply Chain Security?
AI supply chain security is the practice of verifying the origin, integrity and behavior of every AI component that enters development or production. That includes models, datasets, frameworks, agent tooling, and the code those tools generate. It applies the logic of the software supply chain to a newer set of parts.
AI agent supply chain security narrows that scope to the agents developers run and everything those agents pull in. In a single session, an agent can install packages, connect to MCP servers, load skills, and call a model. Each link has a publisher, a version and an update channel, and each runs with the developer's access.
Three questions follow for every component: where did it come from, is it the version you approved, and what did it touch? An AI bill of materials answers the first two. Records of agent activity answer the third.
How AI Agents Expand the Software Supply Chain
A classic supply chain program tracks source code, open-source dependencies, build systems, and artifacts. Agents add six component types, and today's checks cover them unevenly:
Read the last column from top to bottom. SCA covers the packages and code review covers the output, but the four components in between have no clear owner. Those four also hold the most privilege, because they run on the developer's machine with the developer's tokens.
If you already run SCA and SBOMs, this can look like the same problem, and partly it is. Pinning, signing, and inventory still apply. The new part is that these components act: an agent CLI or MCP server executes with developer credentials, so a malicious version starts working the moment it runs.
AI Supply Chain Security Risks in Agentic Development
Three incidents from three ecosystems show that AI supply chain security risks already reach real releases. Each follows the shape of a software supply chain attack, with a twist specific to agents:
- Nx "s1ngularity" (npm, August 2025): According to the Nx post-mortem, attackers exfiltrated an npm token through a GitHub Actions workflow and published malicious Nx versions on August 26, 2025. The payload attempted to use developers' local AI CLIs, such as Claude and Gemini, to search systems for sensitive data, reportedly with flags that bypass the tools' permission prompts. Results went to a public GitHub repository, and Nx says the versions were live for about four hours.
- postmark-mcp (npm, September 2025): An unofficial package impersonating Postmark's email service published 15 clean versions first. According to Postmark's security notice, version 1.0.16 then added a backdoor that secretly BCC'd emails to an external server. Any install that tracked the latest version would have received the backdoor as a routine update.
- LiteLLM via Trivy (PyPI, March 2026): On March 24, 2026, malicious LiteLLM versions 1.82.7 and 1.82.8 appeared on PyPI. The publishing token was reportedly exposed when an unpinned, poisoned Trivy binary ran in LiteLLM's CI. LiteLLM is an AI/LLM proxy that holds provider API keys, and the Trivy-to-LiteLLM compromise breakdown puts the exposure window at about five and a half hours.
The three cases show three ways an agent component turns hostile. A trusted publisher's token gets stolen, a lookalike builds a clean history, or a tool upstream of the AI component is poisoned. The Shai-Hulud npm worm followed a similar token-theft path at a larger scale.
The Nx case adds something new. Alongside its own scanning code, the malware reportedly tried to borrow the agent the developer had already installed and trusted.
Securing AI Agents, MCP Servers, Skills, and Dependencies
This section stays on provenance: where each component came from, whether it's pinned and signed, whether it's in inventory, and how it drifts. Here's how those checks apply to each component type:
Agents and MCP servers carry the most risk per component because they hold credentials. Verify the publisher before the first install, then treat each new version as a fresh install. Runtime controls are covered in the MCP security overview.
Skills and dependencies drift more quietly. A skill pinned to a branch changes whenever someone pushes, and a dependency changes when a maintainer account does. CycloneDX's ML-BOM format already represents models, datasets and configurations, including dataset provenance, so you can extend an existing SBOM pipeline.
Protecting AI-Generated Code Across the Software Supply Chain
Supply chain security for AI code starts with attribution. Code an agent writes enters the repository under a human's commit, so the history says a developer wrote it. When a model version later turns out to produce a flawed pattern, you can't find the affected code without that record.
Three records close the gap:
- Attribution: Capture which agent and model produced a change in commit trailers or pull request metadata. Search then becomes possible when a model or agent version is flagged.
- Review status: Record whether a human reviewed the change line by line or approved it in bulk. Auditors and incident responders weigh those two very differently.
- Dependency origin: Note whether a new package came from the developer or from the agent's own choice. Agents can request package names nobody published until an attacker did, a pattern known as package hallucination, one of the documented risks of AI-generated code.
Provenance doesn't tell you whether the code is safe. It tells you where to look when something upstream goes wrong, which is the question supply chain owners get asked first.
AI Supply Chain Security Best Practices
These AI supply chain security best practices extend controls you likely run already. Start with inventory, because every later step depends on it:
- Inventory agent components: List every agent, CLI, MCP server, skill, and model in use on developer machines and CI runners. You can't pin, scan, or revoke what the inventory doesn't show.
- Pin versions: Lock agent CLIs, MCP servers, and skills to exact versions or commit hashes, and pin CI tools the same way. LiteLLM's exposure reportedly began with one unpinned scanner install in CI.
- Prefer verified publishers: Install agent components from the vendor's documented channel and check the publisher against official docs. The postmark-mcp package impersonated a real company for 15 releases.
- Restrict agent CLI permission flags: Block settings that skip approval prompts on developer machines, and never allow them in CI. Malware that inherits an unrestricted agent can search files without a single prompt.
- Isolate agent credentials: Give agents scoped, short-lived tokens instead of a developer's full session, and keep publishing tokens off machines where agents run. A stolen token then reaches one system, and the registry stays out of reach.
- Monitor for update drift: Alert when a pinned component publishes a new version, changes maintainers or ships a release that doesn't match its source repository. Drift review catches the turn that a clean history hides.
- Record AI involvement in commits: Add agent and model identifiers to commit or pull request metadata. Responders can then scope a bad model version in minutes instead of reviewing every recent merge.
- Extend the SBOM to AI components: Add models, MCP servers and agent tooling to the SBOM you already generate, using ML-BOM fields for models. One format keeps AI components inside existing review and audit flows.
- Verify build and source provenance: Require provenance for components you build, and prefer packages that publish it. SLSA v1.2, released in November 2025, added a Source Track alongside the Build Track; SLSA's levels explained covers the basics.
- Rehearse an AI-tooling incident: Run a tabletop where an agent CLI or MCP server turns malicious overnight. Practice finding every machine that ran it, then revoke and rotate the credentials it could reach.
Building Supply Chain Security Into Agentic AppSec
Agent components belong in the AppSec program that already owns SCA, SBOMs, and signing. That team has the registries, the policies, and the incident playbooks. A parallel AI program would rebuild the same inventory with less context, and each side would see half the chain.
Ownership also settles a question most programs haven't answered: who approves a new MCP server or agent CLI? Route those requests through the same intake as a new third-party library. Platform teams own installation, and AppSec owns the policy and the risk call.
Measure progress the way you already do, as the share of agent components that are inventoried, pinned and provenance-checked. The controls for supply chain vulnerability protection carry over directly; only the component list changes.
One gap has no clean answer yet. Agent activity logs vary from tool to tool, so inventory still depends largely on scanning machines and repositories after the fact. The teams doing this well accept that gap and close it with frequent discovery.
Legit Security extends software supply chain protection to agentic development. Its AI visibility and governance capability inventories the AI models, coding assistants and MCP servers in use and flags unapproved models. Dependency inventory and SCA scanning cover the packages from code to deployment. Download the supply chain security best practices guide to map these steps to your program.
Frequently Asked Questions
Is an MCP server a software supply chain component?
Yes. A packaged MCP server is third-party code with a publisher, a version history and an update channel, and it runs with whatever credentials you grant it. Remote MCP servers behave more like SaaS vendors: you can't pin their code, so vendor review and narrowly scoped credentials carry more of the weight.
Should AI-generated code be tracked in an SBOM?
Not as a separate component. An SBOM lists what software contains, and AI-written code becomes first-party source once it's merged. Track it through commit and pull request metadata, then link the agent and model versions to the build. That keeps the SBOM accurate while still letting responders trace a flawed model's output.
How do attackers abuse AI agents in supply-chain attacks?
There are two routes so far. Attackers compromise components that agents load, such as MCP servers and agent CLIs, or they ship malware that hijacks an agent already installed on a developer machine. The second route appeals because the agent already has file access and credentials, so the malware borrows trusted tooling.
What is an AI bill of materials, and do you need one?
An AI bill of materials (AIBOM) records the models, datasets, frameworks, and AI tooling inside a system, along with where each came from. You need one once AI components ship in products or run in pipelines with production access. Most teams start by extending their existing SBOM format rather than adopting a separate tool.
How should you pin and update AI coding tools and agent CLIs?
Pin exact versions in a managed configuration and turn off auto-update on shared and CI machines. Read release notes for new tools or permissions, test each update on one machine, then roll it out on a fixed schedule. For urgent security fixes, shorten the window but keep the review step.
Who owns AI supply chain security: AppSec, platform, or an AI team?
AppSec owns the policy and the risk decisions, because it already runs SCA, SBOM and signing programs. Platform engineering usually owns installation, configuration and credential provisioning for agents. An AI team, where one exists, advises on model selection. Write the split down, because an unowned approval step is how unvetted MCP servers reach developer machines.
Legit Security needs the contact information you provide to us to contact you about our products and services. You may unsubscribe from these communications at any time. For information on how to unsubscribe, as well as our privacy practices and commitment to protecting your privacy, check out our Privacy Policy.
More Articles

AppSec AI Agents: Types, Autonomy, and What to Look For
AppSec AI agents take a security goal, act, and verify the result. See which agents work at each SDLC stage, how much autonomy each gets, and how to judge them.



See it in your stack
Every prompt, every commit, every deploy, covered the moment you're ready.


