Skip to main content
Glama

PyPI version PyPI - Python Version License: Apache 2.0 codecov VS Code Marketplace MCP Toplist

Docs · Quick start · Website · VS Code · Discord

English | Deutsch | 简体中文

What is Skylos?

Skylos is a free, open-source (Apache-2.0) checker for the code you and your coding agents write. It runs on your machine, inside your agent's loop and as a pull-request gate. No account, no API key and no LLM needed.

Coding agents such as Claude Code, Codex and Cursor write code faster than anyone can review it, and they repeat the same mistakes. They say "done" after deleting or skipping a failing test. They install packages that don't exist and import functions nobody wrote. They leave injection bugs and hard-coded keys behind. Linters and security scanners each catch a slice of this, after the fact. Skylos checks all of it in one tool, at the points where it can still be stopped.

It is built for:

  • Developers who let agents write code, and want the agent checked while it works, not after.

  • Maintainers who want one free check on every pull request.

  • Existing codebases that need security, secrets, dependency, quality and dead-code findings from one scan, in Python, TypeScript, Java, Go and more.

Related MCP server: loctree-mcp

Quick start

pip install skylos
skylos . -a          # scan this repo with every check; nothing leaves your machine

Key commands

No account needed. Your code and findings stay on your machine.

To

Run

Find dead code

skylos .

Run every check: security, secrets, dependencies, quality, AI-code mistakes

skylos . -a

Check only what your branch changed

skylos . -a --diff origin/main

Fail the build when the gate fails

skylos . --gate

Check the agent really finished (runs your tests)

skylos done --base main

Check every pull request in CI

skylos cicd init

Set up Claude Code and Codex in this repo

skylos setup

Skylos Cloud: see results online and block failing pull requests

Optional. Five steps, in this order, from your repository folder. No token to copy.

Step

Run or do

What happens

1. Upload your first scan

skylos cloud

Your browser opens skylos.dev. Sign in, then pick or create the project for this repo. Back in the terminal, Skylos scans and uploads the findings (not your code).

2. Open your results

Click the Open: link it prints

The scan in your dashboard: its gate result and every issue. Find it again later at skylos.dev/dashboard.

3. Add the pull request check

skylos cicd init

Writes .github/workflows/skylos.yml and prints the next steps: the git commands that open a pull request with it, and the GitHub App link.

4. Install the GitHub App, then merge

Open the GitHub App link it printed

Install the Skylos GitHub App on the repo before you merge that pull request. CI then uploads with its GitHub identity, so there is no token or secret to add.

5. Make the check required

skylos setup

Run it after the merge (it uses the GitHub CLI, gh). A pull request that fails the Skylos check can no longer merge.

Done: every pull request gets a Skylos check, and every push to your default branch shows up in your dashboard.

The end of step 1 looks like this:

✓ Scan saved · gate (not blocking): fail
  Open: https://skylos.dev/dashboard/projects/<project>/scans/<scan>
  Saved for review. Only verified CI scans block merges and update the project verdict.
  Next: to block pull requests, run skylos cicd init and merge the workflow it writes.

A scan from your machine is saved for review but never blocks a merge; only CI scans do. Upload again any time with skylos cloud. Details: Skylos Cloud.

Working with a coding agent? skylos setup once per repo, then skylos open every day for a diagram of your code, what changed, and every check run. The tutorial walks through a real session.

How it works

Skylos steps in at four points:

When

Command

What it stops

While the agent works

skylos agent install-hooks

Made-up package installs, reads of files holding secrets, git-hook bypasses; checks every edit

When the agent says "done"

skylos done --base main

Deleted or skipped tests, loosened CI steps, silenced lint or type checks, test-only special cases; runs your tests

On every pull request

skylos cicd init

Critical security issues, secrets and critical AI-code mistakes, plus anything over your limits

Any time, on the whole repo

skylos . -a

Security flaws, secrets, vulnerable dependencies, quality regressions, AI-code mistakes, dead code

See it work

A 20-line Flask app, scanned with every check (excerpt):

