Agent Skill Registry

What is it

An Agent Skill Registry is a centralized catalog where AI agents discover, install, and invoke reusable capabilities — "skills" — the way npm hosts JavaScript packages or the App Store distributes mobile apps. Technically, a skill is a packaged, versioned, permissioned unit of agent behavior: a function spec, a prompt template, an API wrapper, or a full workflow that a Claude agent (or any LLM runtime) can load on demand. The registry handles discovery, versioning, dependency resolution, auth, and billing.

The business significance is bigger than the plumbing. When capabilities become packages, distribution becomes the moat. The examples in the source data make this concrete: mattpocock/skills on GitHub, Graphify's /graphify skill, and Luckin turning coffee ordering into an agent skill all point to the same shift — a skill is now a product surface, not just a code artifact. Whoever owns the registry owns the shelf space where every agent capability gets discovered, ranked, and monetized. That is a platform position, and platform positions are where the durable margin lives. This is the npm moment for agent capabilities, arriving before the ecosystem has consolidated.

Why now

Three forces converged in 2026 to make this inevitable. First, agent runtimes matured. Claude's tool-use and skill-loading primitives, plus competing runtimes from OpenAI and open-source frameworks, gave every agent a standard "install a capability" hook. Before that, every integration was bespoke glue code.

Second, the supply of skills exploded faster than discovery could handle. mattpocock/skills and Graphify's /graphify are early examples, but the pattern is general: developers are shipping narrow, high-value skills (data enrichment, document parsing, commerce actions) and have nowhere to list them. GitHub repos are a terrible distribution channel for agent-runtime artifacts — no versioning semantics for agents, no permission model, no discovery ranking.

Third, commercial demand arrived. Luckin turning coffee ordering into an agent skill is the signal that matters: a real consumer brand treating agent skills as a distribution channel. Once non-tech companies want their service to be "callable by agents," they need a registry to be listed in. That's a two-sided market forming in real time.

The timing is precise because the tooling just became standard enough to package skills portably, but no dominant registry exists yet. Twelve months ago the runtimes weren't ready; twelve months from now the shelf will likely be claimed.

Market Evidence

The data is thin but directional: 2 independent sources (juejin and GitHub), 3 total mentions, 100% growth rate, stage classified as nascent, trend score 63/100. Read honestly, this is an early signal, not a proven market. Three mentions is not demand — it's a leading indicator.

But the composition of the evidence matters more than the count. The sources are independent and different in kind: a Chinese developer community (juejin) and GitHub, which means the concept is crossing both geographic and platform boundaries. That's the pattern you want at the nascent stage — not volume, but diversity of origin. A single platform spiking looks like hype; two unrelated platforms converging looks like a real primitive forming.

The 100% growth rate off a tiny base is mathematically meaningless on its own — going from 1 to 2 mentions is 100%. The stage label "nascent" is the honest read. The 63/100 trend score suggests the tracker sees momentum but not yet conviction.

My position: this is real but early. The demand signal is the Luckin example — a commercial brand adopting the pattern — not the mention count. Watch for the next 60 days: if a third and fourth independent source appear, and if any registry launches publicly, the signal converts from "interesting" to "act now." Right now it's a build-cheap-and-validate situation, not a raise-money situation.

Who's Behind It

The visible drivers are developer-led, not corporate. mattpocock/skills is an individual developer's skill collection — the kind of bottom-up artifact that seeded npm and Homebrew. Graphify's /graphify skill shows a company treating a skill as a productized capability. Luckin represents the demand side: an established consumer brand experimenting with agent-native ordering.

The "whales" to watch are the runtime owners: Anthropic (Claude), OpenAI, and the major agent frameworks. Whoever ships the default skill-loading mechanism has the inside track to own the registry, exactly as Apple owned the App Store by owning iOS. Their competitive dynamic is the central question — will they build a registry themselves, or leave a gap for a third party?

The indie opportunity lives in that gap. Historically, platform owners are slow to build marketplaces for their own ecosystems (see how long it took Apple to improve App Store discovery, or how npm was a community project before GitHub absorbed it). That lag is the window. The community drivers — GitHub skill repos, Chinese dev communities on juejin — are the supply side that will need a home before the platforms get around to building one.

TAM & Market Size

The buyers split into two sides. Supply side: developers and companies packaging skills. Demand side: agent operators and end users who need capabilities discovered and installed.

Start with the realistic serviceable market. There are roughly 30-50 million developers worldwide; the subset actively building agent integrations in 2026 is maybe 1-3 million and growing fast. Of those, the ones who will pay for skill distribution tooling — early adopters, agencies, product teams — is a few hundred thousand. That's the near-term TAM for a registry SaaS, and it's enough to build a real business on.

Price tolerance: developers pay $0-20/month for tooling individually, but teams pay $50-500/month for anything that touches production distribution, security, or billing. Enterprise buyers — the Luckin-type companies wanting their service listed — will pay $500-5,000/month for placement, analytics, and integration support. That's the higher-value side.

