SkillNet: A Package Registry and Quality Scorer for AI Agent Skills

The problem SkillNet targets: agent capabilities that get rebuilt per project

Teams that ship agents tend to accumulate the same capabilities in slightly different forms. One repository has a PDF table extractor, another has a web scraper, a third has a summarizer, and none of them know about each other. SkillNet's framing is that agent skills should be treated as software assets: searchable, installable, inspectable, evaluable and composable. The README states the goal plainly with the line that agents should not rebuild the same capability from scratch every time. The intended audience is therefore engineers who already have an agent runtime and want a reuse layer above it, not people looking for a first agent framework. The library covers five operations in the README's own list: discovery by keyword or semantic intent, installation of skill folders from GitHub into local workspaces, creation of structured skills from repositories, documents, prompts or execution traces, evaluation against safety, completeness, executability, maintainability and cost awareness, and composition through inferred relationships between local skills. Orchestration is the sixth: selecting scene-specific skills and generating a prompt for a downstream execution agent.

How the pieces fit: a client, a hosted index, and a local skill folder

The architecture visible in the README is a thin client over a hosted service plus local filesystem operations. SkillNetClient is the single entry point in the Python SDK. Search returns objects with fields such as skill_name, skill_url and stars, and the README's example prints skill_name and skill_url. Download takes one of those URLs and writes the skill folder into a target directory, returning the local path. That is the whole read path, and it is the only part that works without credentials. Everything else, meaning create, evaluate, analyze and orchestrate, goes through an OpenAI-compatible endpoint configured with api_key and base_url, or through the Claude Agent SDK for orchestration. The graph layer is a separate install extra, skillnet-ai[graph], described as scenario-level graph analysis, and orchestration is skillnet-ai[orchestrate]. The README names the relationship types the analysis step can infer: compose_with, depend_on, and scenario-level handoff relationships. SkillNet Explorer at skillnet.openkg.cn is the visual front end, offering keyword and semantic search, quality-ranked listings, graph visualizations, and copyable installable GitHub URLs. The 2026-07-11 news entry states the library indexes 500K+ GitHub skills with improved deduplication. Treat that as a self-reported figure from the project's own release notes, not an independently verified count.

Getting it running: pip, three environment variables, and a search call

Installation is one command from PyPI: pip install skillnet-ai. The README shows optional extras as pip install "skillnet-ai[graph]" and pip install "skillnet-ai[orchestrate]". A minimal search and download in Python looks like this: import SkillNetClient from skillnet_ai, construct the client with no arguments, call client.search("pdf understanding", limit=5), then pass results[0].skill_url into client.download with target_dir="./my_skills". The CLI mirrors it with skillnet search "pdf understanding" --limit 5 and skillnet download <skill_url> -d ./my_skills. The README states explicitly that no API key is required for search or public GitHub downloads. For the credential-requiring paths, the client constructor takes api_key, base_url and github_token, and the same values can come from the environment variables API_KEY, BASE_URL, SKILLNET_MODEL and GITHUB_TOKEN. The README notes that orchestration requires a compatible gateway configured with the same API_KEY, BASE_URL and SKILLNET_MODEL variables, which is a real constraint: mixing providers across those three variables is the kind of setup that fails at call time rather than at construction. Search also accepts mode="vector" and a threshold argument, shown as 0.85, so semantic retrieval is opt-in rather than the default. Python 3.10 or newer is required according to the badge.

Where the design gets thin: evaluation criteria without published rubrics

The evaluation layer is the most interesting claim and the least specified in the supplied material. The README says skills are scored for safety, completeness, executability, maintainability and cost awareness, which is a five-axis model, but it does not give the scale, the weights, or any worked example of a score. Because evaluation runs against an OpenAI-compatible endpoint, the scoring is presumably model-generated rather than derived from static analysis, though the README does not say so directly. That matters for adoption: a model-generated safety score is a filter, not a guarantee, and it will drift as the underlying model changes. The same ambiguity applies to the graph layer. compose_with and depend_on are named as relationship types, but the README does not describe how they are inferred, whether from metadata, embeddings, or model judgement. If you need deterministic, auditable quality gates in a CI pipeline, this design gives you a number whose provenance you cannot inspect from the documentation alone. Verify by running client.create and the evaluation path on a skill you already trust and comparing the output against your own review.