$ skylos . -a --format concise
app.py:15  SKY-D211  Possible SQL injection: tainted or string-built query.
app.py:5  SKY-L012  Import from local module 'billing' requests 'issue_refund', but that name is not defined or re-exported there.
app.py:8  SKY-S101  Potential stripe secret detected
requirements.txt:1  SKY-SCA-GHSA-68rp-wp8r-4726  flask@3.1.2: Flask session does not add `Vary: Cookie` header when accessed in some ways
billing.py:1  SKY-U001  unused function: charge_card

Every finding names the file, line and rule. Security findings show the source-to-sink path when one was recorded; --format json keeps the full evidence.

Check every agent edit

Install hooks so the agent is checked while it works:

skylos agent install-hooks            # Claude Code
skylos agent install-hooks --codex    # Codex
skylos agent install-hooks --cursor   # Cursor
  • After each edit: checks the changed lines for security issues, secrets and AI-code mistakes, and tells the agent what to fix.

  • Before a file read: blocks files that contain hard-coded secrets.

  • Before a package install (pip, uv, npm, pnpm, bun, go, ...): blocks made-up or typosquatted packages, and asks before installs it cannot verify.

  • Before a git command: blocks --no-verify and other ways around your git hooks.

  • At stop: blocks "done" while issues the agent added are still open.

If Skylos itself errors, the action is allowed and both you and the agent are told it went unchecked. See agent hooks.

Is the agent really done?

skylos done --base main

skylos done compares the branch with main and runs your tests. It flags:

  • deleted, skipped or weakened tests

  • loosened test settings and CI test steps

  • silenced lint or type checks

  • code that special-cases the tests

  • code the branch left with no callers (advice, not a block)

When a test fails, it reruns it on main and labels the failure "introduced" or "already failing". It writes a receipt to .skylos/receipts/. pytest runs automatically; other runners need one line:

[tool.skylos.done]
test_command = "npm test"

It reads its settings from main, so a branch cannot loosen its own check. Exit codes: 0 pass, 1 blocked, 2 could not run. See the done gate and what it misses.

Gate pull requests

No account or token needed:

git checkout -b add-skylos-gate
skylos cicd init --no-upload
git add .github/workflows/skylos.yml
git commit -m "Add Skylos pull request gate"
git push -u origin add-skylos-gate

The workflow reviews the changed lines of each pull request and runs skylos done when it finds your tests. skylos cicd init also sets up GitLab CI, Jenkins, Bitbucket Pipelines, Azure Pipelines and CircleCI (any CI).

The gate always fails on a critical security issue, a secret, or a critical AI-code issue such as an import of a package that doesn't exist. Everything else fails only above your limits:

[tool.skylos.gate]
max_high = 5          # high-severity security issues allowed
max_quality = 10      # quality issues allowed
max_ai_defects = 10   # AI-code issues allowed

The policy is read from the base branch, so a pull request cannot loosen its own gate. Each run ends with Quality Gate: PASSED, FAILED (exit 1) or INCOMPLETE (exit 2) and the reasons. Walkthrough: your first gated pull request.

Need a person to sign off on risky changes? skylos cicd init --risk-review adds a check that waits for a human approval when a pull request deletes tests, removes auth checks, changes dependencies or weakens CI. See risk review.

Scan a repository

skylos .                         # dead code (fast, default)
skylos . -a                      # every check
skylos . -a --diff origin/main   # only findings on changed lines
skylos . --format pretty         # grouped report with code snippets
skylos . --tui                   # keyboard-driven triage
skylos . -a --format json        # full evidence for scripts and agents
skylos . --format sarif          # GitHub code scanning
skylos cleanup . --top 5         # a prioritized fix list

Python dead code can be removed for you: skylos clean . --dry-run shows the plan, --apply edits files. Output modes and exit codes: CLI output.

What Skylos catches

Category

Examples

AI-code mistakes

imports of functions that don't exist, invented package APIs, packages that don't exist, impossible versions, unfinished stubs, disabled controls

Security flaws

SQL injection, XSS, SSRF, path traversal, command injection, unsafe deserialization, ReDoS

Secrets

API keys, tokens, private credentials, high-entropy strings

Dependencies

known CVEs, malicious packages, license policy, offline SBOM (CycloneDX, SPDX)

Quality

complexity, deep nesting, duplicate branches, long functions, inconsistent returns

Dead code