The scores give zero (opportunity, market, demand all 0/100), which reflects the tracker's inability to size an unformed market rather than genuine zero demand. Treat the zeros as "unknown," not "none." The honest position: this is a market you help create, not one you enter. That means TAM expands as you build, and the first credible registry captures disproportionate share because it becomes the default.

Competitive Landscape

No dominant player exists yet — that's the whole opportunity. The nearest analogues are fragmented: GitHub repos (no agent semantics), LangChain's tool hub (framework-locked), and early skill collections like mattpocock/skills (personal, not a platform). Each has a fatal gap. GitHub can't rank or version for agent runtimes. LangChain's hub only serves LangChain users. Personal collections don't scale discovery.

The real competition is the platform owners. If Anthropic ships an official Claude Skill Registry, an indie competitor's window shrinks to the "multi-runtime, neutral" niche — the Switzerland position. That's actually defensible: developers building for Claude and OpenAI and open-source runtimes will prefer a registry that isn't owned by any one vendor, the same way companies use Terraform instead of a single cloud's native IaC.

Time budget: assume 6-12 months before a major platform ships something official. That's your runway to establish supply-side liquidity and a neutral brand.

The competition score is 0/100, meaning the tracker sees essentially no established competition — consistent with "nascent." Differentiation levers: multi-runtime neutrality, a real permission/security model (the thing enterprises will pay for), and revenue-share billing so skill authors can actually monetize. Win supply first; demand follows liquidity.

Business Model

Go freemium with a marketplace take rate — the combination that fits two-sided distribution.

Free tier: unlimited public skill publishing and installation for individuals. This drives supply-side liquidity, which is the only thing that matters early. Charge on the demand and enterprise side.

Paid tiers:

• Pro ($19/month): private skills, team sharing, usage analytics, priority ranking in search.
• Team ($99/month): SSO, audit logs, permission controls, private registry.
• Enterprise ($500-2,500/month): SLA, on-prem/VPC deployment, custom integration, dedicated support.
• Marketplace take rate (15-20%): on paid skills, so authors monetize and you capture a cut of transaction value — the App Store model.

Why this fits: registries live or die on liquidity, so you cannot charge supply early. The take rate aligns your revenue with author success and scales without a sales team. Enterprise tiers monetize the security/compliance needs that only show up at scale.

12-month forecast (assumes you launch within 90 days):

• Conservative: 2,000 free users, 60 Pro, 15 Team, 2 Enterprise → ~$5.5K MRR.
• Base: 8,000 free, 300 Pro, 60 Team, 8 Enterprise → ~$25K MRR.
• Optimistic: 25,000 free, 1,000 Pro, 200 Team, 30 Enterprise + take rate → ~$90K MRR.

CAC: developer tools run $50-150 via content and community; enterprise $2,000-8,000 via outbound. Payback under 6 months for Pro/Team, 9-12 for enterprise. The take rate has near-zero CAC — it's your margin engine.

MVP Blueprint

Ship in 5-7 days. Cut everything that isn't discovery, install, and versioning.

Core features (ONLY these):

1. Skill manifest spec — a simple skill.json (name, version, runtime targets, permissions, entry point). Publish this spec publicly; it's your standard-setting move.
2. Publish CLI — skill publish that validates the manifest and pushes to the registry. One command, no dashboard needed for v1.
3. Install CLI — skill install <name> that resolves the version and drops the skill into the agent runtime's expected path.
4. Web catalog — a searchable, ranked list of published skills. Read-only. This is your SEO surface and your supply-side showcase.
5. Basic auth + versioning — semantic versioning, immutable releases, API keys.

Tech stack: Next.js for the catalog (fast, SEO-friendly), Postgres for the registry metadata, S3/R2 for skill bundles, a thin Python or Node CLI published to PyPI/npm. Auth via GitHub OAuth — developers already have it.

Fastest path to launch: build the CLI first, seed it with 10-20 hand-curated skills (including a port of mattpocock/skills and a /graphify-style example), then launch the catalog. Don't build billing, private registries, or analytics in v1 — those are week-3+ features gated behind the Pro tier.

The single success metric for the MVP: number of skills published by people who aren't you. If that number moves past 20 organically in the first month, you have a market. If it stalls at 5, the primitive isn't ready.

Commercial Opportunities

1. Neutral multi-runtime registry (core play). A registry that serves Claude, OpenAI, and open-source runtimes equally. Target user: agent developers and platform teams who refuse vendor lock-in. Expected revenue: $5K-25K MRR within 12 months on subscriptions. Why it beats alternatives: platform-owned registries will always be distrusted by multi-vendor shops, and that distrust is a permanent moat.

2. Enterprise private skill registry. On-prem/VPC deployment for companies that want internal skill distribution with audit logs and permission controls. Target user: enterprises with 50+ internal agents (banks, healthcare, large SaaS). Expected revenue: $1K-5K/month per customer, 5-15 customers = $5K-75K MRR. Why it beats alternatives: this is the highest-willingness-to-pay segment and the one Big Tech serves worst, because they optimize for public ecosystems, not private ones.

