SkillCorpus

What SkillCorpus gives you

SkillCorpus is EverMind's open-source pipeline for turning scattered SKILL.md files from public repositories into reliable agent context. It aggregates sources, applies safety and license gates, evaluates quality, and matches task-specific skills before the agent answers.

You can use the live SkillHub without cloning this repository. Clone SkillCorpus when you want the open-source machinery behind that experience:

• Build your own skill layer — point the pipeline at your own source registry, apply the curation, safety, and license gates, and export a corpus for your agents.
• Change the behavior — modify the taxonomy, quality and dedup rules, retrieval recipe, export schema, evaluation suites, or host plugins.
• Keep control of deployment — self-host the released retrieval models and connect your own agent host instead of using the hosted SkillHub API.

The core code is Apache-2.0 licensed (match/, evaluate/ and lifecycle/ are MIT); each skill retains its upstream license. The public 1,000-skill demo, three agent benchmarks, and live SkillHub show the result.

https://github.com/user-attachments/assets/4d9a3241-df13-4b20-9798-fb7920069995

🔥 Latest Updates

• 2026-10-28 The October corpus version holds 300,473 skills, 178,173 of them under commercial-safe licenses — same curation pipeline, same schema. Release on HuggingFace coming soon.
• 2026-10-23 SkillRep — skill retrieval is hard because a request and the skill that answers it are written in different words, and existing methods each move only one or two dimensions. We give the first complete formulation of that representation space (five dimensions; most prior retrievers occupy a single point in it), optimize across the whole of it, and reach state of the art on both mainstream benchmarks — a 0.6B encoder beats the strongest same-size retriever on SRA-Bench by +7.02 MRR@10 and leads SkillsBench. We also make the space interpretable: three measurable quantities show which part of the gap each dimension closes, and when two of them cancel. Code and model are open. arXiv:2610.32336 | code | HF encoder · reranker
• 2026-10-23 Beyond Gain — skill hubs keep growing (ours is past 300K) while the models they serve keep improving, so a hub has to retire, per model, what that model has already internalized. Yet internalization had no reliable measurement: the standard retire-on-gain test reads identically for a skill the model absorbed and one that never worked for anyone. We give the first reliable measurement of internalization — withhold the skill, score the model, and trust a high score only when some other model does gain from it: under the old rule more than 90% of SkillsBench retirements rest on tasks no run ever solved, while ours loses no reward and reproduces nearly twice as well. Code and data are open. arXiv:2610.32322 | code | HF 1,251 skills × 4 models
• 2026-09-17 · v0.4.0 Adds a shared skills library across all six hosts: they read one ~/.evermind-skillsearch/ directory and register their own, so a skill you have in one agent is available in the rest; skills retrieved from a catalog are kept instead of discarded at the end of the turn; and changes take effect on the next turn, with no restart. Raven and Hermes also gain skills_dirs / SKILLSEARCH_SKILLS_DIRS.
• 2026-09-02 Adds OpenClaw 2.0 support and smarter skill delivery: retrieve automatically on every query, or let the main agent call skill_search on demand.
• 2026-08-27 Supports multi-source retrieval across local skills, EverMind SkillHub, ClawHub, and skillhub.cn, with filtering, deduplication, and final 0–2 selection.
• 2026-08-26 Supports PathGuard placeholder resolution and host-aware paths for skill files and agent workspaces.
• 2026-08-25 Adds official SkillCorpus plugins for WorkBuddy, OpenClaw, Hermes, Raven, and DeepSeek Harness.

Stronger agents, one turn at a time

At answer time, the practical difference is a retrieval layer: SkillHub selects vetted procedural knowledge for the task and puts it into the agent's context.

The result is the same agent with better task-specific procedures available at the moment it needs them — stronger execution without asking users to memorise skill names or wire up tool calls.

Results

Pass rate with no skills → with SkillCorpus, same harness, same backbone (paper, Table 1):

