Guides

Agentic Systems

What is AI agent supply chain security, and how do you trust what agents install?

How to decide which extensions, MCP servers, skills and vendor keys an agent may use, how to keep secrets out of shared traces, and what to do when a marketplace cache serves a poisoned build.

By Tirth Gajjar · Founder & CTO

14 min

At a glance

AI agent supply chain security is how you decide which extensions, MCP servers, skills, plugins and vendor keys an agent may install or call, and how you keep secrets out of the traces those vendors can read. For agents, that is the half of AI supply chain security that covers installs and shared traces, not only where model weights came from.

Bigcircle builds agents that act only through registered tools, keep credentials in a vault the model never holds, and leave a per-run trace, so a third-party install cannot invent reach the agent was not given.

Who this is for
Engineers building AI systems and technical leads reviewing the implementation.
Topics
  • AI Agent
  • Model Context Protocol (MCP)
  • Tool Calling (Function Calling)
  • LLM Guardrails
  • LLM Observability & Tracing
  • Prompt Injection

Published

AI agent supply chain security is how you decide which extensions, MCP servers, skills, plugins and vendor keys an agent may install or call, and how you keep secrets out of the traces those vendors can read.

Key facts

Definition

AI agent supply chain security means trusting the extensions, MCP servers, skills, plugins and vendor keys an agent loads, and keeping credentials out of any trace a vendor can read.

How Bigcircle does it

  1. On Solarpunk, Bigcircle keeps credentials in an encrypted vault on the user's machine and injects them at the call, so the model never holds the keys and the agent acts only through registered tools.
  2. On Skionis, Bigcircle treats the agent as untrusted and reaches the provider only through purpose-built tools, with no general shell and no path from a plan step to an arbitrary API call.
  3. On the insurance voice agent, Bigcircle puts permission checks in the tool contract, so the model's output is a request to call a tool and never an action by itself.

Comparison

Classic software supply chain security asks whether a package is the one you meant to ship, while AI agent supply chain security also asks which installs run with the agent's privileges and who can read the traces those installs leave.

Key number

On Solarpunk, plans completed with no person rose from about 55% to 80% once local retrieval and planner memory grounded the agent, in our own measurement during the build.

We already treat that as an install problem, not a prompt problem. On Solarpunk, a desktop agent that reaches more than a hundred tools, credentials sit in an encrypted vault on the user's machine and are injected into the tool adapter at execution time, so the model is a reasoning service and never holds the keys, and the agent can act only through systems someone registered.

On Skionis, the DevOps agent on a live AWS account, the agent is untrusted: it reaches the provider only through purpose-built tools, with no general shell and no path from a plan step to an arbitrary API call.

Cursor's 13 November 2026 incident update shows why the install path matters as much as the runtime. Fireworks exposed an access key Cursor had issued to it as its inference vendor. The attacker used that key to copy coding-agent traces from a shared bucket, some of which still held unredacted credentials. On 29 October the attacker put trojanized copies of Anthropic's Claude Code extension (versions 2.1.312 and 2.1.313) on the cache that served Cursor's VS Code extension marketplace. Those copies stayed on that cache for about 11 hours. A team that requested those copies was pulling from a cache it did not run. Cursor's upper bound is 5,000 users, and only among people who asked that cache for those versions.

A familiar publisher name on a marketplace cache is not provenance. On Cursor's account, the malicious copies came from neither Anthropic nor Open VSX, and the incident was not a flaw in Anthropic's product.

This guide starts with what AI agent supply chain security is and how it differs from classic software supply chain security. It then covers where the chain breaks, how you spot a malicious MCP server, how you handle agent skills security, how you keep secrets out of traces, and a practical control set. It ends with how Bigcircle already keeps installs registered and secrets out of the model.

Runtime containment stays on AI agent sandboxing, poisoned tool descriptions on MCP tool poisoning, auth to an MCP server on MCP authorization, and knowing which agents exist on AI agent inventory.

What is AI agent supply chain security?