unused functions, classes, imports, files and dependencies, framework-aware (FastAPI, Django, Flask, Next.js, React, Laravel, ...)

CI/CD and deployment

risky GitHub Actions and GitLab CI, Dockerfiles, Docker Compose, systemd, Kubernetes

LLM apps

unsafe tool use, prompt-injection exposure, missing output validation

Every rule: Rules Reference and rule dictionary.

Verify the AI apps you build

If your code calls an LLM, Skylos checks the guardrails around it, with no model in the loop:

skylos discover .                    # list LLM calls, agent tools and prompt sites
skylos defend .                      # score the guardrails around them
skylos defend . --fail-on critical   # CI gate
skylos defend . --format md -o evidence.md   # evidence report with OWASP LLM Top 10 coverage

It covers Python and TypeScript/JavaScript; --owasp-framework agentic reports against the OWASP Agentic Top 10. To test a running agent against expected answers and tool calls, use skylos agent test. See agent verification and agent behavior testing.

Language Support

Language

Dead code

Security

Quality

Python

Yes

Yes

Yes

TypeScript / JavaScript

Yes

Yes

Yes

Java

Yes

Yes

Yes

Go

Yes

Partial

Partial

PHP

Yes

Yes

No

Rust

Experimental

Partial

Partial

Ruby

Partial

Partial

No

Dart

Yes

Partial

No

C#

Partial

Partial

Partial

C++

Partial

No

No

Kotlin

Partial

Partial

No

Swift

Partial

No

No

Shell

No

Partial

No

  • Python has the deepest coverage.

  • Go needs the native skylos-go engine. It ships in the PyPI wheels for Linux, macOS and Windows; elsewhere skylos doctor prints the build command.

  • Dart needs pip install "skylos[dart]".

  • Rust dead code is hidden by default; --confidence 40 shows it.

Full matrix and per-language limits: language support.

Configuration

skylos init adds a starter config to pyproject.toml. Projects without one can use skylos.toml with the same keys at the top level:

# skylos.toml
exclude = ["generated", "dist"]

[gate]
max_high = 5

[done]
test_command = "npm test"

In a monorepo, each package can have its own file; the nearest one wins per key. skylos doctor shows which files are in use.

Silence one finding with a reason:

query = build_query(user_id)  # skylos: ignore[SKY-D211] user_id is an int from the router

To accept existing findings and gate only new ones, run skylos baseline . and scan with --baseline. More: configuration.

Integrations

Integration

What it does

GitHub Action

Pull-request gate, optional container-image gate

GitLab, Bitbucket, Azure, Jenkins, CircleCI

Pull-request gate for that CI

Agent hooks

Claude Code, Codex and Cursor checked on every edit

MCP server

Skylos scans as tools for AI assistants

VS Code extension

Findings in the editor

Skylos Cloud

Optional: findings and the gate per branch, over time

Install options

pip install skylos              # core checks
pip install "skylos[llm]"       # agent commands that use an LLM
pip install "skylos[all]"       # every optional extra

Or run the container image:

docker run --rm -v "$PWD":/work -w /work ghcr.io/duriantaco/skylos:latest . -a

Other extras (lint, verdict, dart), Python-specific image tags and source installs: installation.

What leaves your machine

Your code and findings reach Skylos Cloud only when you run a command that says it uploads, such as skylos cloud or --upload. A saved login alone never uploads anything. There are no analytics.

Dependency and package checks send package names and versions to OSV and the public registries, never source. LLM commands share code only with the model provider you configure. Every request, its trigger and how to turn it off: privacy and network.

Results

10 Skylos-assisted dead-code cleanup PRs have been merged in 9 open-source projects, including Black, NetworkX, Optuna, mitmproxy and pypdf. Real-World Results lists all 26 PRs we recorded, including the ones that were closed or reverted. These are accepted cleanups, not endorsements.

Methods, dated results and competitor comparisons: BENCHMARK.md.

FAQ

Does Skylos replace Semgrep, CodeQL, Bandit or Vulture? No. It runs alongside them. It adds agent checks, framework-aware dead code and one gate across security, secrets, dependencies and quality.

Does it need an LLM? No. The core checks run locally with no model. LLM features are optional (skylos[llm]).

