Skip to main content
Glama

skvil-mcp

MCP server for the Skvil security scanner

Verify, scan, and check on-chain certifications for AI agent skills — directly from your AI assistant.

npm version License: MIT Bun Node.js MCP


Why skvil-mcp?

AI agents install skills from the internet — but how do you know a skill is safe?

Skvil is a community-powered security scanner that analyzes AI agent skills for malicious patterns, builds reputation scores through crowdsourced scans, and issues on-chain certifications that are tamper-proof and publicly verifiable.

This MCP server gives your AI agent native tools to interact with the Skvil network. No HTTP knowledge required — just ask your agent to verify a skill.

On-chain certification

Skvil's certification pipeline is what sets it apart — the entire process is fully automated with zero human intervention:

  1. Community scanning — multiple independent agents scan the same skill

  2. Reputation building — scores aggregate via exponential moving average (EMA)

  3. Crucible analysis — automated static analysis scans 32+ pattern categories, then an AI triage phase (embeddings + LLM) validates findings and filters false positives

  4. On-chain registration — skills scoring ≥ 80 are automatically anchored on Solana via SPL Memo transactions, creating a tamper-proof trust anchor that no single party can forge or revoke silently

Certification is algorithmic: score ≥ 50 passes, score < 50 fails and revokes any existing certificate. A periodic re-certification scheduler re-analyzes certified skills and revokes those that no longer pass.

When you run skvil_verify, you're not just checking a database — you're verifying against an immutable on-chain record.


Related MCP server: vigile-mcp

Quick start

Tip: Works with both npx (Node) and bunx (Bun). We recommend Bun for faster installs and startup.

Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "skvil": {
      "command": "bunx",
      "args": ["@skvil/mcp-server"]
    }
  }
}
{
  "mcpServers": {
    "skvil": {
      "command": "npx",
      "args": ["-y", "@skvil/mcp-server"]
    }
  }
}

Claude Code

Add to your project's .mcp.json:

{
  "mcpServers": {
    "skvil": {
      "command": "bunx",
      "args": ["@skvil/mcp-server"]
    }
  }
}
{
  "mcpServers": {
    "skvil": {
      "command": "npx",
      "args": ["-y", "@skvil/mcp-server"]
    }
  }
}

VS Code / Cursor

Add to your settings (JSON):

{
  "mcp.servers": {
    "skvil": {
      "command": "bunx",
      "args": ["@skvil/mcp-server"]
    }
  }
}
{
  "mcp.servers": {
    "skvil": {
      "command": "npx",
      "args": ["-y", "@skvil/mcp-server"]
    }
  }
}

That's it. The server auto-registers a free API key on first use. Zero config.


Tools

Tool

Auth

Description

skvil_verify

No

Check if a skill is safe by its SHA-256 hash. Returns reputation score, risk level, on-chain certification status, and Crucible behavioral analysis.

skvil_stats

No

Community statistics: total skills scanned, trusted, critical, and on-chain certified counts.

skvil_certified

No

List skills with active on-chain certifications (V1/V2/V3/Gold). Up to 10 most recent.

skvil_catalog

No

Browse the full catalog of certified skills with metadata, install URLs, and provider info. Up to 100 skills.

skvil_register

No

Get a free API key (500 scans/day). Auto-cached locally for future use.

skvil_scan

Key

Submit security scan results to the community reputation network. Requires full skill identification (see below).

skvil_report

Key

Report a suspicious skill. Confirmed reports trigger automatic on-chain revocation.

skvil_scan — required fields

Every scan submission requires full identification so the Crucible behavioral analysis pipeline can fire:

Field

Type

Description

name

string

Skill name (max 256 chars)

composite_hash

string

sha256:{64 hex} — deterministic hash of all skill files

file_count

number

Number of files in the skill

file_hashes

object

Map of "relative/path" → "sha256 hex hash"

score

number

Computed security score 0-100 (server recomputes from findings)

risk_level

string

"safe" | "caution" | "danger"

skill_url

string

Required. Source URL — must be https://github.com/..., https://gitlab.com/..., or https://clawhub.ai/...

provider

string

Required. "github" | "gitlab" | "clawhub"

agent

string

Required. Agent platform submitting the scan (e.g. "claude", "codex", "openclaw")

findings

array

Security findings (severity, category, description, file, line)

frontmatter

object

Optional SKILL.md metadata

Without skill_url, the backend skips Crucible forwarding and the skill can never be certified.

Certification levels

Level

Meaning

V1

Basic verification — scanned by community, passed automated static analysis (32+ pattern categories + AI triage)

V2

Enhanced verification — V1 + passed Crucible behavioral analysis in sandboxed environment

V3

Full verification — V2 + passed periodic re-certification cycles

Gold

Highest trust — V3 + continuous monitoring, reserved for critical infrastructure skills

All levels are registered on-chain. The entire certification process is automated — no human review is involved at any level. Higher levels require progressively more rigorous automated verification.


Configuration

API key

The server automatically registers a free API key on first use and caches it in ~/.skvil/mcp-config.json.

To use an existing key:

{
  "mcpServers": {
    "skvil": {
      "command": "npx",
      "args": ["-y", "@skvil/mcp-server"],
      "env": {
        "SKVIL_API_KEY": "sk_your_key_here"
      }
    }
  }
}

Custom API URL

For self-hosted or development instances:

{
  "env": {
    "SKVIL_API_URL": "http://localhost:8000"
  }
}

