More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    License & Dependency Compliance Auditor

    2

    Automated open-source license audit and risk assessment based on your project's specific distribution model.

    $10

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    License & Dependency Compliance Auditor

    Example session with this skill installed

    We're a proprietary SaaS about to raise a round. Audit our dependencies for any license that could be a problem in due diligence.

    • Read your context and instructions
    • Compiled the license & dependency

    Detected: npm (pnpm-lock) + Go modules. Project license: none found. Distribution model: proprietary hosted SaaS. Analyzed 47
    direct / 612 transitive deps.

    Writing the full report to LICENSE_AUDIT.md.

    Summary: 10 findings — 2 Critical, 3 High, 3 Medium, 2 Low.

    Deal-breaker for due diligence: rrweb@2.0.0 is AGPL-3.0 and you ship as hosted SaaS. AGPL's network clause means using it
    obligates open-sourcing your entire application — exactly what an acquirer's counsel flags. Replace it with a permissive
    session-replay library before the raise.

    Also Critical: fast-geoip-pro@1.4.2 has no license at all — that's all-rights-reserved, you have no right to ship it.

    High: project has no LICENSE declared; 96 Apache-2.0 deps ship to the browser with no aggregated NOTICE; a BUSL-1.1 Terraform
    provider needs its internal-use grant confirmed.

    First moves: swap rrweb, resolve the unlicensed geoip dep, add a project LICENSE. Full details with versions, SPDX ids, and
    fixes in LICENSE_AUDIT.md.

    This is an engineering analysis, not legal counsel — have an attorney confirm before the raise.

    Writing the full report to LICENSE_AUDIT.md

    Connects securely to your tools. The creator never sees your data.

    About this skill

    A single GPL or AGPL dependency can force you to open-source your entire product, or sink an acquisition in due diligence. This skill audits your dependency tree for license risk — scoped to how your project actually ships, because the same dependency can be perfectly fine in one model and a violation in another.

    What makes it different

    It detects your distribution model first — hosted SaaS, distributed app/binary, open source, or internal tool — then judges every dependency against it. AGPL is a non-issue for a CLI tool but a Critical violation in proprietary SaaS. GPL is fine in your backend but not in a distributed binary. Generic license scanners ignore this; this one leads with it.

    What it checks

    • Copyleft conflicts AGPL in proprietary SaaS (the #1 startup trap — network use counts as distribution), GPL in distributed proprietary software, LGPL static-linking nuances, MPL file-level reciprocity
    • Source-available licenses: BUSL, SSPL, Elastic License, FSL, Confluent — used commercially against their terms. Tracks the version whipsaw (Redis → AGPL 2025, Elasticsearch → AGPL 2024, Terraform → BUSL 2023)
    • Attribution duties: missing NOTICE files (Apache-2.0), stripped copyright headers, no aggregated third-party licenses when distributing (including browser-shipped frontend bundles)
    • Unknown / no license: dependencies that are all-rights-reserved by default — no legal right to use
    • Your own project: missing or mismatched LICENSE, outbound/inbound incompatibility for open-source projects

    Ecosystems

    npm/yarn/pnpm, PyPI (pip/poetry/pipenv), Cargo, Go modules, Maven/Gradle, RubyGems, Composer, NuGet, pub.dev — reads direct and transitive dependencies from lock files, distinguishes shipped vs dev/build-only.

    How it works

    1. Detects ecosystems + your project license + distribution model (asks if ambiguous).
    2. Builds the dependency license map from lock files, with SPDX identifiers.
    3. Audits each against the distribution model and per-license obligations.
    4. Writes LICENSE_AUDIT.md graded by legal risk (Critical/High/Medium/Low) with the dependency, version, SPDX id, the exact conflict, and a concrete fix — replace with X, comply by Y, or get a commercial license.

    Why buy it

    • Distribution-aware — the only framing that gives correct answers; avoids both false alarms and missed violations
    • Due-diligence ready — run it before a release, fundraise, or acquisition; the report is the artifact reviewers ask for
    • Concrete fixes — named permissive replacements and exact compliance steps, not "remove GPL stuff"
    • Current — knows the 2023–2025 source-available relicensing wave and pins findings to the version in your lock file
    • Agent-agnostic — Claude Code, Cursor, Codex CLI, Copilot, Gemini CLI

    Limitations

    Analyzes declared licenses statically. Not legal advice — license interpretation is fact-specific. Doesn't scan for security CVEs (use an SCA tool for that), doesn't auto-generate NOTICE files, and doesn't verify that a declared license matches the actual code.

    Analyzes declared licenses statically; does not verify that a declared license matches the actual code. Not legal advice — license interpretation depends on facts the code can't fully reveal (linking mode, how you distribute, your
    commercial model). Such cases are routed to "Needs human review." Best results require a lock file; without one, only direct dependencies are analyzed (transitive deps unseen) and the report says
    so. Does not scan for security vulnerabilities/CVEs — use a dedicated SCA tool. Does not auto-generate NOTICE/attribution files or swap dependencies; it reports and recommends.Source-available license terms vary by version and change date; findings are pinned to the locked version, but always confirm the
    current grant.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 24 days ago

    Requires

    Python

    Permissions

    Write Files
    Read Files

    File Scopes

    **/package.json
    **/package-lock.json
    **/yarn.lock
    **/pnpm-lock.yaml
    **/pyproject.toml
    **/requirements*.txt
    **/poetry.lock
    **/Pipfile.lock
    **/Cargo.toml
    **/Cargo.lock
    **/go.mod
    **/go.sum
    **/pom.xml
    **/build.gradle*
    **/Gemfile*
    **/composer.{json
    lock}
    **/*.csproj
    **/pubspec.{yaml
    **/LICENSE*
    **/COPYING*
    **/NOTICE*
    **/node_modules/**/package.json
    **/third_party/**
    **/vendor/**
    LICENSE_AUDIT.md

    Static analysis only. Reads manifests, lock files, and installed package metadata to determine each dependency's license, plus LICENSE/NOTICE files for attribution checks. Writes a single file (LICENSE_AUDIT.md). No network calls, no shell, no environment reads. If "Network Access" is auto-detected from the ZIP it's a false positive — the skill references registry/license docs in its checklists but never fetches them.

    Listed6 months ago

    What's inside

    Frequently Asked Questions

    Unlike generic scanners, this agent evaluates risks based on your specific distribution model (SaaS, binary, or internal). It understands that a license like AGPL is a critical risk for a proprietary web app but may be perfectly safe for a local CLI tool.

    The skill supports all major package managers including npm/yarn, PyPI, Cargo, Go modules, Maven/Gradle, RubyGems, Composer, NuGet, and pub.dev by analyzing your project's lock files.

    This is an agent-agnostic skill designed to work with any environment where you use AI coding assistants, including Claude Code, Cursor, Copilot, and terminal-based tools like the Gemini or Codex CLI.

    The agent generates a detailed `LICENSE_AUDIT.md` report that categorizes risks from Critical to Low, identifies specific version conflicts (like the recent Redis or Terraform license shifts), and provides concrete replacement recommendations.

    Yes, the auditor is specifically programmed to track the 'relicensing wave' of 2023–2025, ensuring you don't accidentally pull in source-available versions of tools like Elasticsearch or Redis that now carry restrictive commercial terms.

    The skill focuses on identifying legal and licensing risks within your dependency tree; it does not scan for security vulnerabilities (CVEs) or perform static analysis of the source code itself.

    New in Security