Is it free? The CLI is free and open source. Skylos Cloud is optional and has a free plan; see pricing.

Can I check only my changes? Yes: skylos . -a --diff origin/main. A removed security check, such as a deleted auth decorator, is still reported.

What about code that is only called dynamically? Use inline ignores, a baseline, or --trace to record what actually runs. See smart tracing.

More: FAQ.

Documentation

Need

Read

Every command and flag

CLI reference

Install, extras, Docker

Installation

Config files, ignores, baselines

Configuration

Output formats and exit codes

CLI output

Agent hooks

Agent hooks

skylos done

Done gate

Pull-request gates

First gated PR, any CI

Security and taint analysis

Security

Dependencies, SBOM, licenses

Dependency scanning, licenses

AI-code checks

AI code verification

Network requests

Privacy and network

Rule IDs

Rule dictionary

Contributing

License

Apache License 2.0. See LICENSE.

Available Tools

24 tools
analyzeFind dead codeA
Read-only

Find dead code: unused functions, classes, imports, variables, parameters and files.

Use this to list cleanup candidates in a project. Returns JSON with a summary and per-category findings (file, line, name, confidence) plus _run_id; the full result is stored locally and can be read from the skylos://results/{run_id} resource. Read-only: it never edits code. Findings are candidates: before deleting one, check for dynamic use (getattr, string dispatch, entry points, framework decorators, tests). A non-empty analysis_errors means analysis or verification was incomplete; do not treat the findings as a complete scan.

Defect and Review records remain complete. Advice is grouped by default; expand_advice=True includes every Advice record. Read _result_uri for the complete saved result without rescanning.

Works without SKYLOS_API_KEY (5 calls/day); higher limits with a key.

Inputs: path (required), confidence, expand_advice, exclude_folders. Returns: result

architecture_checkCheck architectureA
Read-only

Report architecture findings for a project: module coupling, cohesion and circular dependencies.

Returns JSON with the architecture findings and _run_id. Read-only and local. Use quality_check for function-level issues.

Defect and Review records remain complete. Advice is grouped by default; expand_advice=True includes every Advice record. Read _result_uri for the complete saved result without rescanning.

Requires SKYLOS_API_KEY: this tool returns an authentication error unless the MCP server is started with SKYLOS_API_KEY set. Without a key, analyze works (5 calls/day) and the local map tools (change_map and the graph_* tools) work with no limit. The local CLI needs no key: skylos verify <file> and skylos agent install-hooks.

Inputs: path (required), confidence, expand_advice, exclude_folders. Returns: result

change_mapMap what a change touchesA
Read-only

Map what a code change touches, to review it: every changed Python or TypeScript/JavaScript function, method or class with its old and new code, calls added and removed, calls that only moved into a helper, its callers (with call lines, and whether each caller was updated), removed security checks and access checks, breaking or compatible signature changes, changed module values and the functions using them, and a review plan: read first, read, skim, or skip (skip only when the logic is proven the same: docstring only or local names only; moved code is skim because its import path changed), with changed-line counts and tests whose expected answers changed. Flags list what a person must look at.

Computed from the code, not by a model: the same commit gives the same map. Returns JSON. Read-only and local.

Works without SKYLOS_API_KEY and has no daily limit: it reads the repository on this machine and sends nothing to Skylos Cloud.

Inputs: base, path. Returns: result

generate_fixGenerate a dead-code removal patchA
Destructive

Build a unified-diff patch that removes (or comments out) dead code found by static analysis, after grep verification drops findings that are still referenced.

Returns the diff, patch summary, validation errors and applied status. With apply=False (default) it previews changes; with apply=True it edits files if patch validation succeeds. Refuses to run when the analysis or grep verification was incomplete. Review the diff and run trusted tests before keeping it.

Requires SKYLOS_API_KEY: this tool returns an authentication error unless the MCP server is started with SKYLOS_API_KEY set. Without a key, analyze works (5 calls/day) and the local map tools (change_map and the graph_* tools) work with no limit. The local CLI needs no key: skylos verify <file> and skylos agent install-hooks.

Inputs: path (required), mode, apply, min_safety. Returns: result

get_security_contextSummarize security contextA
Read-only