Harness × backbone	SkillsBench	GDPVal	QwenClawBench
OpenClaw × Qwen3.5-27B	8.8 → 13.0	81.2 → 83.1	65.2 → 66.7
OpenClaw × Qwen3.5-397B	11.1 → 16.9	82.2 → 84.0	65.7 → 67.0
Raven × Qwen3.5-27B	10.0 → 16.5	82.6 → 83.8	66.9 → 70.8
Raven × Qwen3.5-397B	9.2 → 22.6	84.0 → 85.2	68.8 → 73.2
Pooled ∆	+7.5±2.3 (z=3.2)	+1.51±0.49 (z=3.1)	+2.79±0.70 (z=4.0)

The gain is largest where the task needs procedural knowledge the model does not already have (SkillsBench), and smallest on open-ended economic tasks it can already do (GDPVal).

SkillHub integrations

SkillHub brings skill retrieval to the five agent platforms below. Choose a platform to open its plugin guide:

Two modes, one setting. On demand — the default — gives the agent a skill_search tool and lets it decide: a long task pays for retrieval at the step that needs it and nothing on the turns that do not. mode: auto is the older behaviour: search every turn, before the model answers, with no tool call and no skill names to memorise. They are exclusive; running both would search twice for one turn.

OpenClaw ships as two packages, because 2.0 dropped the hook the 1.x plugin injects through: plugin-openclaw for releases up to 2026.7.x, plugin-openclaw2 for 2.0 (2026.8.1) and newer. The packaged Raven plugin installs and its on-demand mode works today; mode: auto there will claim the skills stage once Raven merges its upstream context_segments slot, and is inert until then. Raven's built-in retrieval keeps working either way.

Install SkillCorpus Plugins following https://github.com/EverMind-AI/SkillCorpus/blob/main/skillcorpus_plugin/INSTALL.agent.md

Paste that line to your agent and it installs itself. Per-host setup, the five settings you will actually touch, what each turn costs and what leaves your machine — skillcorpus_plugin/.

Public artifacts

This is the concrete inventory of what is public today.

	Artifact	What	Link
🌐	SkillHub	the current 114,190-skill catalog + the two models, hosted as an API — no install	evermind.ai/skillhub
📚	Corpus (demo)	the downloadable 1,000-skill sample — skills.parquet + attachments.tar.zst + dataset card; the full catalog is served by SkillHub	🤗 demo-1k
🗂️	Full corpus (coming soon)	the complete 114,190-skill dataset, same schema and layout as the demo — skills.parquet + attachments.tar.zst + dataset card	🤗 coming soon
🔡	Retrieval models	a bi-encoder and a reranker, fine-tuned from Qwen3-Embedding-0.6B and Qwen3-Reranker-0.6B	🤗 bi-encoder · reranker
🛠️	Code	this repo — the pipeline that builds the corpus and trains the two models (aggregate · curate · match · evaluate · export)	GitHub
🔌	Plugins	packaged host adapters for OpenClaw · Hermes · WorkBuddy · Raven, plus DeepSeek Harness and an HTTP adapter	skillcorpus_plugin/

Open source today: the code, the 1,000-skill demo corpus, and the retrieval models. The full 114,190-skill corpus is being prepared for release on HuggingFace. The hosted SkillHub service itself stays closed.

The 96,401-skill snapshot measured in the paper, organised by a 16-class taxonomy and three quality facets (utility / robustness / safety), with 1024-dim retrieval embeddings. Column contract: docs/corpus-schema.md.

Query the API directly

SkillHub serves the corpus in three tiers — discover (metadata), read (skill_md), download (zip with scripts/). Most skills are pure instructions, so the read tier is usually sufficient.

curl "https://skillhub.evermind.ai/openapi/v1/skills?q=extract+tables+from+a+PDF"

Take an id from the results, fetch its skill_md, and inject it into your agent's prompt. examples/skillhub_demo.py runs all three tiers:

