Model or dataset
zhuyansen/agent-skills-hub avatar
zhuyansen/agent-skills-hub

AgentSkillsHub: a scored directory of Claude Skills and MCP servers, rebuilt every eight hours

Discover and compare open-source Agent Skills, tools & MCP servers — with quality scoring, trending analysis, and automated GitHub sync

501 stars59 forksTypeScriptMIT

At a glance

What is it?
AgentSkillsHub indexes 117,000+ Claude Skills, MCP servers, Codex skills and agent tools on an eight hour GitHub Actions cycle, and documents its scoring weights in detail. The same page never names a license.
Who is it for?
AgentSkillsHub suits an engineer who wants a shortlist of MCP servers and Claude Skills with a defensible ordering, and it is the wrong tool for anyone who has to confirm what a skill actually does before trusting its rank. Two things to check first.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly TypeScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • zhuyansen/agent-skills-hub501 ★ · +121
Star history
Repository2026-09-222026-11-15
zhuyansen/agent-skills-hub380501

121 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Where the 117,000 entries come from: six phases on an eight hour clock

Collection runs out of `scheduler/jobs.py`, and every phase carries a ceiling. Search pulls roughly 30 repositories from 10+ GitHub queries such as mcp-server, claude-skill and agent-tool. Masters adds about 18 repos from verified skill creators. Extra adds about 14 from community submissions and curation. Enrich fetches up to 500 owner profiles for follower counts. README pulls up to 300 full READMEs, each capped at 50KB. Upsert has a budget of zero because it only cleans, scores and saves.

Weekdays run an incremental sync over new and updated repositories, Sundays run a full one. When GitHub throttles the job, it waits for the real reset time instead of retrying into the ceiling, which is why a backlogged run stretches rather than fails.

Those budgets explain the shape of the eight hour cycle. A single pass touches a few hundred README payloads at most, so the 117,000+ figure is the accumulated product of many runs, not one sweep. Set against browsing GitHub topics by hand, the difference is normalization rather than reach: the pipeline derives a platform inference across 17 platforms, a token estimate, and composability pairings from TF-IDF plus 8 signals, none of which a topic search computes for you. The price is an eight hour staleness window and keyword guessing, both of which show up in the next stage.

Deduplication by repo_full_name, and a category list that contradicts itself

`services/data_cleaner.py` deduplicates by `repo_full_name`, infers whether a project is a framework, a skill or a tool, buckets size from micro at 50KB or below up to large above 5MB, and assigns a category by keyword.

That keyword list is `mcp-server`, `claude-skill`, `codex-skill`, `agent-tool`, `ai-skill`, `llm-plugin`, `youmind-plugin`. The directory advertises a different set of seven categories: `mcp-server`, `claude-skill`, `codex-skill`, `agent-tool`, `prompt-library`, `ai-coding-assistant`, `uncategorized`. Three labels the cleaner can emit, `ai-skill`, `llm-plugin` and `youmind-plugin`, never appear in the published taxonomy, and two published categories, `prompt-library` and `ai-coding-assistant`, never appear as classifier keywords. A repository tagged `youmind-plugin` therefore has no documented route into the seven categories the site presents.

Because assignment is keyword-driven rather than model-driven, a project can also change category when its README wording changes. That moves its composite score without a single line of code changing, and the same wording drift reshuffles which /compare/ page it lands on. Size buckets feed the Size Bonus signal too, so a repository that crosses 5MB loses points on the sweep that notices.

README Structure is worth 23 percent of quality, Examples only 12

`services/quality_analyzer.py` scores six dimensions. Completeness carries 15% and reads README size, license, description and stars. Clarity carries 15% from description quality, topics and naming. Specificity carries 15% from language, topic count, category and size. Examples carries 12% from code examples, commits and contributors. README Structure carries 23% from sections, code blocks, badges and a table of contents. Agent Readiness carries 20% from API docs, config, install instructions and MCP compliance.