Summarize a project's security setup: detected web frameworks, auth decorators and middleware, security headers, rate limiting, input validation and a supported Skylos YAML policy file.

Use it before reviewing or writing security-sensitive code to learn the project's conventions. Returns JSON. Read-only and local.

Requires SKYLOS_API_KEY: this tool returns an authentication error unless the MCP server is started with SKYLOS_API_KEY set. Without a key, analyze works (5 calls/day) and the local map tools (change_map and the graph_* tools) work with no limit. The local CLI needs no key: skylos verify <file> and skylos agent install-hooks.

Inputs: path (required). Returns: result

get_triage_suggestionsSuggest triage decisionsA
Read-only

Suggest accept or dismiss for current findings, based on decisions recorded with learn_triage in this project.

Returns JSON suggestions with finding fingerprints, suggested actions and confidence, plus the number of learned patterns. Read-only and local.

Requires SKYLOS_API_KEY: this tool returns an authentication error unless the MCP server is started with SKYLOS_API_KEY set. Without a key, analyze works (5 calls/day) and the local map tools (change_map and the graph_* tools) work with no limit. The local CLI needs no key: skylos verify <file> and skylos agent install-hooks.

Inputs: path (required). Returns: result

graph_areasThe areas of the codebaseA
Read-only

The codebase split into areas: groups of functions and classes that work together, grouped folder by folder and named after the folder and the member the rest of the code depends on most, with its size, folders and links to other areas. Pass an area id to get its members, most important first, and the areas it links to. Use it to get oriented in an unfamiliar repository. Returns JSON. Read-only and local.

Works without SKYLOS_API_KEY and has no daily limit: it reads the repository on this machine and sends nothing to Skylos Cloud.

Inputs: area, path. Returns: result

graph_describeSave plain-English descriptions to the codebase graphA

Save descriptions you wrote for items from graph_pending into .skylos/graph/notes.json, where the graph viewer and graph_show read them. A replaced description is kept as the previous one, so readers can see what the code did before. Unknown ids are ignored, and so are impact entries for callers graph_pending did not list with that change. Summaries are capped at 400 characters and impact effects at 300. Writes one local file.

Works without SKYLOS_API_KEY and has no daily limit: it reads the repository on this machine and sends nothing to Skylos Cloud.

Inputs: items (required), path. Returns: result

graph_findFind code in the codebase graphA
Read-only

Search the codebase graph for functions, methods and classes by name. Each result has its id, file, line and plain-English summary when one exists. Builds the graph first if the repository has none (Python, TypeScript, JavaScript). Returns JSON. Read-only and local.

Works without SKYLOS_API_KEY and has no daily limit: it reads the repository on this machine and sends nothing to Skylos Cloud.

Inputs: query (required), path, include_tests. Returns: result

graph_impactWhat depends on a functionA
Read-only

Everything in the repository that calls a function or class, directly or through other code, grouped by distance, plus the tests that reach it. Use it before changing a signature or behaviour. Returns JSON. Read-only and local.

Works without SKYLOS_API_KEY and has no daily limit: it reads the repository on this machine and sends nothing to Skylos Cloud.

Inputs: name (required), path, depth. Returns: result

graph_pendingCode that still needs a plain-English descriptionA

Functions and classes that have no plain-English description yet (or whose code changed since it was written), with their source, callers and callees. Write the descriptions yourself and save them with graph_describe; nothing is sent to any model by this tool. With changes=true, lists changed code whose logic changed (not code proven to keep the same logic) to explain instead, each with its old and new code, proven facts, the tests that reach it and its callers (code proven to call it within 2 steps, with what each does today), and writes .skylos/graph/changes.json for the viewer; explain each change and, in impact, how it changes each listed caller that behaves differently. Use change_map first to see what to read. Returns JSON. Local.

Works without SKYLOS_API_KEY and has no daily limit: it reads the repository on this machine and sends nothing to Skylos Cloud.

Inputs: base, path, limit, changes. Returns: result

graph_relevantCode that matters most to the files you are changingA
Read-only

The functions and classes elsewhere in the repository that matter most to the given files, most important first, cut to a token budget: each with its signature, file and line, plain-English summary, how it relates to the files (calls them, called by them) and its area. Use it before editing to know what else to read. Returns JSON. Read-only and local.