# search + read the bodies — stdlib only, no install, no API key
python examples/skillhub_demo.py "extract tables from a scanned PDF invoice"

# also fetch the bundled scripts of the top hit
python examples/skillhub_demo.py --install ./skills "convert a PDF to images"

# retrieve AND run the task — any OpenAI-compatible LLM (OpenAI, OpenRouter, local vLLM, …)
export OPENAI_API_KEY=...                                # OpenRouter / vLLM: also set
# export OPENAI_BASE_URL=https://openrouter.ai/api/v1   # OPENAI_BASE_URL + --model openai/gpt-4o-mini
python examples/skillhub_demo.py --ask "extract tables from a scanned PDF invoice"

task: extract tables from a scanned PDF invoice

[1/2] search  → 2 hit(s), metadata only
  1. ocr-and-documents   q=0.808  DOC-PROC  MIT
     Extract text from PDFs/scans (pymupdf, marker-pdf).
  2. document-workflows  q=0.86   DOC-PROC  MIT
     Build end-to-end document processing workflows and pipelines …

[2/2] detail  → fetching skill_md for 2 skill(s)
  ocr-and-documents: 4916 chars  u=8 r=7 s=9  files=4  flags=['no_steps']
  document-workflows: 31628 chars  u=9 r=9 s=9  files=7

→ built a prompt of 36,742 chars with the skill bodies injected

Endpoints, response envelope, status codes and rate limits: docs/integrations.md.

Self-host the models

To avoid depending on the hosted endpoint, run selection yourself. The corpus and both retrieval models are released: load the data, serve the two models, and run your own encode → top-k → rerank.

# the data — a 1,000-skill demo for now; the full 114,190-skill corpus follows
from datasets import load_dataset
skills = load_dataset("EverMind-AI/skillcorpus-demo-1k", split="train")   # 1,000 demo skills
# or read the file directly with pandas (no `datasets`):  pip install pandas
import pandas as pd; skills = pd.read_parquet("skills.parquet")

Attachments (scripts/, references/) ship as a sibling attachments.tar.zst.

# install the serving deps (torch, transformers, …), then point the two env vars at
# the released checkpoints (the script's defaults are training outputs absent from a
# fresh clone) and serve both models behind one endpoint  ->  /embed + /score
pip install -r skillcorpus/match/requirements.txt
EMBEDDING_MODEL=<embedding checkpoint dir> RERANKER_MODEL=<reranker checkpoint dir> \
  bash skillcorpus/match/scripts/run_server.sh

This endpoint speaks /embed + /score (skillcorpus/match/ → Serving) — it is not a drop-in for SkillHub's hosted-only /openapi/v1/skills API. So:

• examples/skillhub_demo.py and the section-C integrations talk only to the hosted SkillHub; a self-hosted setup runs its own selection directly over /embed + /score.
• It is also the embedding endpoint the producer's dedup uses — set embedding.provider: skillrouter_remote to build your own corpus with it.

To curate your own sources instead, see Build your own corpus.

How it works

skillcorpus/
├── core/       data models · SQLite/faiss store · LLM & embedding clients
├── aggregate/  source registry + multi-repo clone
├── curate/     parse · safety · license · classify · quality · dedup + full-library passes
├── export/     corpus writer (parquet + attachments + dataset card)
├── match/      the 2 released models + training recipe                 ← isolated deps
├── evaluate/   skillsbench · qwenclawbench · gdpval benchmarks          ← isolated deps
├── lifecycle/  per-model skill retirement on the unaided level
└── cli.py      build · stats · export

cli build runs the whole curation chain (ingest → quality_pass → dedup_pass → license_audit → export.corpus). LLM classification and quality scoring degrade gracefully to rules when no model endpoint is reachable, so the pipeline always runs end to end.

match/ and evaluate/ are standalone toolkits with their own requirements.txt (torch / transformers, per benchmark); they are not pulled in by pip install of the producer.