AI agent supply chain security is the work of trusting what an agent installs and who can read what that agent leaves behind. Classic software supply chain security asks whether a package, container image or library is the one you meant to ship. Agent supply chain security asks the same question about extensions, MCP servers, skills, plugins and inference vendors. It then asks a second question classic packages rarely force: once the agent runs, do its traces, prompts and tool returns become a second copy of your secrets on someone else's disk.

That is the agent-specific angle on AI supply chain security. Provenance of model weights still matters, and it is not this page. An agent also installs and executes tools under a person's privileges, holds credentials for the systems it reaches, and can write a session log that a vendor later trains on or shares. A compromised dependency in a binary is bad. A compromised MCP server or extension that the agent will call with your vault open is worse, because the next tool call is the exploit.

We do not ship a product named AI agent supply chain security. The method is the one the agents we build already use: register every tool, keep secrets outside the model, treat the agent as untrusted, and leave a trace you can compare with what actually changed. The sections below apply those habits to the install path.

Where does an agent's supply chain break?

The chain breaks in five places, and the figure is the framework for them: blue is the gate you own before a run starts, green is an install you trust, and orange is a path you refuse or rotate.

Five places the agent supply chain breaksFramework. Trust what you install, and who can read the traces.Break pointsExtensionsMCP serversSkills / pluginsVendor keysAgent tracesSupply chain gateAllow-listPinned versionsProvenanceWho published itVaultKeys outside modelRedactionSecrets out of tracesInventoryWhat is installedRotate drillVendor key breachTrusted installPinned, reviewed,owned in inventoryAgent may call itUntrusted pathCache, rug pull,or secret in a traceRefuse or rotateBlue is the gate. Green is an install you own. Orange is a path you refuse or rotate.Sandboxing contains a run. This page decides what you install before the run starts.
Break pointWhat failsWhat a team does
Extensions and marketplace cachesA cache or mirror serves a build the publisher never signedPin versions, verify publisher and hash, treat auto-update as a deploy
MCP serversA server you installed changes its tools, or was malicious from day oneAllow-list servers, pin definitions, refuse silent schema changes
Skills and pluginsA SKILL.md or plugin carries instructions or code you did not reviewInternal registry, pin, read the diff when the pin moves
Vendor keysA key you issued to an inference or training vendor is exposedScoped, short-lived keys, egress limits, a rotate drill you have run
Agent tracesA shared bucket or training share holds unredacted credentialsRedact before share, secret scanning, prefer no share over late cleanup

Cursor's incident put three of those on the same timeline: a vendor key, unredacted credentials in shared traces, and a marketplace cache that served a trojanized extension for about 11 hours. The lesson for a team is not "avoid Cursor": the cache that serves your IDE extensions is part of your supply chain, and so is every bucket you share with a training or inference vendor.

Code Mode, documented as experimental from v2.1.323 of Anthropic's coding product (checked 16 November 2026), widens the install question again. The model writes JavaScript, and several tool calls run from that script in one step. On Anthropic's own docs, auto mode's classifier reviews that generated code and not each tool call. For a team, the skills, MCP servers and permission rules you already installed decide what that generated code can reach. Review the install set before you turn on a mode that batches calls.

How do you spot a malicious MCP server?

A malicious MCP server is one you should not connect, or one that changed after you did. Spotting it is review work before the agent can call it, not a hope that the model will notice.

Approve a server only after you have read every field the client will trust: names, descriptions, parameter types, return shapes and annotations. OWASP's MCP Security Cheat Sheet, checked 16 November 2026, treats each of those fields as a place an instruction can hide, not only the description. The same sheet is why a pin has to cover the whole definition you reviewed: hash every field together, then refuse a silent change. If readOnlyHint flips and the name stays put, a client can auto-approve a call you would have stopped. A server that changes its tools after the first approval is the rug pull that sheet warns about.