Works without SKYLOS_API_KEY and has no daily limit: it reads the repository on this machine and sends nothing to Skylos Cloud.

Inputs: files (required), path, budget. Returns: result

graph_showExplain one function or class from the codebase graphA
Read-only

One function, method or class from the codebase graph: its plain-English summary, signature, who uses it, what it uses, the tests that reach it within 3 calls, literal input/output pairs its tests expect, and its change verdict when the working tree changed it. Also: description (now, and before when the code changed since the previous one was written), change_note (the saved change explanation, with impact: how the change reaches each caller) and impact_preview (code proven to call it within 3 steps, production first, then tests). Returns JSON. Read-only and local.

Works without SKYLOS_API_KEY and has no daily limit: it reads the repository on this machine and sends nothing to Skylos Cloud.

Inputs: name (required), path, with_code. Returns: result

health_scoreAssess codebase healthA
Read-only

Assess a project through separate Risk, Maintainability and Dead code readouts.

This tool retains its health_score name for compatibility but no longer creates a blended numeric grade. Gate policy remains independent. Returns assessment, coverage, finding counts and _run_id. Read-only and local. Advice is grouped by default; expand_advice=True includes every Advice record. Read _result_uri for the complete saved result.

Requires SKYLOS_API_KEY: this tool returns an authentication error unless the MCP server is started with SKYLOS_API_KEY set. Without a key, analyze works (5 calls/day) and the local map tools (change_map and the graph_* tools) work with no limit. The local CLI needs no key: skylos verify <file> and skylos agent install-hooks.

Inputs: path (required), confidence, expand_advice, exclude_folders, +3 more. Returns: result

learn_triageRecord a triage decisionA

Record whether a finding was accepted or dismissed so get_triage_suggestions can learn from it.

Writes the decision to the project's local Skylos state.

Requires SKYLOS_API_KEY: this tool returns an authentication error unless the MCP server is started with SKYLOS_API_KEY set. Without a key, analyze works (5 calls/day) and the local map tools (change_map and the graph_* tools) work with no limit. The local CLI needs no key: skylos verify <file> and skylos agent install-hooks.

Inputs: path (required), action (required), action_id (required). Returns: result

provenance_scanAttribute changes to agents or humansA
Read-only

Report available evidence of AI-agent, bot and human contributions.

Combines git signals since the base (agent bot accounts, Co-authored-by and AI declaration trailers, agent-named commit subjects) with recorded local attribution evidence. Returns JSON with per-file attribution, evidence and coverage status. Commit declarations do not establish line authorship; missing evidence remains unknown. Read-only and local.

Requires SKYLOS_API_KEY: this tool returns an authentication error unless the MCP server is started with SKYLOS_API_KEY set. Without a key, analyze works (5 calls/day) and the local map tools (change_map and the graph_* tools) work with no limit. The local CLI needs no key: skylos verify <file> and skylos agent install-hooks.

Inputs: path (required), diff_base. Returns: result

quality_checkCheck code qualityA
Read-only

Report code-quality issues: high complexity, deep nesting, long functions, duplicate branches and similar maintainability findings.

Returns JSON with findings (rule ID, file, line, message) and _run_id. Read-only and local.

Defect and Review records remain complete. Advice is grouped by default; expand_advice=True includes every Advice record. Read _result_uri for the complete saved result without rescanning.

Requires SKYLOS_API_KEY: this tool returns an authentication error unless the MCP server is started with SKYLOS_API_KEY set. Without a key, analyze works (5 calls/day) and the local map tools (change_map and the graph_* tools) work with no limit. The local CLI needs no key: skylos verify <file> and skylos agent install-hooks.

Inputs: path (required), confidence, expand_advice, exclude_folders. Returns: result

remediatePlan or apply LLM fixesA
Destructive

Plan or apply LLM-generated fixes for Skylos findings in a project.

With dry_run=True (default), static analysis returns a remediation plan without calling a model or changing files. With dry_run=False, it generates fixes and can edit files in place: this needs the skylos[llm] extra and provider configuration (including credentials when required), and sends affected code to that provider. It does not run your tests. Review every change and run trusted tests before keeping it. Costs no Skylos credits. Scan tools cost no credits either.

