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/..."
}
}
]
}/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 four weighted factors.
score = content + references + query_match + popularityContent Availability
40 pts maxSkills with successfully fetched SKILL.md content receive 40 points. This ensures skills with actual content rank above those that failed to fetch.
| Has content | +40 |
| No content (fetch failed) | 0 |
Query Match
30 pts maxHow well the skill ID matches the search query.
| Exact ID match | +30 |
| All query terms in ID | +27 |
| All ID terms in query | +25.5 |
| Partial 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 |
| Skill | Content | Refs | Query | Pop. | Total |
|---|---|---|---|---|---|
| Exact match, popular, with content | 40 | 15 | 30 | 15 | 100 |
| Good match, popular, with content | 40 | 0 | 25 | 12 | 77 |
| Partial match, new skill | 40 | 0 | 15 | 0 | 55 |
| No content (fetch failed) | 0 | 0 | 30 | 15 | 45 |
Design Rationale
Content is king. Skills without content are not useful, so content availability dominates the score.
Query relevance matters. Exact matches should rank above partial matches, regardless of popularity.
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.
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 can run as an MCP (Model Context Protocol) server, making it available as a tool for Claude Desktop, Cursor, and other MCP-compatible clients.
Claude Desktop Configuration
{
"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
# SSE transport (for web clients)
python -m src.mcp_server --transport sse --port 8080Available MCP Tools
search_skills
Search for skills by query. Returns ranked results.
get_skill
Get a specific skill by source and ID.
Use 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.