Check the publisher and the package name the way you would for any dependency. Typosquats and unfamiliar forks that reuse a known brand are the same failure as in npm. Run local servers in a sandbox with the least file and network access the job needs. Give each server its own short-lived credential with a narrow scope, not one long-lived token shared across servers. Log every tool call with the person, the server, the tool and an argument summary. Keep the secret out of that log.

MCP tool poisoning is the attack where instructions hide in a tool description the model reads and the user usually does not. This section is about whether you should connect the server at all, and whether yesterday's approval still matches today's schema. MCP authorization is where the token, the check before the call and the refusal record live once the server is on the allow-list. An MCP gateway is the hop that can enforce that allow-list for many agents.

No client engagement of ours has turned up a poisoned MCP tool. The controls we already put around tool calling still hold after the model is fooled: registered tools only, credentials in a vault the model cannot print, and a person on anything that cannot be undone.

How do you handle agent skills security?

Agent skills security is the install and review work for skills and plugins: the SKILL.md files, helper scripts and plugin manifests an agent loads with a user's privileges. Treat them as supply chain, not as documentation you skim.

A familiar name in a public registry is not a review. Yi Liu and colleagues, in a January 2026 snapshot of two public registries, confirmed 157 malicious skills among 98,380, with 632 vulnerabilities. Of those vulnerabilities, 84.2 percent sat in the SKILL.md file, 8.5 percent in executable code, and 7.3 percent in config and other files. 54.1 percent of the malicious skills came from one actor using templated brand impersonation. All 157 were removed after disclosure. That is the paper's own count of those two registries. It does not cover private repositories or a vendor's curated set.

Check the SKILL.md text before you check any script. Keep an internal registry, pin the version, and read the diff when the pin moves. Run any script in a sandbox. Record the load, the version and the tool call. Skills versus MCP is where the load model and the comparison live. This page only demands that a skill you did not review does not reach a shared credential.

Keep a skill private when one person is the only user and no shared credential is in reach. The moment a second person installs it, or it can call a tool that changes a system, the review above applies.

How do you keep secrets out of agent traces and vendor data shares?

On Solarpunk we inject secrets into the tool adapter at execution time, and they never travel into the prompt. The agent drives a session. It does not learn a password. Carry that habit into every vendor share: if a credential can appear in a prompt, a tool argument or a session log, assume a training share or a support export will eventually copy it.

Cursor's update is the cautionary case: redaction after the share is already too late. A training share with a vendor held a limited set of coding-agent traces from sessions that were not in Privacy Mode, and some of those traces still contained secrets. Cursor's own figures put the exposed API credentials at under 0.01 percent of customers, and those credentials are what the attacker used next to reach some of the SaaS tools Cursor uses. Scan before you share, avoid sharing traces that ever held secrets, and keep Privacy Mode or an equivalent no-training setting as the default for any agent that can see production credentials.

Scope the keys you issue to vendors. A long-lived key with read access to a training bucket is a second vault with a different owner. Prefer short-lived, scoped keys, cut network access to the share when the job ends, and run a rotate drill so the first time you revoke is not during an incident. An AI gateway can hold provider keys so agents never see them. An AI audit trail still needs the secret kept out of the log line.

What does a practical AI agent supply chain security control set look like?

Start with the allow-list and the pin. Extensions, MCP servers, skills and plugins that can reach a shared system enrol before they load, the same way we refuse an agent that invents access on Solarpunk and refuse a general shell on Skionis. Pin the version and the tool definition hash. A moving tag is not a pin.

Add provenance next: publisher, source registry, signature or checksum when the ecosystem gives you one, and a named owner in the inventory. An install with no owner is shadow supply chain.

Keep credentials outside the model and outside the sandbox the install runs in. Use least privilege per server and per skill, short life, and no shared token across unrelated tools. Put egress on the worker host so a local MCP server or skill script cannot open hosts the control plane never listed.

Scan traces and configs for secrets before any vendor share, and treat a shared training bucket as a production system. Practice rotation of the vendor key, the marketplace credential and the OAuth grants the agent holds. Name the person who can flip the kill switch if a poisoned install is already running.