Requires SKYLOS_API_KEY: this tool returns an authentication error unless the MCP server is started with SKYLOS_API_KEY set. Without a key, analyze works (5 calls/day) and the local map tools (change_map and the graph_* tools) work with no limit. The local CLI needs no key: skylos verify <file> and skylos agent install-hooks.

Inputs: path (required), model, dry_run, severity, +2 more. Returns: result

secrets_scanFind hard-coded secretsB
Read-only

Find hard-coded secrets and credentials (API keys, tokens, private keys, passwords) in source and config files.

Returns JSON with findings (provider, file, line) and _run_id. Secret values are redacted in the output. Read-only and local.

Defect and Review records remain complete. Advice is grouped by default; expand_advice=True includes every Advice record. Read _result_uri for the complete saved result without rescanning.

Requires SKYLOS_API_KEY: this tool returns an authentication error unless the MCP server is started with SKYLOS_API_KEY set. Without a key, analyze works (5 calls/day) and the local map tools (change_map and the graph_* tools) work with no limit. The local CLI needs no key: skylos verify <file> and skylos agent install-hooks.

Inputs: path (required), confidence, expand_advice, exclude_folders. Returns: result

security_scanScan for security issuesA
Read-only

Scan source code for security issues such as SQL and command injection, SSRF, path traversal, eval/exec and unsafe deserialization.

Returns JSON with findings (rule ID, severity, file, line, message) and _run_id. Read-only; the scan runs locally and does not upload code. Use secrets_scan for hard-coded credentials and validate_code_change to check a diff before it lands.

Defect and Review records remain complete. Advice is grouped by default; expand_advice=True includes every Advice record. Read _result_uri for the complete saved result without rescanning.

Requires SKYLOS_API_KEY: this tool returns an authentication error unless the MCP server is started with SKYLOS_API_KEY set. Without a key, analyze works (5 calls/day) and the local map tools (change_map and the graph_* tools) work with no limit. The local CLI needs no key: skylos verify <file> and skylos agent install-hooks.

Inputs: path (required), confidence, expand_advice, exclude_folders. Returns: result

validate_code_changeCheck a diff before it landsA
Read-only

Validate a code diff for security regressions and issues before it lands.

Takes a unified diff and checks for:

  • Security control regressions (auth, CSRF, TLS, rate limiting removal)

  • New dangerous patterns (eval, exec, SQL injection, etc.)

  • Secrets in added code

  • Hallucinated or undeclared dependencies in added imports and manifest entries (requirements*.txt, pyproject.toml, package.json, go.mod), verified against the package registries. The "registry" field reports "ok", "unreachable" or "error" (lookups incomplete — do not treat pass as clean), or "skipped".

Returns pass/fail with findings.

Requires SKYLOS_API_KEY: this tool returns an authentication error unless the MCP server is started with SKYLOS_API_KEY set. Without a key, analyze works (5 calls/day) and the local map tools (change_map and the graph_* tools) work with no limit. The local CLI needs no key: skylos verify <file> and skylos agent install-hooks.

Inputs: diff (required), path, policy, check_dependencies. Returns: result

verify_agentVerify an AI agent's guardrailsA
Read-only

Statically verify an AI agent's guardrails before deployment.

Deterministic, local pre-deployment agent verification: inventories LLM integrations, runs the defense checks (prompt-injection exposure, dangerous sinks, tool scope, output validation, PII filtering, cost controls), and returns scores, failed checks with remediation, OWASP LLM/Agentic coverage, and a reproducible attestation digest. No model is involved in the verdict and the analysis runs locally; source code is not sent to Skylos Cloud. Optional gate: set fail_on (severity) and/or min_score (0-100).

Requires SKYLOS_API_KEY: this tool returns an authentication error unless the MCP server is started with SKYLOS_API_KEY set. Without a key, analyze works (5 calls/day) and the local map tools (change_map and the graph_* tools) work with no limit. The local CLI needs no key: skylos verify <file> and skylos agent install-hooks.

Inputs: path, fail_on, min_score, owasp_version, +2 more. Returns: result

verify_changeVerify an edited file or rangeA
Read-only

Verify a changed file/range for AI-code defects and security bugs.

