Why Skyll?
Agent skills (SKILL.md files) are a powerful way to extend what AI agents can do. They're markdown files that teach agents how to complete specific tasks, following the Agent Skills specification.
The Problem
Today, skills only work with a handful of tools like Claude Code and Cursor. They require manual installation before a session, which means developers need to know in advance which skills they'll need.
The Solution
Skyll democratizes access to skills. Any agent, framework, or tool can discover and retrieve skills on demand. No pre-installation. No human intervention. Agents explore, choose based on context, and use skills autonomously.
Think of Skyll as a search engine for agent capabilities. Your agent asks "How do I do X?" and Skyll returns the relevant skill with full instructions, ready to use.
Features
Multi-Source Search
Query skills.sh, community registry, and extensible to more sources. Results are deduplicated automatically.
Full Content Retrieval
Get complete SKILL.md content with parsed YAML frontmatter, not just metadata. Ready for context injection.
Relevance Ranking
Skills scored 0-100 based on content availability, query match, references, and popularity (install count).
Aggressive Caching
Intelligent caching respects GitHub rate limits. Configure TTL via environment variables.
References Support
Optionally fetch additional .md files from references/, docs/, examples/ directories.
Dual Interface
Use as REST API for any integration, or as MCP server for Claude Desktop, Cursor, and more.
Install with pip
The easiest way to use Skyll in your agents. Uses the hosted API at api.skyll.app - no server setup required.
pip install skyllBasic Usage
from skyll import Skyll
async with Skyll() as client:
skills = await client.search("react performance", limit=5)
for skill in skills:
print(f"{skill.title}: {skill.description}")
print(skill.content) # Full SKILL.md contentGet a Specific Skill
async with Skyll() as client:
skill = await client.get("anthropics/skills", "skill-creator")
if skill:
print(skill.content)Include References
Some skills have additional documentation in references/ directories:
async with Skyll() as client:
skills = await client.search("react", include_references=True)
for skill in skills:
for ref in skill.references:
print(f"๐ {ref.name}: {len(ref.content)} chars")Point to Self-Hosted Server
async with Skyll(base_url="http://localhost:8000") as client:
skills = await client.search("testing")REST API
The hosted API is available at https://api.skyll.app. For other languages or direct integration.
/searchSearch for skills by query. Returns ranked results with full content.
Example
curl "https://api.skyll.app/search?q=react+performance&limit=5"Query Parameters
| q | Search query (required) |
| limit | Max results (1-50, default 10) |
| include_content | Fetch full SKILL.md (default: true) |
| include_references | Fetch reference files (default: false) |
Example Response
{
"query": "react performance",
"count": 1,
"skills": [
{
"id": "react-best-practices",
"title": "React Best Practices",
"description": "Guidelines for building performant React apps",
"source": "vercel/ai-skills",
"relevance_score": 85.5,
"install_count": 1250,
"content": "# React Best Practices\n\n## Performance\n...",
"refs": {
"skills_sh": "https://skills.sh/...",
"github": "https://github.com/..."
}
}
]
}/skill/{name}Get the latest version of a skill by name. Similar to npx skills add but for runtime context injection.
Simple Name (Searches for Best Match)
curl "https://api.skyll.app/skill/react-best-practices"Full Path (Direct Lookup)
curl "https://api.skyll.app/skill/vercel-labs/agent-skills/vercel-react-best-practices"Always fetches fresh content from GitHub, ensuring you have the latest version.
/skills/{source}/{skill_id}Get a specific skill by source and ID.
curl "https://api.skyll.app/skills/anthropics/skills/skill-creator"/healthHealth check endpoint. Returns service status.
Self-Hosted
Run your own Skyll server for full control, higher rate limits, or private deployments.
Step 1Clone & Install
git clone https://github.com/assafelovic/skyll.git
cd skyll
pip install -e ".[server]"Step 2Configure (Optional but Recommended)
# GitHub token for higher rate limits (5000 vs 60 requests/hour)
GITHUB_TOKEN=ghp_your_token_here
# Cache TTL in seconds (default: 86400 = 24 hours)
CACHE_TTL=86400Get a GitHub token at github.com/settings/tokens
Step 3Start the Server
uvicorn src.main:app --port 8000Step 4Point Client to Your Server
from skyll import Skyll
async with Skyll(base_url="http://localhost:8000") as client:
skills = await client.search("testing")Ranking Algorithm
Skyll uses a multi-signal ranking algorithm to order search results by relevance. Each skill receives a score from 0-100 based on weighted factors, with a small additional boost for curated registry skills.
score = content + references + query_match + popularity + curated_boostContent Availability
40 pts maxSkills with successfully fetched SKILL.md content receive 40 points. Skills without content are sorted last (not filtered).
| Has content | +40 |
| No content (sorted last) | 0 |
Query Match
30 pts maxHow well the skill matches the query. Checks ID, title, description, and content in priority order, taking the best score.
| Exact ID match | +30 |
| All query terms in ID | +27 |
| All query terms in title | +24 |
| All query terms in description | +21 |
| Partial / content matches | 0-15 |
References
15 pts maxWhen include_references=true, skills with additional .md files receive a boost.
| Has references (when requested) | +15 |
| No references | 0 |
Popularity
15 pts maxInstall count from skills.sh, using logarithmic scaling to prevent extremely popular skills from dominating.
| 10,000+ installs | +15 |
| 1,000 installs | +11.25 |
| 100 installs | +7.5 |
| 0 installs | 0 |
Curated Registry Boost
up to 8 ptsSkills from the curated registry/SKILLS.md receive a boost scaled by query relevance. This rewards hand-picked quality skills without letting irrelevant registry entries jump the ranks.
curated_boost = is_curated ร 8 ร query_matchA curated skill with a strong ID match gets +7.2 pts, a description match gets +5.6 pts, and a weak partial match gets just +2 pts.
| Skill | Content | Refs | Query | Pop. | Curated | Total |
|---|---|---|---|---|---|---|
| Exact match, popular, with content | 40 | 15 | 30 | 15 | 0 | 100 |
| Good match, popular, with content | 40 | 0 | 25 | 12 | 0 | 77 |
| Curated, description match | 40 | 0 | 21 | 0 | 5.6 | 66.6 |
| Partial match, new skill | 40 | 0 | 15 | 0 | 0 | 55 |
| No content (fetch failed) | 0 | 0 | 30 | 15 | 0 | 45 |
Design Rationale
Content is king. Skills without content are less useful, so content availability dominates the score.
Multi-field matching. Skills match via ID, title, description, or content. A skill about "deep research" surfaces even if its ID is "gpt-researcher".
Popularity is a signal, not the answer. Log scaling prevents extremely popular skills from dominating. A skill with 100 installs and good query match can outrank a skill with 10,000 installs and poor match.
Curated skills get a nudge. Registry skills are hand-picked for quality. The boost is scaled by relevance to prevent irrelevant registry skills from jumping the ranks.
References add value. When users request references, skills that provide them are more valuable.
Create a Custom Ranker
The ranking algorithm is modular. Implement the Ranker protocol to create your own:
from src.ranking.base import Ranker
class MyCustomRanker(Ranker):
def rank(self, skills, query="", include_references=False):
for skill in skills:
# Your scoring logic
skill.relevance_score = ...
return sorted(skills, key=lambda s: s.relevance_score, reverse=True)
# Register in src/core/service.py:
self._ranker = MyCustomRanker()Future Enhancements
The ranking system is designed for extension. We welcome community contributions:
- Semantic search: Use embeddings to match query intent, not just keywords
- Recency: Boost recently updated skills
- Quality signals: Factor in documentation completeness, test coverage
- User feedback: Learn from click-through rates
MCP Server
Skyll provides a hosted MCP server at api.skyll.app/mcp - no installation required. Works with Claude Desktop, Cursor, and other MCP-compatible clients.
RecommendedHosted MCP
{
"mcpServers": {
"skyll": {
"url": "https://api.skyll.app/mcp"
}
}
}That's it! The hosted server is always up-to-date with the latest features.
Available MCP Tools
add_skill
Get a skill by name. Like npx skills add for runtime.
search_skills
Search for skills by query. Returns ranked results.
get_skill
Get a specific skill by source and ID.
get_cache_stats
Get cache statistics for debugging.
Example: add_skill
The simplest way for agents to learn skills:
# Simple name - searches and returns best match
add_skill("react-best-practices")
# Full path - direct lookup
add_skill("vercel-labs/agent-skills/vercel-react-best-practices")Self-Hosted MCP
If you prefer to run your own MCP server:
{
"mcpServers": {
"skyll": {
"command": "/path/to/skyll/venv/bin/python",
"args": ["-m", "src.mcp_server"],
"cwd": "/path/to/skyll"
}
}
}Standalone Mode
# Stdio transport (for MCP clients)
python -m src.mcp_server
# HTTP transport (for web clients)
python -m src.mcp_server --transport http --port 8080
# SSE transport (legacy)
python -m src.mcp_server --transport sse --port 8080Use Cases
Real examples of how agents can use Skyll to discover and apply skills dynamically.
Web Research
tavily-searchUser asks 'Find the latest news on AI agents' โ Agent searches Skyll for web search skills โ Discovers tavily-search โ Uses Tavily's LLM-optimized search API to fetch real-time results.
Deep Research
gpt-researcherUser needs comprehensive market analysis โ Agent queries Skyll โ Finds gpt-researcher โ Runs autonomous multi-step research with citations and detailed reports.
Testing Workflows
test-driven-developmentUser says 'Add tests for this feature' โ Agent doesn't know TDD โ Searches Skyll โ Retrieves test-driven-development skill โ Follows TDD workflow.
Building Integrations
mcp-builderUser wants to connect app to external APIs โ Agent needs MCP knowledge โ Finds mcp-builder on Skyll โ Creates Model Context Protocol servers following best practices.
Why Options Matter
Skyll returns a ranked list of skills, not just one result. This gives agents the freedom to:
- Choose based on the specific context of the user's request
- Prefer popular, well-tested skills (high install count)
- Discover new skills they weren't pre-configured with
- Let developers filter/sort based on their own criteria
Contributing
Add Your Skill to the Registry
The community registry at registry/SKILLS.md is the easiest way to make your skill discoverable.
- your-skill-id | your-username/your-repo | path/to/skill | Short description of what it doesRequirements
- Valid
SKILL.mdfollowing the Agent Skills Spec - Public GitHub repository
- Description under 80 characters
- Skill should be useful and well-documented
Add a New Skill Source
Want to add a new source beyond skills.sh and the registry? Implement the SkillSource protocol:
from src.sources.base import SkillSource, SkillSearchResult
class MyCustomSource(SkillSource):
@property
def name(self) -> str:
return "my-source"
async def search(self, query: str, limit: int) -> list[SkillSearchResult]:
# Your search logic here
...
async def initialize(self) -> None:
# Setup (called on startup)
...See docs/sources.md for full documentation.