Two consequences follow from those weights. A tidy table of contents plus an install snippet outweighs a repository full of usage examples, because Structure and Agent Readiness together are 43% while Examples is 12%. And MCP compliance is a lever a server project can pull that a prose-only skill cannot, so the same 0 to 100 score is not measured on the same scale across categories. A skill that is all instructions and a server that ships a full config both reach 100 through different paths.

One gap is worth naming. None of the six dimensions mentions security, even though the site header advertises security grading and links a security report at agentskillshub.top/blog/securing-117k-ai-skills/. Whatever that grading measures, it is documented outside the scoring path these two service files describe.

Nine signals in the scorer table, ten in the headline

`services/scorer.py` folds the six dimensions into a 0 to 100 composite from nine weighted signals: Quality at 20% as the six-dimension aggregate, Stars at 18% with log₁₊ₓ normalization, Recency at 11% with exponential decay e⁻⁰·⁰¹ᵈ, Forks at 10%, Commits at 10%, Issue Resolution at 10% as resolved over total, Momentum at 8% as a Z-score of star growth, Author Followers at 8%, and Size Bonus at 5% weighted so that smaller ranks higher.

Those nine weights add up to exactly 100. The site header and the repository description both say 10 weighted signals, so a tenth either sits folded into one of these rows or is absent from the table. `docs/scoring-algorithm.md` is linked as the full design.

Recency is the term to read before trusting any ordering. An e⁻⁰·⁰¹ᵈ decay means a project with no commits for roughly 70 days keeps about half of its recency contribution, so a famous tool that stopped moving slides down the same list a newcomer climbs. Momentum is the only signal looking at the rate of change rather than the total, and a Z-score over a short window is the easiest of the nine to move on a single good week.

Production reads Supabase directly, local runs go through FastAPI

Presentation splits into two modes. Production uses Supabase PostgREST and RPCs directly; development uses the FastAPI backend. `get_landing_data()` replaces 7+ API calls with one RPC. Database views such as `v_trending`, `v_top_rated` and `v_rising` pre-shape the common lists, full text search runs on a PostgreSQL tsvector with a GIN index, and HTTP caching runs from 5 minutes for trending to 1 hour for stats.

The FastAPI surface covers `GET /api/skills` for paginated search, filter and sort, `GET /api/skills/{id}` with compatible skills, `GET /api/trending` for 7 day star velocity, `GET /api/rising` for new this week, `GET /api/top-rated`, `GET /api/most-starred` for classics older than 6 months, `GET /api/masters` for verified creators and org builders, `GET /api/landing`, `GET /api/stats`, an RSS 2.0 feed at `/api/feed.xml`, an SEO sitemap at `/api/sitemap.xml` covering 6,000+ URLs, plus `POST /api/submit-skill` and `POST /api/subscribe`.

Worth knowing before you write a client against it: the routes are FastAPI shaped while production traffic can bypass FastAPI entirely. Treat the local backend as a development contract, not the production path. The sitemap covering 6,000+ URLs against 117,000+ indexed projects is another gap to keep in mind if you plan to rely on crawl coverage.

Running the backend and the React frontend on your own machine

Two directories, two toolchains. The backend is Python 3.12 with FastAPI, SQLAlchemy and httpx, and it wants a GitHub token before the sync queries anything:

bash
cd backend
python3.12 -m venv venv && source venv/bin/activate
pip install -r requirements.txt
cp .env.example .env   # Add GITHUB_TOKEN
uvicorn app.main:app --reload

Copy `.env.example` to `.env` and fill in what the scheduler reads:

bash
GITHUB_TOKEN=ghp_xxx          # GitHub API (required)
SUPABASE_DB_URL=postgresql://  # Production database
RESEND_API_KEY=re_xxx          # Email service
ADMIN_TOKEN=sk-xxx             # Admin API auth
SYNC_INTERVAL_HOURS=8          # Sync frequency

