SkillNet: A 200,000-Skill Nebula for Reusable AI Agent Capabilities

> "We are in the era of experience." > — Richard S. Sutton, 2022

Introduction: The Programmer Swimming Alone in a Sea of Code

A young programmer named Xiao Chen joins a tech company. His first assignment: write a Python script that extracts sales data from the company database and emails a weekly report to management. After three days of struggling with database connections, email templates, and edge cases, he finishes. His mentor casually mentions that someone wrote a similar script three years ago — it's still on GitHub, more complete, with better edge-case handling and documentation.

Xiao Chen could have finished in two hours if he had known. This is not his fault. In the era of information overload, knowledge is scattered across GitHub repositories, abandoned Confluence pages, Slack threads, and the cryptic notes of departed colleagues. Every new task is a fresh search in the dark.

This is precisely the困境 facing today's AI agents.

Chapter 1: The "Experience Problem" of AI Agents

Modern AI agents can browse the web, manipulate databases, call APIs, and even write and execute code. They appear omnipotent — yet they suffer from a fundamental problem:

AI agents lack a systematic mechanism for skill accumulation and transfer.

Teach an agent to book a Tokyo flight. It learns the websites, price comparisons, cheaper dates, optimal cabin classes. A month later, ask it to book a Paris flight. It starts from scratch, forgetting every trap, trick, and detail you taught it.

As Sutton argues, intelligence increasingly depends on efficient retrieval and adaptive reuse of heuristic knowledge from past experience, not raw learning capacity. Humans excel not because we compute faster, but because we crystallize experience into reusable patterns. AI lacks this capacity: every task is isolated, ephemeral, and disposable.

It is like reinventing the wheel every time — without knowing the wheel already exists.

Chapter 2: From Symbols to Parameters to Skills — A History of Knowledge Representation

Symbolic Era (1970s–1980s)

Researchers encoded intelligence through explicit if-then rules in expert systems. Knowledge was interpretable but brittle — real-world ambiguity overwhelmed hand-crafted logic.

Deep Learning Era (2010s)

Knowledge became distributed across billions of parameters in weight matrices. Models learned features automatically, but the resulting representations became opaque, entangled, and impossible to modularize. Updating a trained model meant costly retraining or limited in-context prompting.

Agent Era (2020s — we are here)

AI no longer just answers questions — it acts, coordinating multi-step tasks. The central question becomes: how do we transform fragmented experience into persistent, composable capability units? This is the question SkillNet answers.

Chapter 3: What Is a Skill? Redefining the Capability Unit

In SkillNet's vocabulary, a *skill* is not a code snippet or a prompt template. It is a structured, self-contained capability package — like a professional kitchen recipe card with metadata, step-by-step instructions, dependencies, substitutions, common failure modes, and variations.

Each skill lives in a folder centered on a SKILL.md file containing:

1. Metadata — name, description, conditions of use 2. Detailed instructions — precise step-by-step execution guide 3. Optional resources — scripts, templates, documentation 4. Dependency declarations — required skills or tools

Skills operate through a three-stage progression:

• Discovery — the agent loads only minimal metadata (name + description) to identify candidates
• Activation — matching skills are read in full when relevant
• Execution — the agent follows the instructions, optionally invoking bundled code or resources

Critically, skills are self-documenting: humans can read, understand, audit, and improve them — a stark contrast to the black-box nature of deep neural networks.

Chapter 4: The Birth of SkillNet — A 200,000-Skill Nebula

SkillNet is an open skill infrastructure built by 40+ researchers from Zhejiang University, Alibaba, Ant Group, Tencent, and others. It hosts over 200,000 curated skills structured into a Skill Network — imagine a nebula where each star is a skill and gravitational links between them encode similarity, complementarity, dependency, and composability.

The architecture has three core modules.

Module 1: Skill Creation

SkillNet ingests heterogeneous sources:

