Agent Upstart

Cool things people are building with agents — and practical help getting the most out of them.

Skills

NVIDIA SkillSpector — scan a skill before you install it

Written October 31, 2026

github.com/NVIDIA/skillspector · security scanner for AI agent skills · static checks plus an optional model-based semantic pass

What it does

An agent skill is a folder of instructions that runs with the agent's permissions, and installing one usually means trusting its description. SkillSpector reads the skill before it is installed and reports what the skill's own files say it can do. It answers one question, as its README puts it: "Is this skill safe to install?" It covers skills for Claude Code, Codex CLI, Gemini CLI, and MCP servers.

The scanner checks 71 vulnerability patterns across 17 categories, per the README: prompt injection, data exfiltration, privilege escalation, supply chain, excessive agency, output handling, system prompt leakage, memory poisoning, tool misuse, rogue agent, anti-refusal, trigger abuse, dangerous code, taint tracking, YARA signatures, MCP least privilege, and MCP tool poisoning. Each scan ends in a risk score from 0 to 100, a severity label, and a recommendation: SAFE, CAUTION, or DO NOT INSTALL. It also checks declared dependencies against OSV.dev for known vulnerabilities, with an offline fallback when that service is unreachable. SkillSpector is part of NVIDIA's Verified Skills pipeline, which the README describes as scanning, evaluating, and signing agent skills before publication.

The reason a scanner exists is the scale of the problem it measured. In the 31,132-skill analyzed subset of its research dataset, 26.1% of skills contained vulnerabilities and 5.2% showed likely malicious intent, according to the README. Those figures describe the dataset SkillSpector's authors analyzed, not every skill in circulation, and they are counts of pattern matches in skill files, not confirmed attacks. They are a reason to scan, not a verdict on any one skill.

Two stages of analysis are available. The static stage is fast and deterministic: it pattern-matches text, code structure, and declared permissions. The semantic stage sends the skill to a configured language-model provider to compare what the skill claims with what its code appears to do, which catches description-behavior mismatches and vague triggers that pattern matching misses. The semantic stage is optional and needs a provider key; the static stage needs none. For skills whose contents must not leave the machine, the static-only flag keeps the scan local, apart from the dependency-name lookups to OSV.dev described above.

Install

SkillSpector needs Python 3.12 or newer. Install it from the author's repository, in a virtual environment, following NVIDIA's scanning guide:

git clone https://github.com/NVIDIA/SkillSpector.git
cd SkillSpector
python3 -m venv .venv
source .venv/bin/activate
make install

If uv is available, the README also gives a one-command install:

uv tool install git+https://github.com/NVIDIA/skillspector.git

Confirm the install with skillspector --version. The version installed for the scans below was 2.12.0. A Docker image is also available from the repository's Dockerfile for machines without Python; the README gives the build and run commands.

Scan a skill

Copy the skill to a throwaway folder first and scan the copy, so nothing in the skill runs in your project before the decision is made. Scan a local directory, a single file, a repository URL, or a zip file:

skillspector scan ./my-skill/ --no-llm
skillspector scan ./SKILL.md --no-llm
skillspector scan https://github.com/user/my-skill --no-llm
skillspector scan ./my-skill.zip --no-llm

The --no-llm flag runs the static stage only, with no model key and no skill contents sent to a provider. Without it, the scan uses the configured provider for semantic analysis: set SKILLSPECTOR_PROVIDER and the provider's key variable (for example, OPENAI_API_KEY) first, as the README's provider table lists them. Output formats are terminal by default, with JSON, Markdown, and SARIF available through --format and --output for automation and review records. A baseline file suppresses findings already accepted, so rescans surface only new findings; the README and the suppression guide describe the baseline workflow.

Read the score as the start of a decision, not the decision. Static scans pattern-match text, so teaching material that documents attacks as examples scores badly: the vetting playbook linked below documents one security-teaching skill scoring the maximum severity on three scanners, including SkillSpector, for exploit code and example hosts shown as attacks to detect. A maximum verdict is a reason to read the findings, not a verdict by itself. Conversely, a low score is not proof of safety: the static stage reads text and does not execute the skill, and a partial scan — one that reports incomplete coverage — is a partial inspection, not a complete one. Use --fail-on-incomplete when partial coverage should fail a gate instead of passing quietly.

What the scans found

Three static-only scans show what the score means at both ends. SkillSpector's own skill-inspector skill scored 0, severity LOW, recommendation SAFE, with 0 issues at 100% coverage. The repository's malicious_skill test fixture scored 100, severity CRITICAL, recommendation DO NOT INSTALL, with 7 issues: two CRITICAL prompt-injection findings, one HIGH data-exfiltration finding, and four MEDIUM findings across data exfiltration and MCP least privilege. Both scans completed in under ten seconds on a small skill. A scan is only as complete as its coverage figure: a report that says coverage is incomplete has inspected only part of the skill, whatever the score says.

Skill contents go to the configured model provider by default when semantic analysis runs. That default is the scanner's sharpest edge for the job it does: the very files a user may not want leaving the machine are the files the semantic stage reads. The --no-llm flag is the control for that, and it should be the default for any skill that contains private material, until the user has deliberately chosen a provider and read what it receives.

Trust score: 6/10

A score is a signal, not a certification. This score rates the scanner itself, from a run of version 2.12.0 (static-only scans, above) and a read of the author's README and scanning guide. No full code read was done. It does not rate any skill the scanner checks.

The scanner loses points for two things it does by design. First, its default semantic mode sends skill contents to an external model provider, which is an exfiltration path for exactly the material being vetted; the static-only flag controls it, but the default is the sending mode. Second, it reads untrusted skill text as its input, so its findings depend on pattern coverage: a skill whose behavior is not covered by the 71 patterns, or a scan that reports incomplete coverage, can pass without being safe. It keeps points for what it does not do: the static stage does not execute the skill, the install runs no skill code, and the dependency lookups send dependency names and versions to OSV.dev, not skill contents. Rescore after any version change that alters the pattern set, the default provider behavior, or the coverage reporting.

Related skills

Sources

Sources: github.com/NVIDIA/skillspector, NVIDIA scanning guide.

Related playbooks: Vet a skill before you install it · Make sure your Claude Code skill actually loads when it should: test it in each agent before you rely on it · Agent Skills has a neutral home — and still no security story

Back to: Skills index