AI supply chain security centers on inspecting and governing both internal and third-party components integrated into AI environments. These artifacts encompass machine learning models, software dependencies, agent code, reusable skills, and Model Context Protocol (MCP) servers.
Evaluating these elements before production deployment helps organizations detect hidden instructions, unsafe serialization, malicious code, and compliance violations. Because these underlying artifacts dictate an AI system's capabilities and reasoning, any compromised component can fundamentally alter system behavior—even if the main application code remains untouched.
Key Points
Models: Pre-trained, open-weight, and fine-tuned models can carry hidden backdoors, malicious code, or unsafe serialization.
Model Dependencies and Licenses: Packages, open-source components, and license terms travel with a model and can introduce insecure code or compliance exposure.
Agent Skills: Reusable agent capabilities can contain prompt manipulation, credential access, or unsafe shell commands.
Agent Code and Tools: Agent source code and the tools it calls can carry unsafe permissions, hidden vulnerabilities, or indirect injection paths.
MCP Servers: Third-party servers supply the tool definitions agents act on, so tampered or unvetted servers directly shape agent behavior.
Registries and Pipelines: Model hubs, artifact repositories, and CI/CD pipelines store and promote artifacts, and inspection must happen before production.
An AI system is assembled from artifacts that originate both inside and outside the organization. Models determine what the system understands, while skills, tools, and servers determine what it can do. Each artifact type carries its own tampering risks, and each enters the environment through a different route.
| Component | What It Includes | Typical Source | Where Compromise Occurs |
|---|---|---|---|
| Models | Pre-trained, open-weight, and fine-tuned models in formats such as Pickle, PyTorch, TensorFlow, ONNX, Safetensors, and GGUF | Public model hubs, commercial vendors, internal training | Code that runs at load or inference, architectural backdoors, unsafe serialization, impersonated publishers |
| Libraries and Dependencies | Packages, open-source components, metadata, and license terms | Package repositories, model repositories | Insecure or vulnerable dependencies, metadata anomalies, license violations |
| Skills | Reusable capabilities that let an agent call APIs, run code, or orchestrate workflows | Internal teams, marketplaces, public repositories | Embedded instructions, credential access, data exfiltration, behavior that differs from stated purpose |
| Plugins, Tools, and MCP Servers | Agent extensions, APIs and connectors, and servers that expose tools to agents | Public registries, vendors, internal teams | Tampered tool definitions, context poisoning, credential leakage |
| Agent Code, Prompts, and Configuration | Agent source code, behavioral instructions, model and agent settings, guardrails and policies | Internal development, coding assistants, third parties | Overly broad permissions, hidden vulnerabilities, indirect injection paths |
| Registries and Pipelines | Model hubs, object storage, artifact repositories, model registries, and CI/CD | Cloud providers, public hubs, internal platforms | Unvetted artifacts promoted to production without inspection |
In a model-centric deployment, the supply chain is largely settled at build time: a team selects a model, packages it, and deploys it. Agentic AI changes that pattern. Agents plan multistep tasks, call tools, and connect to external servers, which means the set of components shaping behavior is larger, more varied, and more likely to change after deployment. A coding agent such as Claude Code, can be extended with third-party skills, plugins, and MCP servers that an individual developer adds at any time, with no change to the model itself.
| Dimension | Model-Centric AI | Agentic AI |
|---|---|---|
| Primary Artifacts | Model files and their dependencies | Models, skills, plugins, MCP servers, agent code, and configuration |
| When Dependencies Are Chosen | Mostly at build time | At build time and at runtime, as agents add or call tools |
| What Artifacts Control | Model output | Model output and actions on connected systems |
| Trust Boundary | The model and its host | Every skill, tool, and server the agent can reach |
| Rate of Change | Model updates and version changes | Skill updates, tool definition changes, new server connections |
A skill is code and instructions that an agent follows on behalf of a user or application. If a skill is compromised, the agent can execute code, read secrets, run shell commands, or contact external endpoints while appearing to perform its normal task. This makes skills and tools a primary target, closer to software packages with execution privileges than to configuration files.
MCP servers present tool descriptions that models treat as context for deciding what to do. Adversaries can tamper with those descriptions to manipulate agent reasoning, a technique called context poisoning.
Fake or hijacked servers can enter through public registries or software dependencies, and a server that passes an initial review can later swap in malicious tool definitions. One-time approval is therefore insufficient. Agentic AI security describes the broader set of controls that apply along the agent loop.
AI coding assistants regularly pull third-party skills, extensions, and libraries onto developer machines, often straight from public repositories and marketplaces. These artifacts can bypass the registries and pipelines where central controls sit. Unsanctioned artifacts accumulate as shadow AI, which leaves security teams without an inventory of what is running or where.
Even a project folder can carry risk. An untrusted code repository in a coding agent such as Claude Code could trigger attacker-defined commands through the project's own settings, until the vendors patch the issue.
AI supply chain security inspects AI artifacts before they reach production or a developer's machine, applies policy to the results, and keeps checking afterward.
Let’s take Claude Code as an example. The model comes from the vendor, but teams extend the agent with skills, plugins, MCP servers, hooks, and project settings. Each of these is an artifact, from a third party or an internal team, that shapes what the agent does.
| Claude Code Component | What It Does | What Inspection Looks For |
|---|---|---|
| Skills | Add reusable instructions and scripts for specific tasks | Hidden instructions, code that goes beyond the skill's stated purpose, access to credentials |
| Plugins | Bundle skills, commands, and tools so a team can share them | Unknown publisher, unexpected changes between versions, bundled scripts |
| MCP Servers | Give the agent access to external tools and data | Tampered tool descriptions, excessive permissions, data sent to unapproved destinations |
| Hooks and Project Settings | Run commands automatically when a project is opened or a session starts | Commands that run without the developer's awareness, credential access |
Discovery and Provenance: An organization using Claude Code would start by inventorying which skills, plugins, and MCP servers developers have added across teams, and verifying where each came from. A skill from a verified internal team would be treated differently from one downloaded from an anonymous public marketplace. In general, discovery means building an inventory of every artifact in use and confirming its origin.
Type-Specific Inspection: In Claude Code, a skill described as a document formatter that also reads credential files or sends data to an outside address would fail inspection. The team would analyze each skill, plugin, and MCP server to compare what it does with what it claims to do. In general, each artifact type needs its own analysis, and models the organization runs itself would be examined structurally for hidden code and backdoors.
Policy Evaluation: For Claude Code, a team might block any skill that requests credentials but only flag one that lacks a license. In general, findings are compared against configurable rules. Blocking rules stop high-risk artifacts from being installed or promoted, while non-blocking rules record findings without interrupting work.
Workflow Enforcement: For Claude Code, a skill or plugin would be checked before it is shared with a team, not after it is already running on developer machines. In general, scanning runs inside the pipelines and registries where artifacts are stored and promoted, so a failed check stops a release automatically. It can also run inside the organization's own environment when artifacts are sensitive.
Monitoring and Audit Evidence: If a Claude Code plugin approved last month ships an update with new behavior, or a new vulnerability affects something already in use, ongoing monitoring would alert the team. In general, each scan produces a structured record of what was examined and found, and an AI bill of materials (AI-BOM) documents the components behind each system.
AI systems inherit the risk of every artifact they are built from. As agents add skills, tools, and MCP servers, that inheritance grows and changes faster than periodic reviews can follow. Organizations that treat AI artifacts like any other software dependency, with a known source, an inspection before deployment, and a policy decision tied to the result, can adopt open models and agent capabilities without giving up control.
The practical path starts with an inventory of the models, skills, and servers already in use. From there, inspection moves into registries and pipelines, release decisions follow scan results, and findings are re-evaluated as new vulnerabilities emerge. Scanning artifacts before they run is far less costly than responding to a compromise after deployment.