AI Agents Can Now Discover Skills at Runtime — Without Any Human Intervention

Catalin Crisan — Wed, 08 Apr 2026 10:07:07 +0000

The moment I realized something unexpected was happening

I was reviewing our backlink data when I noticed something strange. A GitHub issue on quickwit-oss/tantivy — a Rust full-text search library with 37 million monthly visitors — was linking to our domain. The issue title: "Your SKILL.md was picked up by the Invoked registry."

We hadn't emailed anyone. We hadn't submitted to any directory. A crawler had found a SKILL.md file in that repository, added it to the registry, and automatically notified the repo owner via a GitHub issue — which contained a link back to us.

That was one of 349 such notifications sent in 72 hours.

What is runtime skill discovery?

Runtime skill discovery is the ability of an AI agent to find, evaluate, and invoke a capability it has never been explicitly programmed with — at the moment it needs it, not before.

Traditional AI agent setup looks like this: a developer manually installs skills, tools, or plugins before the agent runs. The agent only knows what it was given. If a new skill appears after setup, the agent is blind to it.

Runtime discovery changes the model entirely. The agent queries a live registry at the moment of need, finds the most relevant skill for the task, and invokes it — all without human intervention.

How it works

The mechanism has three parts:

SKILL.md — a standard format for agent capabilities

Any developer can publish a skill by adding a SKILL.md file to a GitHub repository. The file describes what the skill does, when to use it, and how to invoke it. No package submission, no approval process.

Automatic indexing

A crawler continuously scans public GitHub repositories for SKILL.md files. When one is found, it is added to the public registry within hours. The developer who owns the repo receives a GitHub notification — their skill is now discoverable by every agent connected to the registry.

As of April 2026, the registry contains 14,385 skills across individual developers, teams, and vendors.

MCP-based runtime resolution

The registry exposes a Model Context Protocol (MCP) server. When an agent needs a capability, it queries the registry with a natural language description. The registry returns the most relevant matches using semantic search. The agent invokes the skill directly — no reinstallation, no reconfiguration.

Configure once. Every registered skill is available on demand.

What makes this different from existing approaches
Most skill systems today are static. You install a plugin, you get that plugin's capabilities. The agent's knowledge is frozen at install time.

Runtime discovery treats skills like web pages — indexed, searchable, accessible to any agent that knows where to look. The registry grows continuously. An agent running today has access to skills that didn't exist yesterday.

The closest analogy: npm, but the package manager is the agent itself, and it decides which packages to use based on the task at hand.

What skill creators get: invocation analytics
When a skill is registered in the registry, its author gets access to invocation data — how many times their skill was called, across all agents using the registry, in the last 30 days.

This is new. Previously, a developer who published a SKILL.md file had no way of knowing if anyone was using it. The skill would sit in a GitHub repository, occasionally starred, with no signal of real-world usage.

Invocation data changes the feedback loop for skill development. Authors can see which skills get used, iterate on the ones that don't, and understand how agents actually behave in production.

The 349-repo discovery

When we ran the first automated discovery pass, 349 repositories were identified as containing SKILL.md files. Each repository owner received a GitHub notification. Many of those repos belong to active projects — real codebases with real audiences.

The tantivy repository (37M monthly visitors, DR 97) was among them. So was a repository from a contributor at a major AI lab. Neither had submitted to anything. The crawler found them.

This is what unsolicited skill discovery looks like at scale: the registry finds skills, not the other way around.

How to connect your agent to the registry

`Run the npm command:

npm install -g invoked-sh`

Then add this MCP Server config into your Agent:




{
  "mcpServers": {
    "invoked": {
      "command": "npx",
      "args": ["-y", "invoked-sh"]
    }
  }
}

Then ask Claude: "Search for a cold email skill." The agent queries the live registry and returns matching skills — descriptions, invocation counts, and source repositories — without you installing anything in advance.

How to publish your own skill

Add a SKILL.md file to any public GitHub repository
The crawler will find it within 24–48 hours
You'll receive a GitHub notification when it's indexed
Your skill is immediately discoverable by every agent connected to the registry
Claim your skill at invoked.sh/claim to access invocation analytics.

FAQ

_What is an agent skill registry?
_An agent skill registry is a searchable index of capabilities that AI agents can discover and invoke at runtime. Unlike static tool configurations, a registry grows continuously and is accessible to any agent with the right MCP configuration.

_What is a SKILL.md file?
_A SKILL.md file is a structured markdown document that describes an agent capability — its name, description, usage instructions, and invocation format. It is the standard format for publishing skills to the Invoked registry.

_How is runtime skill discovery different from MCP?
_MCP (Model Context Protocol) is the transport layer — it defines how agents communicate with tools. Runtime skill discovery is what happens above that layer: the agent actively searches for the right skill rather than relying on pre-installed tools.

_Can I publish a private skill?
_Currently the registry indexes public GitHub repositories. Private skill support is on the roadmap.

Forem: Catalin Crisan