SkillNet: Open Infrastructure for AI Agent Skill Discovery and Routing

What SkillNet Addresses and Who It Is For

As LLM agent systems accumulate skills, managing them becomes its own problem. A team building a coding agent might have dozens of skill folders, each doing something slightly different, with unclear coverage gaps and unknown relationships between them. Discovering relevant skills from external sources requires manual search. Evaluating whether a skill is safe, complete, and runnable before deploying it adds overhead.

SkillNet provides infrastructure for the full skill lifecycle. It covers discovery of skills in a public index, installation into a local workspace, generation of new skills from repositories or documents, quality evaluation against five dimensions, analysis of capability coverage and skill relationships, and task routing to select the right skill from a local library. The public library at `skillnet.openkg.cn` indexed 500,000+ GitHub skills as of the July 2026 update, with improved deduplication and broader coverage of scientific research and data analysis domains.

The intended audience includes agent developers building or managing skill libraries for LLM systems, and researchers working on skill reuse, routing, and benchmarking. The SDK is also used in JiuwenClaw and OpenClaw as a built-in skill marketplace, making it relevant to developers who use those agent frameworks.

Installing the SDK and Searching the Public Library

The package requires Python 3.10 or newer.

pip install skillnet-ai

Optional dependencies add scenario analysis and routing via Claude or Codex:

pip install "skillnet-ai[graph,claude]"  # analysis and routing via Claude
pip install "skillnet-ai[graph,codex]"   # analysis and routing via Codex

Once installed, initialize the client and search the hosted catalog:

from skillnet_ai import SkillNetClient

client = SkillNetClient()
results = client.search(
    q="analyze financial PDF reports",
    mode="vector",
    threshold=0.85,
    limit=10,
)
for skill in results:
    print(skill.skill_name, skill.stars, skill.skill_url)

Keyword search defaults to sorting by stars. Vector search uses the hosted service's embeddings. Both modes search the same public catalog of 500,000+ indexed GitHub skills at skillnet.openkg.cn.

Downloading and Creating Skills

Downloading a skill fetches the skill folder and its resources from GitHub into a local directory:

local_path = client.download(
    url="https://github.com/anthropics/skills/tree/main/skills/pdf",
    target_dir="./my_skills",
)

Creating a new skill generates a structured skill package from one of four sources: a natural language prompt, a GitHub repository URL, an office document, or an execution trace. One source per call, returned as a list of generated directory paths.

paths = client.create(
    prompt=(
        "Create a csv-quality-checker skill that checks CSV files for missing "
        "values and duplicate rows without modifying the input."
    ),
    output_dir="./my_skills",
)

The `create` method also accepts `github_url` for generating skills from a repository's code, and `office_file` for generating from a PDF or other document. The result is a list of paths to the generated skill directories. The generated skill package follows the structured format that the rest of the SDK expects for evaluation and analysis, meaning you can pass a `create` output directly to `client.evaluate()` or `client.analyze()` in the next step.

Evaluating Skill Quality Across Five Dimensions

The `client.evaluate()` method assesses a skill across safety, completeness, executability, maintainability, and cost awareness. Each dimension returns a level (Good, Average, or Poor) and a reason explaining the assessment. Evaluation works on a local skill folder or on a GitHub skill URL directly.

This evaluation is the primary quality gate for deciding whether to deploy a discovered or generated skill. The safety dimension is relevant for teams operating in regulated environments or handling sensitive data. The executability dimension catches skills that are syntactically valid but would fail at runtime. Cost awareness flags skills that make API calls or consume resources without documentation.

The `client.analyze()` method extracts capabilities and usage scenarios from a local skill library and infers relationships between skills. The two relationship types it infers are `compose_with` (skills designed to work together) and `similar_to` (skills covering overlapping ground). These relationships are stored in a `graph.json` file that the local browser interface can then visualize.

SkillNet-Gym, documented on the SkillNet website and in the updated arXiv report (2603.04448, August 2026), provides executable benchmarks for skill construction, retrieval, and composition. These benchmarks allow systematic measurement of skill lifecycle quality across the whole pipeline, not just per-skill assessment.

The Local Browser Interface and Relationship Analysis

Version 0.1.2, released on 2026-09-24, adds a local browser interface that lets you explore skill folders, view analyzed relationships, and follow relationship evidence to source lines.

pip install "skillnet-ai[ui]>=0.1.2"
skillnet ui --skills-dir "/absolute/path/to/skills"

Open `http://127.0.0.1:8765`. The interface has two views: Current skill files (reads the sources directly) and Analysis results (explores saved `compose_with` and `similar_to` relationships). Importing a `graph.json` generated by `skillnet analyze` populates the relationship graph view.

The `[ui]` extra includes the website assets; users do not need Node.js or model API keys to browse. Generating the analysis separately with the SDK or CLI produces the relationship graph that the interface displays.

Task Routing and What SkillNet Cannot Do

The routing operation selects skills for a task from the local library and returns selection reasons for each chosen skill. This is useful when a task could be addressed by multiple skills and the agent needs to pick the most appropriate one without running all of them.

SkillNet-Fabric, described on the SkillNet website, routes tasks through a Wiki built for each task. The August 2026 report update introduces this approach: rather than routing directly from a flat skill list, Fabric builds a task-specific Wiki that structures the skill search space. A guided routing demo is available on the website at `skillnet.openkg.cn/skillfabric`.

The public web platform at `skillnet.openkg.cn` also provides curated skill collections for specific domains. The library tab supports search by keyword or semantic intent with category filtering, and each skill's page shows its evaluation ratings and GitHub source with a download link.

SkillNet does not host skill code, execute skills, or provide a runtime environment. It finds, assesses, and organizes skills, but the agent framework or runtime is separate. The MCP server maintained by CycleChain at `github.com/CycleChain/skillnet-mcp` makes SkillNet tools available to MCP-compatible agents, but the server is a third-party project, not part of the zjunlp/SkillNet repository itself.

The last push to the repository was on 2026-09-26. The MIT license permits use and modification without restrictions.

Editorial conclusion

SkillNet is well suited for teams building or maintaining skill libraries for LLM agent systems and for researchers studying skill reuse and routing. It is not suited for teams that need a managed hosting service or production-grade SLA: the library at skillnet.openkg.cn is a research index, not a vetted marketplace. Before adopting for production, run `client.evaluate()` on each skill you plan to deploy; the five-dimension report (safety, completeness, executability, maintainability, cost awareness) is the primary quality gate the SDK provides.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. Project website
4. README
5. zjunlp/SkillNet on GitHub