A concrete failure mode: the public library is the dependency

Search and download are credential-free, which is the SDK's best property, but they are also the part most exposed to an external service. The README describes SkillNet Explorer as the visual entry point for the public skill library and the client as talking to it, so an air-gapped deployment, a regulated environment, or a team that cannot send query text to a third party has no documented path here. The README does not describe a self-hosted index or an offline mode. Download adds a second dependency: it fetches skill folders from GitHub, so private repositories need github_token, and public ones are subject to GitHub rate limits, which the README acknowledges by noting the token is optional for higher limits. There is also a supply-chain consideration the README does not address. Installing a skill folder from an arbitrary GitHub repository into a local agent workspace means executing or loading code you did not write, and the evaluation step that might flag problems is itself behind a credentialed endpoint. The project is not archived and the last push date is 2026-09-10, so the repository is active, but no releases were retrieved, which means versioning discipline is not visible from the material provided.

How it differs from LangChain tools and MCP servers

The nearest comparison the README itself invites is MCP. SkillNet shipped an MCP server in March 2026, maintained by a third party called CycleChain, and integrations exist for OpenClaw and JiuwenClaw, where SkillNet appears as a built-in skill marketplace. The difference in approach is worth stating precisely. MCP standardizes how a running agent calls out to a tool server at runtime, with the tool implemented and hosted by whoever wrote the server. SkillNet instead treats the skill as a folder of files that you download into your workspace, so the unit of reuse is a repository you can read, diff and vendor rather than an endpoint you call. That is a meaningfully different trust and versioning model: you can pin a skill by committing it, but you own its maintenance from that point on. Against a general framework like LangChain, the difference is scope. LangChain gives you abstractions for composing chains and agents in code. SkillNet gives you a search index, a downloader, a scorer and a prompt generator, and it hands the resulting prompt to a downstream execution agent rather than running the agent itself. If your problem is orchestration logic inside one application, neither the search index nor the skill folder format solves it.

Licence and the cost of keeping skills current

SkillNet itself is MIT-licensed, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are retained. That covers the SDK and CLI. It does not cover the skills you download, and this is the practical trap: each skill folder under a GitHub URL carries its own licence, which may be absent, copyleft, or incompatible with your distribution. The README's download step does not mention licence inspection, and the evaluation axes it lists (safety, completeness, executability, maintainability, cost awareness) do not include licensing. Anyone vendoring skills into a product should read each downloaded repository's licence separately. On maintenance, the picture from the material is a fast-moving project: news entries land roughly monthly, extras are split into skillnet-ai[graph] and skillnet-ai[orchestrate], and the paper was updated in August 2026 with SkillNet-Gym for executable benchmarks and SkillNet-Fabric for task time routing through a task specific Wiki. Vendored skill folders do not upgrade themselves, so the recurring cost is re-running search and download as the index changes, plus re-evaluating anything you already scored. The README gives no deprecation policy or compatibility guarantee across SDK versions. This is a description of the licence terms as stated, not legal advice.

Editorial conclusion

Adopt SkillNet if you already run agents through an OpenAI-compatible endpoint or the Claude Agent SDK and want a credential-free way to search and vendor GitHub skill folders into a local workspace. Skip it if you need a self-hosted, air-gapped index, because the README describes a public library reached through the hosted service at skillnet.openkg.cn, and the create, evaluate, analyze and orchestrate calls all require a compatible endpoint plus the API_KEY, BASE_URL and SKILLNET_MODEL variables. Before committing, install skillnet-ai and run skillnet search on one of your own task descriptions to see whether the returned skill_url entries are repositories you would actually vendor, then call client.create on a single internal repo and read the generated folder before wiring anything into a workflow.

Official sources

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