How do I install the Asset License Checker skill?

Run npx skillmds@latest add aibot88/asset-license-checker in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.

What does the Asset License Checker skill do?

Verify license compliance for downloaded 3D assets, textures, HDRIs, fonts before scene build or export. It is listed under Coding & Dev Tools on SkillMD.

Is Asset License Checker safe to use?

This skill has not completed SkillMD's automated safety review yet. Independent scanners report: SkillSpector: PASS, Skill Scanner: PASS. Capability flags: docs only. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.

Which AI agents work with Asset License Checker?

This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.

Is Asset License Checker free to use?

Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.

Who published Asset License Checker?

aibot88 (@aibot88) published this skill. Their other Agent Skills are listed on their SkillMD profile.

Asset License Checker by aibot88 — Agent Skill

Name: Asset License Checker
Rating: 4.5 (4 reviews)
Author: aibot88

asset-license-checker

Purpose

Catch license risk before assets go into a scene that will be rendered, exported, or shipped. This is a planning / validation skill — does not modify assets, does not consult lawyers.

Quick start

list every external asset (model, texture, HDRI, font, sound, brushes)
record source URL + license name + permissions per asset
flag risk per asset (Pass / Warn / Fail)
emit asset row table + handoff to scene build only if all rows are Pass or explicitly accepted Warn

When to use

after blender-asset-discovery-planner produces asset list
before scene build / mutation / render
before any export or commercial distribution
when a previously-used asset's license is unclear

When not to use

asset modeling that you author yourself (no third-party license)
pure planning before assets are sourced
legal advice (this skill flags risk; it does not give legal opinion)

Trigger phrases

"is this license OK"
"can I use this commercially"
"what's the license"
"license check"

Prerequisites / readiness

asset list with sources known
intended use case known (commercial / non-commercial / internal / open-source)
target license compatibility known (e.g., MIT / CC0 / CC-BY / proprietary)

Input schema

Required inputs

Input	Why it is required
Asset list (name + source)	Scope of check
Intended use case	Drives compatibility
Target attribution policy	Some licenses require attribution

Optional inputs

Input	Use
Existing internal license whitelist	Pre-approved sources
Brand legal policy	Per-company override rules

Assumptions to confirm

Asset license file or page is publicly readable.
License version is current (licenses sometimes change).
The user's intended use is accurately stated.

Output schema

Primary output

A per-asset row table: name, source URL, license name, attribution required (Y/N), commercial allowed (Y/N), modification allowed (Y/N), redistribution allowed (Y/N), verdict (Pass / Warn / Fail), notes.

Secondary output

attribution lines required (if any)
assets to remove if Fail
top-line status

Evidence / caveat output

Runtime status: Not Run | Attempted | Produced | Verified | Failed | Blocked / Not Run
Artifact status: Not Run | Not Produced | Produced | Verified | Failed
Evidence used: <links, paths, logs, or "none">
Limitations: <known gaps>

Required laws

../../laws/evidence-before-done.md
../../laws/non-blender-user-language.md
../../laws/no-arbitrary-python-interface.md
../../laws/official-runtime-only.md

Official runtime boundary

Validation skill — does not modify assets, does not run Blender. Verdicts are based on documented license terms, not legal interpretation. Not legal advice: when in doubt, recommend the user consult their legal team.

Operating procedure

Read asset list from blender-asset-discovery-planner output.
For each asset, look up its license (per references/license-source-rules.md).
Map license to permissions (commercial / modification / redistribution / attribution).
Compare against intended use.
Assign verdict per asset.
List required attribution lines.
Flag assets to remove if Fail.
Hand off to scene build only if all Pass / explicitly accepted Warn.

Decision tree

License unknown?
  → Fail until source confirmed
"Free for personal use" but commercial intent?
  → Fail
"Free for any use, attribution required" + intended attribution policy = "no attribution"?
  → Fail
"CC0 / public domain"?
  → Pass for any use
"Proprietary / EULA"?
  → Read EULA carefully; default Warn until terms clarified

Playbooks

Playbook A: Commercial brand campaign

Strict policy: only CC0, MIT, or paid-licensed assets. CC-BY allowed if attribution renders correctly. No CC-BY-NC.

Playbook B: Internal tool / non-commercial

Most CC variants allowed; flag attribution requirements; track them.

Playbook C: Open-source pack release

Match the pack's license; for MIT pack, only MIT or more-permissive (CC0) assets.

Mode handling

Text-only mode

License rows from asset spec; no actual file inspection.

Runtime-ready mode

License rows verified from actual asset metadata where available.

Blocked runtime mode

Skip rows that need file inspection; mark as such.

Validation checklist

Every asset has a row
Source URL recorded
License name recorded
Permissions per row recorded (commercial / modification / redistribution / attribution)
Verdict assigned
Attribution lines listed
Top-line status derived

Pass / Warn / Fail rubric

Verdict	Criteria
Pass	License explicit + permissions match intended use + attribution handled.
Warn	License clear but attribution policy needs verification, or "all rights reserved" with no clear permission.
Fail	License missing / contradicts intended use; commercial use of non-commercial license; redistribution requested but not allowed.

Failure handling

License unknown → block asset until clarified.
Attribution required but no plan to render attribution → block until plan exists.
"Probably fine" answer → downgrade to Warn; user must accept.

Troubleshooting

Problem	Response
License page 404	Block asset; require alternative source.
License changed since download	Re-evaluate; assets purchased at older terms usually grandfather, but verify.
Mixed-license aggregation (asset bundle with multiple licenses)	Treat each sub-asset separately.
AI-generated asset	Verify the AI tool's license terms permit your use case.

Best practices

Record license at acquisition time, not at build time.
Maintain an internal whitelist for repeat sources.
Never ship without verifying every external asset's license.
"Not legal advice" — escalate ambiguity to legal.

Good examples

"Asset: hdri-studio.exr, source: polyhaven.com, license: CC0, commercial: Y, attribution: N (CC0). Verdict: Pass."

Bad examples

"Asset is from internet." — no source, no license.

User-facing response template

Intended use: <commercial / non-commercial / internal / open-source>
Attribution policy: <where attribution will render or "none">

| Asset | Source | License | Comm | Mod | Redist | Attribution | Verdict | Notes |
|---|---|---|---|---|---|---|---|---|

Required attribution lines:
  - <line 1>
  - <line 2>

Assets to remove (Fail): <list or "none">
Top-line: <Pass / Warn / Fail>
Note: not legal advice; escalate ambiguity to legal team.
Limitations: <gaps>
Next: scene build (only if Pass) / asset re-discovery (if Fail)

Anti-patterns

"Should be fine" verdicts.
Skipping the attribution plan.
Inventing license terms.

Cross-skill handoff

Asset discovery → ../blender-asset-discovery-planner/SKILL.md
Style consistency → ../asset-style-consistency-checker/SKILL.md
Fallback strategy → ../asset-fallback-strategy/SKILL.md
Library organization → ../asset-library-organization-planner/SKILL.md

Non-goals

Give legal advice.
Modify asset files.
Run Blender.
Negotiate licenses.

References

references/common-license-mapping.md
references/license-source-rules.md
references/attribution-rendering-patterns.md
../../docs/skill-system.md

Asset License Checker

File contents