1. Execution trajectories — successful agent runs are analyzed to extract reusable patterns (like an experienced driver teaching a novice) 2. Open-source repositories — GitHub projects are scanned for READMEs, comments, and example scripts 3. Semi-structured documents — PDFs, PowerPoint decks, Word files are parsed for procedural knowledge 4. Natural-language prompts — users describe a desired skill in plain language

Automated creation is followed by a multi-stage curation pipeline:

• Deduplication — directory-structure comparison plus MD5 hashing
• Filtering — rule-based validation and model-based checks for low-quality, incomplete, or nonsensical skills
• Classification and tagging — assignment to 10 functional categories (development, AIGC, research, science, business, testing, productivity, security, lifestyle, other) plus fine-grained semantic labels
• Evaluation — application of the multi-dimensional framework (below)
• Integration — automatic establishment of inter-skill relationships, producing structured skill packages

The result is not a skill junkyard but a self-evolving skill ecosystem.

Module 2: Skill Evaluation

Quantity ≠ quality. SkillNet scores every skill across five dimensions:

1. Safety — risks of dangerous system operations, robustness against prompt injection 2. Completeness — coverage of critical procedural steps, prerequisites, dependencies, execution constraints 3. Executability — successful implementation in a sandbox; identification of hallucinated tool calls or vague instructions. This is the most demanding dimension, requiring actual runtime verification 4. Maintainability — modularity and composability; capacity for local updates without breaking global dependencies 5. Cost-awareness — time latency, compute consumption, API call costs

Each dimension is rated Good / Average / Poor. Most dimensions are judged by an LLM-based auto-evaluator (GPT-5o-mini), but executability undergoes actual runtime validation. While safety and maintainability retain high "Good" proportions, executability remains the toughest challenge — a reflection of SkillNet's strict filtering.

To validate automatic scoring, researchers sampled 200 skills and recruited three PhD-level computer-science annotators for blind review. Results: mean absolute error (MAE) below 0.03 across all dimensions, with quadratic weighted Kappa (QWK) approaching a perfect 1.000, confirming the auto-evaluator aligns tightly with human judgment.

Module 3: Skill Analysis

A collection of 200,000 isolated skills is just a library. The real power lies in understanding relationships between them. SkillNet automatically builds a large-scale Skill Graph capturing:

• similar_to — functionally equivalent or interchangeable skills (e.g., requests vs httpx for HTTP calls), enabling redundancy detection and fallback selection
• compose_with — combinable skills forming complex workflows (e.g., read CSV → clean data → visualize)
• belong_to — hierarchical categorization (Matplotlib plotting ⊂ data visualization ⊂ data science)
• depend_on — execution dependencies (Docker deployment depends on installing Docker and writing a Dockerfile)

These relationships form a multi-layered ontology:

• Skill Taxonomy — multi-level functional categories from broad domains to fine-grained tags
• Skill Relation Graph — abstract labels instantiated as concrete skill entities with multi-relational edges
• Skill Package Library — modular, task-oriented bundles (e.g., data-science-visualization) for distribution and deployment

This structure enables global reasoning: an agent can ask "I need to complete task X — which skills combine, what are their dependencies, what are efficient alternatives?" It is GPS navigation instead of blind wandering.

Chapter 5: Experimental Validation — Where Does the 40% Gain Come From?

Experiments ran in three text-based simulation environments:

• ALFWorld — household navigation and object manipulation
• WebShop — online shopping browsing, search, comparison, purchase
• ScienceWorld — scientific experimentation with equipment manipulation

Results with SkillNet-equipped agents:

• 40% average reward improvement
• 30% reduction in execution steps

These gains hold across multiple backbones — DeepSeek V3, Gemini 2.5 Pro, o4 Mini — proving the benefit is model-agnostic.

The interpretation is straightforward. Without SkillNet, an agent enters an unfamiliar city with no map: it takes wrong turns, repeats mistakes, wastes time on solved problems. With SkillNet, it has a detailed map (taxonomy), GPS navigation (relation graph), and veteran advice (crystallized experience). It knows not just *where to go* but also *the fastest route*, *the pitfalls*, and *the backups if the main route is blocked*.