Returns a narrow, versioned JSON verdict containing AI-code trust findings such as hallucinated references, unfinished generated code, stale references, disabled controls, and dependency hallucinations (checked by default; pass include_dependency_hallucinations=False to skip the registry lookups), plus high/critical security findings (category "security") and hard-coded secrets (category "secret", values redacted) in the selected file/range. Pass include_security_findings=False to skip the security and secret checks.

Requires SKYLOS_API_KEY: this tool returns an authentication error unless the MCP server is started with SKYLOS_API_KEY set. Without a key, analyze works (5 calls/day) and the local map tools (change_map and the graph_* tools) work with no limit. The local CLI needs no key: skylos verify <file> and skylos agent install-hooks.

Inputs: file, path, confidence, line_range, +6 more. Returns: result

verify_dead_codeVerify dead code with an LLMA
Read-only

Ask an LLM to review selected unused function, class, import and variable candidates, with its reasoning.

Use it after analyze when you need fewer false positives before deleting code. Sends code snippets and search results to the chosen model provider, so it needs the skylos[llm] extra and provider configuration, including credentials when required. Candidates outside the review limits, or whose use remains uncertain, can remain unverified. Does not edit files. Refuses to run when the static analysis was incomplete.

Requires SKYLOS_API_KEY: this tool returns an authentication error unless the MCP server is started with SKYLOS_API_KEY set. Without a key, analyze works (5 calls/day) and the local map tools (change_map and the graph_* tools) work with no limit. The local CLI needs no key: skylos verify <file> and skylos agent install-hooks.

Inputs: path (required), model, confidence, max_verify, +2 more. Returns: result

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 24 tools

    Disambiguation3/5

    The individual descriptions are strong and often cross-reference each other (security_scan points to secrets_scan, architecture_check to quality_check), but several genuine overlaps remain: verify_change and validate_code_change both validate a change for security/secret problems, and analyze / health_score / verify_dead_code / generate_fix / remediate form a dead-code pipeline whose entry points are easy to confuse. The eight graph_*/change_map tools are more clearly delimited, but an agent must read long descriptions carefully to pick the right scan-vs-verify-vs-fix tool.

    Naming Consistency3/5

    Mixed conventions: noun_verb (health_score, security_scan, quality_check, secrets_scan, architecture_check, provenance_scan), verb_noun (generate_fix, learn_triage, get_triage_suggestions, validate_code_change, verify_change, verify_agent, get_security_context, verify_dead_code), bare verbs (analyze, remediate), and a noun_verb graph family (graph_find, graph_show...). Everything is snake_case and readable, and the graph_ prefix groups that family well, but the verb-first/noun-first split is not predictable.

    Tool Count3/5

    At 24 tools this sits at the heavy end; the graph_* family (7 tools) plus change_map is justified as a coherent subsystem, but the top-level scan/fix surface (security_scan, secrets_scan, quality_check, architecture_check, analyze, health_score, provenance_scan...) pushes the surface wider than most agents need at once and increases selection cost.

    Completeness4/5

    Coverage is broad and lifecycle-aware: detection (analyze, security_scan, secrets_scan, quality_check, architecture_check, provenance_scan), remediation (generate_fix, remediate), pre-land validation (validate_code_change, verify_change, verify_agent), triage learning, and a full codebase-graph navigation subsystem. Minor gaps exist around run management (results only via _result_uri resources, no listing/comparison tool) and no explicit baseline/suppression or policy-editing tool beyond get_security_context.

    Maintenance

    ActivityActive
    ResponsivenessUsually handled

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      F
      maintenance
      A high-performance MCP server providing lightning-fast hybrid code search using TF-IDF and vector embeddings for AI assistants. It enables real-time codebase indexing and semantic retrieval with sub-50ms latency and offline support.
      12
      MIT
    • F
      license
      Not graded
      quality
      B
      maintenance
      Structural code intelligence for AI agents. Scan once, query everything — dead exports, circular imports, dependency graphs, and more. CLI + MCP server.
      10
      -
    • F
      license
      Not graded
      quality
      D
      maintenance
      Give your AI coding agents superpowers — a local MCP server for fast, token-efficient code navigation, search & analysis.
      -