Permissions still bind each action once the tool is trusted. Sandboxing still contains a run that can execute code. This control set decides what is allowed to load before either of those pages starts.

How Bigcircle already keeps installs registered and secrets out of the model

We do not sell a named supply chain scanner, and the agents we ship already refuse the failure modes this page is about.

On Solarpunk, credentials live in an encrypted vault on the user's machine and are injected at the call. We stopped giving the model the registry, and each step queries it for the few contracts it needs. A trace per run goes from the goal through each call to the final application state, so claimed completion can be compared with what actually changed in the target system.

Plans completed with no person rose from about 55% to 80% once local retrieval and planner memory grounded the agent, in our own measurement during the build.

On Skionis, the agent is untrusted and reaches AWS only through purpose-built tools. An engineer approves an architecture diagram before a change applies, and one record links the request to every resulting resource. Template errors before deploy fell from around 10% to 4% across the validation loop's introduction, again by our own measurement. Delivery took roughly 4 months to a working product.

On the insurance voice agent, permission checks and required disclosures sit in the tool contract, so the model's output is a request to call a tool and never an action by itself. A failing request escalates and does not degrade into something close.

On a current engagement for a telecom marketing platform, we scope each agent to the entitlements of the person it acts for, and prompts stay a user-experience layer that no policy check depends on.

When a second team starts installing MCP servers and skills, those same rules become the supply chain gate: nothing loads unless it is registered, pinned and owned, secrets stay in the vault, and a shared trace with a vendor is treated as a system that can leak.

Common questions

What is AI agent supply chain security?#

AI agent supply chain security is how you decide which extensions, MCP servers, skills, plugins and vendor keys an agent may install or call, and how you keep secrets out of the traces those vendors can read. Classic package security still applies, and agents add install-time execution under a user's privileges plus session logs that can become a second copy of credentials.

How is AI supply chain security different for agents?#

AI supply chain security often starts with model weights, datasets and inference providers. For agents, the sharper question is which packages the agent then loads: extensions, MCP servers, skills and plugins that run with local privileges, plus the traces and vendor shares that can hold secrets. This page answers that agent-specific half and links out for runtime sandboxing and MCP auth.

How do you spot a malicious MCP server?#

Read names, descriptions, parameter types, return shapes and annotations before you connect, pin a hash that covers that whole definition, and refuse silent changes after the first approval. Check the publisher and package name, sandbox local servers, use short-lived per-server credentials, and log every call without writing the secret. Tool poisoning in a description is a separate glossary page; this check is whether the server belongs on the allow-list at all.

What is agent skills security?#

Agent skills security is the review, pin and sandbox work for SKILL.md files, helper scripts and plugins an agent loads. Read the instruction file first, keep an internal registry, pin versions, and treat a familiar brand as a reason to read harder. A January 2026 study of two public registries confirmed 157 malicious skills out of 98,380, with most vulnerabilities in the SKILL.md text.

What should you do in the first hour after a poisoned extension?#

Follow the publisher's notice for that build. Uninstall alone may leave standalone persistence running, so flip your agent kill switch if the extension can still call tools while you clean up. Cursor's 29 October 2026 security notice for the trojanized extension builds asked affected teams to rotate credentials from a trusted system, isolate hosts with evidence of payload execution, search telemetry for indicators, and check whether they were impacted. It also asked them to remove persistence rather than only uninstalling the extension.

Does sandboxing replace supply chain controls?#

No. Sandboxing limits what a running agent can reach after it has already loaded code or connected a server. Supply chain controls decide what is allowed to load and which vendor can read the traces, and you need both, because sandboxing without an allow-list still runs yesterday's malicious install inside a nicer box.

Who should own an agent install?#

A named person who can retire the extension, MCP server, skill or vendor key, and who would be paged if it had to stop. Put that name on the inventory record before the install takes production traffic, because a team inbox is not an owner.

Further reading