Key resolution order

  1. SKVIL_API_KEY environment variable

  2. Cached key in ~/.skvil/mcp-config.json

  3. Legacy Python client key in ~/.skvil/config


Examples

"Is this skill safe to install?"

User: Check if sha256:4a2f...c81e is safe

Agent calls skvil_verify → gets reputation, certification, findings

Agent: This skill has a reputation score of 91.2 (safe) and is
       on-chain certified at V2 level. 15 community scans with
       no critical findings. Safe to install.

"What skills are certified?"

User: Show me certified skills

Agent calls skvil_certified → gets list of on-chain certified skills

Agent: There are 7 on-chain certified skills:
       1. web-scraper — V2, score 91.2, certified Feb 18
       2. data-pipeline — V1, score 85.0, certified Feb 15
       ...

"Report this suspicious skill"

User: Report sha256:dead...beef — it's sending data to an unknown server

Agent calls skvil_report → submits report

Agent: Report #42 submitted. The skill will be re-analyzed
       automatically. If the report is confirmed, the skill
       will be flagged and any on-chain certification will
       be revoked.

How it works

┌─────────────┐     stdio      ┌────────────┐     HTTPS     ┌──────────────────┐
│  AI Agent   │ ◄────────────► │  skvil-mcp │ ────────────► │  api.skvil.com   │
│  (Claude,   │    MCP tools   │  (local)   │   REST API    │  (reputation DB  │
│   GPT, etc) │                │            │               │   + on-chain)    │
└─────────────┘                └────────────┘               └──────────────────┘

The MCP server runs locally as a subprocess of your AI client. It translates MCP tool calls into HTTPS requests to the Skvil API. No data is stored remotely except scan results and reports — and certifications are anchored on-chain for public verification.


Development

git clone https://github.com/Skvil-IA/skvil-mcp.git
cd skvil-mcp
bun install   # or: npm install
bun run build # or: npm run build

Run locally

# Point to local API for development
SKVIL_API_URL=http://localhost:8000 bun dist/index.js

Test with MCP Inspector

npx @modelcontextprotocol/inspector node dist/index.js

Lint & format

npm run lint
npm run format
npm run typecheck

License

MIT — Skvil 2026

Available Tools

7 tools
skvil_catalogA

Browse the full catalog of Skvil-certified AI agent skills with detailed metadata: author, version, description, provider, agent platform, file count, and install URL. Returns up to 100 skills. Use this to discover safe skills available for installation.

Inputs: no named parameters.

skvil_certifiedA

List skills that have been verified and certified by Skvil admins. Certified skills have been manually reviewed and registered for tamper-proof verification. Returns up to 10 most recently certified skills with their level (V1/V2/V3/Gold), reputation score, and certification date.

Inputs: no named parameters.

skvil_registerA

Register for a free Skvil API key. The key is automatically cached locally for future use. No sign-up or account required. Other tools (skvil_scan, skvil_report) will use the cached key automatically.

Inputs: no named parameters.

skvil_reportA

Report a suspicious or malicious AI agent skill to Skvil admins for review. Requires an API key (use skvil_register first). Reports are reviewed by admins and confirmed findings lead to certification revocation.

Inputs: hash (required), reason (required), details.

skvil_scanA

Submit security scan results for an AI agent skill to the Skvil reputation network. Contributes to the community reputation score (EMA). Requires an API key (use skvil_register first). The server recomputes the score from findings — always provide accurate findings.

Inputs: name (required), composite_hash (required), file_count (required), file_hashes (required), +7 more.

skvil_statsB

Get aggregate statistics from the Skvil community network: total skills scanned, trusted count, critical findings, and certified skills.

Inputs: no named parameters.

skvil_verifyA

Check if an AI agent skill is safe before installing it. Returns reputation score, risk level, certification status, and community scan data. Use this to verify any skill by its SHA-256 composite hash.

Inputs: hash (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 7 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose with no overlap: catalog browsing, certified listing, registration, reporting, scanning, statistics, and verification. The descriptions specify unique functions, making misselection unlikely.

    Naming Consistency5/5

    All tools follow a consistent 'skvil_verb' pattern (e.g., skvil_catalog, skvil_register), using snake_case throughout. This predictability aids agent selection and readability.

    Tool Count5/5

    With 7 tools, the set is well-scoped for the domain of AI skill security and reputation management. Each tool serves a specific role, covering discovery, verification, reporting, and community interaction without bloat.

    Completeness4/5

    The toolset covers core workflows: discovery (catalog, certified), verification (verify, scan), reporting (report), and community stats. A minor gap is the lack of a tool for managing or revoking API keys, but agents can work around this.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides agent certification and trust verification tools for AI agents, enabling certification checks, trust score calculations, audit ticket issuance, and emergency kill switch activation through the A-SOC trust network.
      1 npm
      1
      -
    • A
      license
      A
      quality
      F
      maintenance
      Enables AI agents to query trust scores for MCP servers and agent skills while scanning content for potential security issues. It provides direct access to the Vigile trust registry to help users evaluate the safety of third-party tools and integrations.
      9
      25 npm
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      On-chain trust verification for AI agent tools. Agents query skill attestations, audit levels, and risk scores before running third-party MCP servers, so you know what's safe before you execute.
      -
    • A
      license
      A
      quality
      D
      maintenance
      Enables AI coding agents to scan smart contracts and code for vulnerabilities, check against 12 famous-hack patterns, and return public security receipts directly in the IDE.
      4
      18 npm
      MIT