Chapter 6: The Nature of Skills — From Transient Experience to Persistent Mastery

The paper articulates a profound philosophical claim: skills are intermediate capability units connecting abstract declarative knowledge with concrete executable procedures.

• Declarative knowledge ("knowing what") — Python is a programming language; REST is a design principle
• Procedural knowledge ("knowing how") — import requests; requests.get(url)

A vast gap separates them. Skills are the bridge: they encode both abstract understanding ("the purpose of this skill is…", "applicable scenarios are…") and concrete operational steps.

Crucially, skills are evolvable, composable, and shareable. When one agent masters a trick, that skill enters SkillNet and is immediately available to others. Each generation of AI stands on the shoulders of the previous one — rather than starting over.

Chapter 7: Future Outlook — From Individual Intelligence to Collective Wisdom

Current AI systems remain *individual*: each model trains, reasons, and forgets alone. There is no genuine knowledge sharing between them.

The greatness of human civilization lies in collective wisdom accumulation. Language transmits knowledge; writing crosses time; the internet shares global intelligence near-instantly. SkillNet aspires to build analogous infrastructure for AI agents:

• Standardized skill interfaces — model-agnostic formats
• Open skill ecosystem — anyone can contribute, like open-source software
• Automated skill discovery — AI extracts skills from human experience
• Multi-dimensional quality assurance — reliable, trustworthy skill libraries
• Relational skill network — understanding inter-skill links for complex reasoning

Imagine: a medical AI diagnosing rare diseases can call on skills accumulated by global experts; a programming AI facing a new framework can reuse community-contributed packages; a research AI designing experiments can reference lessons from all prior similar work.

This is not science fiction. SkillNet takes the first step.

Epilogue: Xiao Chen's Redemption

Back to the beginning. If Xiao Chen's company had a "Programmer SkillNet," his task changes. He searches "sales data extraction weekly email report" and finds:

• A ready skill package: *Database-to-Email Reporting Pipeline*
• Related skills: *SQL Query Optimization for Sales Metrics*, *Email Template Design for Executive Reports*, *Error Handling in Data Pipelines*
• Dependencies: database connection setup (another skill)
• Alternatives: a Node.js version if Python is unsuitable
• Community rating: 5 stars, used by 127 projects, updated 3 days ago

Xiao Chen finishes in two hours — not because he is smarter, but because he stands on the shoulders of the entire organization's knowledge.

This is the world SkillNet aims to build: let knowledge flow, let experience endure, let each generation of AI grow wiser than the last.

Not through larger models, more parameters, or costlier training — but through smarter organization, more effective reuse, and continuous accumulation.

200,000 skills is just the beginning.

References

1. Liang, Y., Zhong, R., Xu, H., et al. (2026). *SkillNet: Create, Evaluate, and Connect AI Skills*. arXiv:2603.04448. 2. Sutton, R. S. (2022). *The Era of Experience*. Blog post. 3. Schick, T., et al. (2023). *Toolformer: Language Models Can Teach Themselves to Use Tools*. arXiv:2302.04761. 4. Qin, Y., et al. (2023). *Tool Learning with Foundation Models*. arXiv:2304.08354. 5. Shinn, N., et al. (2023). *Reflexion: Self-Reflective Agents*. arXiv:2303.11366. 6. Wang, L., et al. (2024). *A Survey on Large Language Model based Autonomous Agents*. arXiv:2308.11432. 7. Wu, Y., et al. (2024). *OS-Copilot: Towards Generalist Computer Agents with Self-Improvement*. arXiv:2402.07456. 8. Shao, Z., et al. (2024). *DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models*. arXiv:2402.03300. 9. Zhang, N., et al. (2024). *Extract, Define, Canonicalize: An Ontology-based Knowledge Graph Construction Framework*. arXiv:2403.00079. 10. Pan, J. Z., et al. (2023). *Large Language Models and Knowledge Graphs: Opportunities and Challenges*. arXiv:2308.06374.