3. Skill monetization infrastructure. Billing, licensing, and usage metering so skill authors can charge per-call or per-seat. Target user: independent skill authors and the Luckin-type brands wanting agent distribution. Expected revenue: 15-20% take rate on a growing transaction volume. Why it beats alternatives: it turns your registry into a two-sided marketplace with compounding network effects — the hardest thing for a competitor to clone.

Product Ideas

🥇 SkillHub — the neutral agent skill registry. One-line value prop: "npm for AI agent skills, across every runtime." Target user: agent developers and platform teams. Why now: runtimes just standardized skill-loading, and no neutral registry exists — the shelf is unclaimed. This is the platform bet; build it first.

🥈 SkillKit — enterprise private registry. One-line value prop: "Your company's internal agent skills, versioned, permissioned, audited." Target user: enterprises running many internal agents. Why now: security and compliance teams are already blocking ad-hoc skill installs; they need a sanctioned channel. This is the revenue bet — higher ACV, longer sales cycle, but it funds the platform play.

🥉 SkillPay — monetization layer for skill authors. One-line value prop: "Charge for your agent skills without building billing." Target user: independent skill authors and brands like Luckin. Why now: authors are publishing skills with no way to get paid, and the moment one skill earns real money, everyone wants the same rails. This is the margin bet — it layers on top of either of the above.

Priority logic: SkillHub establishes supply and brand; SkillKit monetizes enterprises; SkillPay captures transaction value. They share one registry core, so build SkillHub, then bolt on the other two. Do not start with SkillPay — it's worthless without liquidity.

SEO Opportunity

Search volume for "agent skill registry," "claude skills," and "agent skills marketplace" is low today but trending up sharply — this is a category-defining keyword set, which means near-zero competition and the chance to own the terms outright. SEO difficulty: 0/100 confirms it.

Long-tail targets: "how to install claude skills," "agent skill registry vs github," "claude skill manifest format," "monetize ai agent skills," "private agent skill registry."

Content strategy: publish the skill manifest spec as a canonical, linkable document, plus "how to publish your first skill" tutorials. Own the vocabulary before the category has a name — whoever defines the spec defines the search terms.

Risk Assessment

Risk 1 — Platform absorption (market). Anthropic or OpenAI ships an official registry and makes third-party ones redundant. This is the thesis-killer. Mitigation: build for multi-runtime neutrality from day one; the Switzerland position survives platform entry.

Risk 2 — The primitive stalls (tech). "Skills" stay a niche pattern and never become a real distribution unit — the 3-mention count is a warning, not just an early signal. Mitigation: validate supply-side pull before building the full product.

Risk 3 — Liquidity failure (execution). You build a beautiful registry and nobody publishes. Two-sided markets die from empty shelves. Mitigation: hand-seed 20-50 skills yourself and recruit 5-10 known authors personally.

Cheap validation before building: publish the manifest spec as a public GitHub repo and a landing page. Ask 20 agent developers if they'd publish to it. If fewer than 5 say yes, the demand isn't there yet. Run this in a week for near-zero cost.

Walk away if: no third independent source appears within 90 days, platform owners announce official registries, or 20 developer conversations yield under 5 committed publishers. Any one of those, reconsider; two of them, stop.

Action Plan

Today: Write and publish the skill.json manifest spec as a public GitHub repo. This costs nothing, establishes you as the standard-setter, and doubles as validation bait — if developers star it and file issues, you have signal.

Week 1: Build a one-page landing site with a waitlist. Post it to the juejin thread, relevant GitHub issues, and developer communities (Hacker News, r/LLMDevs). Cold-DM 20 agent developers asking one question: "Would you publish a skill to a neutral registry?" Track yes/no.

Month 1: If 5+ committed publishers emerge, ship the MVP (CLI + catalog) in 5-7 days as specced. Seed it with 20 hand-curated skills. Launch publicly. Target: 50 published skills, 500 catalog visitors.

Month 3: If organic publishing passes 20 skills/month without your prompting, turn on the Pro tier ($19/month) and start enterprise conversations for private registries. Target: $3-5K MRR, 3 enterprise pilots. If publishing stalls below 10/month, pivot the registry into a pure open-source spec project and monetize via consulting instead.

The gating decision at every stage is the same: does supply grow without you pushing it? Liquidity is the only proof that matters.

Related Terms

Agent Tool Use / Function Calling — the runtime primitive that makes skills loadable. Skills are the packaged, discoverable layer on top of raw tool-calling; as tool-use standardizes, registries become necessary.

MCP (Model Context Protocol) — Anthropic's standard for connecting agents to external data and tools. MCP is complementary infrastructure; a skill registry could index MCP servers as one class of skill, and MCP adoption accelerates the need for discovery.

AI Agent Marketplaces — the broader trend of agents buying and selling capabilities. The skill registry is the supply-side infrastructure that makes agent-to-agent commerce possible; as agent marketplaces mature, registries become their inventory layer.