• Retrieval — skillcorpus/match/ is the two released models: a bi-encoder fine-tuned from Qwen3-Embedding-0.6B for candidate recall, and a reranker fine-tuned from Qwen3-Reranker-0.6B that scores the top candidates. SkillHub serves both; to run them yourself see Serving (serve.py + run_server.sh). The directory also holds the training recipe (synthetic queries → InfoNCE → listwise CE) and eval_compare.py for the retrieval metrics (nDCG / MRR / Hit / Recall).
• Benchmarks — skillcorpus/evaluate/: skillsbench, qwenclawbench, gdpval — each self-contained with its own README and dependencies.
• Retirement — skillcorpus/lifecycle/ decides, per deployment model, which skills the model has internalized and can retire: it synthesizes a task from each skill, scores the model without and with the skill, and retires on the unaided level instead of the gain. It is the code of the paper Beyond Gain: Measuring Skill Internalization for Agent Skill Retirement.

Build your own corpus

Only needed if you want to curate your own sources. Requires an LLM endpoint for classification / quality scoring and an embedding endpoint for dedup — see docs/running.md.

git clone https://github.com/EverMind-AI/SkillCorpus.git skillcorpus && cd skillcorpus
python3 -m venv .venv && source .venv/bin/activate
python -m pip install --upgrade pip && pip install -e .

python -m skillcorpus.cli build     # 4 demo sources -> curate -> export
python -m skillcorpus.cli stats     # counts by source / category / license
python -m skillcorpus.cli export --out ./corpus

Only skills from GREEN-licensed sources are exported (the demo trusts the whitelist in audit/license_safe_sources.json wholesale; production gates per source-repo SPDX). The per-row license is each skill's declared value, so a demo corpus can still carry non-GREEN license strings. Use --sources-config your.yaml for your own registry, or --source <name> for one source.

pip install -e ".[dev]"
python -m pytest skillcorpus/tests -p no:cacheprovider --import-mode=importlib

Roadmap

• Curation pipeline: 16-class taxonomy, 3-facet quality, per-source license audit
• Fine-tuned retrieval stack + three-benchmark evaluation
• Per-model skill retirement on the unaided level (skillcorpus/lifecycle/)
• Public SkillHub endpoint
• Retrieval models (bi-encoder + reranker) and a 1k demo corpus on HuggingFace
• Full 114,190-skill corpus on HuggingFace — coming soon
• Deployment script for the two retrieval models (self-hosting match/)
• Plugins for WorkBuddy · Hermes · OpenClaw · DeepSeek Harness (+ HTTP adapter for any other host)
• Raven plugin — packaged, waiting on the upstream context_segments slot

EverMind Ecosystem

EverMind connects memory research, production-ready products, and practical integrations into one open-source ecosystem.

Together, these projects form EverMind's research-to-runtime stack: methods and benchmarks become reusable memory infrastructure, products, and agent integrations.

Citation

@article{wang2026skillcorpus,
  title         = {SkillCorpus: Consolidating and Evaluating the Open Skill Ecosystem for Real-World LLM Agents},
  author        = {Wang, Yanze and Yao, Pengfei and Sun, Tianyi and Hu, Chuanrui and Xiao, Yan and Luo, Xiaotian and Han, Yunyun and Chen, Yifan and Sun, Jun and Deng, Yafeng},
  year          = {2026},
  eprint        = {2607.15557},
  archivePrefix = {arXiv},
  url           = {https://arxiv.org/abs/2607.15557}
}

License

• Code — Apache-2.0 (the match/, evaluate/ and lifecycle/ toolkits are each MIT — see their own LICENSE).
• Corpus — every skill keeps its original upstream license; only GREEN (MIT / Apache-2.0 / BSD / ISC / …) skills are included, none relicensed. Each row carries source, source_url, and license, so downstream use must follow the per-skill terms.

Full GREEN/RED/YELLOW policy, license data flow, and opt-out: docs/licence-and-governance.md.