`SYNC_INTERVAL_HOURS` sets how often the scheduler wakes up. `SUPABASE_DB_URL` points at production while local work runs on SQLite. The Resend key matters only for the newsletter job, which GitHub Actions runs on Mondays. Check `ADMIN_TOKEN` before pasting it anywhere: its documented `sk-` prefix reads like a model provider key rather than a directory admin secret.

The frontend is React 18 with Vite and TailwindCSS v4:

bash
cd frontend
npm install
npm run dev

Run both and the React app talks to the FastAPI backend. In production the same frontend is deployed to GitHub Pages by `deploy.yml`, with `sync.yml` running every 8 hours.

No LICENSE file, no releases, and a README that stops mid-sentence

The top-level tree lists `.agents/`, `.claude/`, `.github/`, `.gitignore`, `.loopflow/`, `CLAUDE.md`, `CONTEXT.md`, `README.md`, `backend/`, `docs/`, `frontend/`, `memory/`, `ops/` and `supabase/`. No LICENSE file appears in that list, and no license is declared, so nothing here grants reuse of the code or of the scoring database. Ask before you vendor either.

The last push landed on 2026-10-01 and the repository publishes no GitHub releases, which leaves main as the only installable state and nothing to pin a dependency against. The visible README also cuts off mid-sentence in the Community section, right after the Discussions link for false-positive repo reports, so the moderation path beyond that point is not described on the repository page.

Submissions arrive through the Submit Skill form on the homepage or by opening an issue, and they land in the next 8 hour sync. An unreviewed repository can sit in the index for hours after it is added. At the other end of the age range, `/api/most-starred` treats nothing as a community classic until it is 6 months old, so a brand new project cannot appear there by any score.

Editorial conclusion

AgentSkillsHub suits an engineer who wants a shortlist of MCP servers and Claude Skills with a defensible ordering, and it is the wrong tool for anyone who has to confirm what a skill actually does before trusting its rank. Two things to check first. The repository declares no license and publishes no GitHub releases, so pin nothing and assume no reuse terms for the code or the score database. Then read docs/scoring-algorithm.md against services/scorer.py, because the site header counts 10 weighted signals while the table in the README lists 9, and the security grading advertised on the homepage appears in none of the six quality dimensions.

Frequently asked questions

What is the AI skills hub?

AgentSkillsHub is a continuously updated directory of open source Claude Skills, MCP servers, Codex skills, AI coding assistants and agent frameworks collected from GitHub. It groups every entry into one of 7 categories and rescores them on 6 quality dimensions every 8 hours.

What are agent skills in Claude?

In this directory a Claude skill is one tracked project type. Entries are classified as claude-skill, codex-skill, mcp-server, agent-tool, prompt-library, ai-coding-assistant or uncategorized, then scored on completeness, clarity, specificity, examples, README structure and agent readiness.

How much of the composite score rewards small repositories?

Size Bonus carries 5% of the composite score and is weighted so smaller repositories rank higher. Quality carries 20%, Stars 18%, Recency 11% with an exponential decay of e⁻⁰·⁰¹ᵈ, and Forks, Commits and Issue Resolution carry 10% each.

What does it take to run AgentSkillsHub locally?

A Python 3.12 virtualenv with the contents of `requirements.txt` installed and `uvicorn app.main:app --reload` for the backend, then `npm install` and `npm run dev` inside `frontend/`. `GITHUB_TOKEN` is required for the GitHub API and local database work uses SQLite.

How do community submissions reach the index?

Submit a GitHub repository through the Submit Skill form on the homepage or by opening an issue, and the entry lands in the next 8 hour sync. Methodology questions and false-positive repository reports go to GitHub Discussions.

Official sources

  1. Issues
  2. Project website
  3. README
  4. zhuyansen/agent-skills-hub on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/zhuyansen-agent-skills-hub.svg)](https://hysenlabs.com/projects/zhuyansen-agent-skills-hub)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/zhuyansen-agent-skills-hub.svg)](https://hysenlabs.com/projects/zhuyansen-agent-skills-hub)

Was this useful?