200+ Skills, One Router: Engineering Practice of Agent Skill Routing

Core question: When an AI Agent has 200+ skills installed, how does it know which one to use before each task?
Answer: It does not "choose one"; it "routes to one." A 5KB SKILL.md uses a category × stage matrix to achieve zero-manual-intervention skill discovery and automatic chaining.

Introduction: The More Skills, the Dumber the Agent?

The promise of the AI Agent paradigm sounds great: give it enough tools, and it can handle anything.

The reality is stark.

Junze Zhiku's AI assistant (UltraClaw) currently has 200+ skills installed, covering nine major domains, including financial research, frontend design, code development, and deployment and operations. In theory, it is an all-around player. In practice, its first reaction is often:

Boss: "Analyze the stock 00058.HK for me."
Agent: opens Google and searches for "00058.HK"
Boss: facepalm "You have ak-hk-stock-dd! You have financial-analyst!"

This is not an isolated phenomenon. A 2026 Gartner report shows that 40% of AI projects are canceled because of Agent coordination failures. 88% of production failures stem from infrastructure gaps, with skill scheduling failures being one of the leading causes.

"Skills are not assets. Skills that can be correctly invoked are assets. The rest are just Markdown files taking up disk space."

Skill Router was created precisely to solve this problem. It has only one 5KB SKILL.md file, installs with a single command, and has zero dependencies, yet it can turn your Agent from "a complex machine that requires a manual to operate" into "an autonomous system that knows what to do just by looking at the requirements."

1. Dissecting the Pain Points: What an Agent Without a Router Looks Like

1.1 Skill Discovery Rate Is Only 35%

An Agent with 200+ skills installed can only rely on prompt engineering to "guess" which skill to use when there is no routing mechanism. The problems are:

Prompts are not an index. It is impossible to fit all 200 skill names into the context window
Descriptions are not intent. Keywords in skill descriptions often do not match keywords in user queries
Names are an obstacle. The name ak-hk-stock-dd means nothing to users, but it is the best tool for Hong Kong stock research

Result: The Agent discovers and uses the correct skill only about 35% of the time. In the remaining 65% of cases, it either uses the wrong tool or does not know the skill exists at all.

1.2 Multi-step Tasks Require Manual Chaining

Real workflows are almost never "one skill solves one problem." They are pipelines:

"Help me research 00058"
  → Search stock basic information (search phase)
  → Extract financial data (analysis phase)
  → Generate research report (report phase)

Without a Router, the user must manually specify the skill at each step. The user must know the names and usage of all relevant skills in the skill system, then manually invoke them one by one. This is not automation; this is a voice-operated version of mouse clicks.

1.3 Startup Cost: 3-5 Turns to Find the Correct Entry Point

Without routing, the startup process for a typical task looks like this:

Turn	User	Agent	Problem
1	"Research 00058 for me"	Starts Google search	Does not know a dedicated tool exists
2	"Use ak-hk-stock-dd!"	Invoke ak-hk-stock-dd	User specifies manually
3	"Then do financial analysis"	Start searching for 'financial analysis'	Does not know financial-analyst exists
4	"Use ak-financial-analyst!"	Invoke ak-financial-analyst	User specifies manually
5	"Finally generate the report"	Finally starts generating the report	3-5 turns wasted

With a Router:

Turn	Agent	Behavior
1	Detect category × phase → Finance × Search → ak-hk-stock-dd → automatically expand analysis → report	Completed in one turn

2. Class x Phase Matrix: The Core of the Routing Mechanism

The core of the Skill Router is a two-dimensional routing table: Class x Phase.

2.1 Four Classes

Class	Emoji	Domains Covered	Skill Count (Examples)
🛠️ Daily	`🛠️`	Communication, document management, search, assistant	~30
💰 Finance	`💰`	Stock research, financial analysis, due diligence, valuation	~40
💻 Code	`💻`	Frontend development, backend, testing, deployment	~60
🎨 Design	`🎨`	UI/UX, template design, video editing	~30

2.2 Six Phases

Phase	Emoji	Trigger Keywords	Typical Skills
📋 Planning	`📋`	"Plan", "Planning", "Proposal"	`agent-daily-planner`, `deal-execution-plan`
🔍 Search	`🔍`	"Find", "Look up", "Research", "Search"	`tavily-search`, `ak-hk-stock-dd`, `firecrawl-search`
🎨 Design	`🎨`	"Design", "UI", "Frontend", "Template"	`frontend-design`, `dashboard`, `design-brief`
💻 Development	`💻`	"Write", "Make", "Build", "Develop", "build"	`fullstack`, `claude-code`, `animejs`
🧪 Diagnosis	`🧪`	"Fix", "Bug", "Error", "debug"	`diagnose`, `ak-bdd`
📊 Analysis	`📊`	"Analyze", "Evaluate", "Report"	`ak-financial-analyst`, `dd-business-report`

2.3 Routing Table Example (Partial)

User Says	Class	Phase	Recommended Skills
"Hong Kong stock research", "Check this stock"	💰 Finance	🔍 Search	`ak-hk-stock-dd`, `tavily-search`
"Make a website", "Frontend page"	💻 Code	🎨 Design	`frontend-design`, `design-taste-frontend`
"Deploy", "Go live", "Publish"	🛠️ Daily	🚀 Deployment	`deploy-vercel`
"Fix Bug", "Error", "Troubleshoot"	💻 Code	🧪 Diagnosis	`diagnose`, `claude-code-bridge`
"Do financial analysis", "Valuation"	💰 Finance	📊 Analysis	`dcf-valuation`, `ak-financial-analyst`
"Write report", "Generate document"	🛠️ Daily	📊 Analysis	`blog-post`, `email-report`

3. Multi-Stage Auto-Expansion: From Single-Point Routing to a Complete Pipeline

The most powerful feature of Skill Router is not "finding the right skill", but automatically expanding a multi-stage pipeline.

3.1 Expansion Logic

After a task is routed to the correct skill in the first stage, the Router detects the natural subsequent stages of the task:

Initial routing complete
    │
    ├─ Check whether the task type requires subsequent stages
    │
    ├─ Search-type tasks → Automatically trigger analysis stage
    │    Example: ak-hk-stock-dd (search) → ak-financial-analyst (analysis)
    │
    ├─ Analysis-type tasks → Automatically trigger reporting stage
    │    Example: ak-financial-analyst (analysis) → dd-business-report (report)
    │
    └─ Design-type tasks → Automatically trigger deployment stage
         Example: frontend-design (design) → deploy-vercel (deployment)

3.2 Real-world Example: "Help me research 00058"

User input: "Help me do research on 00058 (Sunway International)"
    ↓
[Route 1] Keyword detection: "do...research" + "00058" (stock code)
          → 💰Finance × 🔍Search → ak-hk-stock-dd
    ↓
[Auto-expand Phase 2] Search complete → Financial analysis required
          → 💰Finance × 📊Analysis → ak-financial-analyst
    ↓
[Auto-expand Phase 3] Analysis complete → Report generation required
          → 💰Finance × 📊Analysis → dd-business-report
    ↓
Final output: complete in-depth stock research report

Throughout the entire process, the user only said one sentence. The Agent automatically completed the skill scheduling, context passing, and output integration for the three stages.

IV. R0 Mandatory Pre-check Rule: How the Router Becomes the Agent's "First Reflex"

The value of a tool is not that it exists, but that it is used every time.

Skill Router ensures this by embedding a mandatory rule in AGENTS.md:

## 🔴 STEP -2: SKILL-ROUTER PRE-CHECK (MANDATORY)

Before you say "Good morning", before you read any rules, before you do ANYTHING else:

1. Read skills/skill-router/SKILL.md
2. Classify the user's intent: Category × Stage
3. From the router table, identify at least ONE recommended skill
4. Read that skill's SKILL.md and follow it
5. 🔴 If you skip this step, you are breaking a mandatory protocol.
   There is no exception.

"R0 is not a suggestion, it is a constitution. The first step of every conversation must be routing."

The placement of this rule is deliberate: it is placed at STEP -2 (before the meta-skill trio in STEP -1), ensuring that routing is completed before the Agent does anything else.

Why "Mandatory" Instead of "Advisory"?

We tested two approaches:

Advisory approach ("Skill Router is recommended"): compliance rate approximately 60%. The Agent will skip it, especially on simple tasks
Mandatory approach ("violating this rule = violating the protocol"): compliance rate approximately 98%. The remaining 2% occurs in extremely minimal scenarios (such as when the user sends only one emoji)

Conclusion: The discipline of an AI Agent depends on the absoluteness of the rules. "Advisory" = 60%, "Mandatory" = 98%.

5. Performance Data

The following is a comparison of key metrics for the Junze Zhiku AI Assistant before and after deploying Skill Router:

5.1 Core Metrics

Metric	Without Router	With Router	Improvement
Skill discovery rate	~35%	~90%	+157%
Incorrect tool usage rate	Frequent (about 65% of tasks used the wrong tool)	Very rare (~13%)	-80%
Task initiation turns	3-5 turns	1 turn	-60% to -80%
Multi-step task interruption rate	High (manual chaining frequently fails)	Very low	-90%
Number of manual user interventions	2-4 times per task	0-0.5 times per task	-85%

5.2 Breadth of Skill Usage

Before deployment (no Router):
  ├── Daily-use skills: ~12 (concentrated in the top 5%)
  ├── Never-used skills: ~140 (70% of skills are never triggered)
  └── Skill long tail completely abandoned

After deployment (with Router):
  ├── Daily-use skills: ~45 (coverage 22%)
  ├── Periodically used skills: ~80 (coverage 40%)
  └── On-demand invoked skills: ~60 (passive routing covers the rest)

200 skills went from being "decorations sitting in a folder" to a "discoverable tool ecosystem."

5.3 Time Savings

Single task time comparison:

Without Router:
  ├── Skill discovery (manual): 2-4 minutes
  ├── Skill invocation: 30 seconds-2 minutes
  └── Total: 3-6 minutes

With Router:
  ├── Skill routing (automatic): < 1 second
  ├── Skill invocation: 30 seconds-2 minutes
  └── Total: same workload, saves 3-5 minutes of manual troubleshooting

At 20 tasks per day, saving 1-1.5 hours per day of "skill discovery friction".

6. Extensibility: The Router Is Not a Black Box, It Is Your Domain Map

The design philosophy of Skill Router is "completely open, completely customizable." It does not presuppose your skill system; it provides a framework for you to fill in with your own skills.

6.1 Adding a New Domain

## My New Domain: 🏥 Healthcare

### Routing Table

| User says | Category | Stage | Recommended Skill |
|--------|------|------|---------|
| "Case Analysis" "Clinical Report" | 🏥 Healthcare | 📊 Analysis | clinical-case-report |
| "Medical Search" "Literature Review" | 🏥 Healthcare | 🔍 Search | pubmed-search |

Simply add a new category and the corresponding skill mappings to the routing table.

6.2 Extending Multi-Stage Pipelines

## Pipeline Definitions

🏥 Medical Pipeline:
  search → clinical-case-report → peer-review-check

6.3 Customizing Trigger Keywords

Each skill can define its own set of trigger keywords:

## ak-hk-stock-dd Trigger Conditions

class: 💰 Finance
phase: 🔍 Search
triggers:
  - "Hong Kong stocks", "Hong Kong shares", "HK stock"
  - "research", "due diligence", "DD", "in-depth research"
  - Stock ticker pattern (4-5 digit number + ".HK")

Forced routing: When user message contains stock ticker + research-related terms → route directly to ak-hk-stock-dd

7. Technical Architecture: Why Can a 5KB SKILL.md Do All This?

7.1 Design Principles

The design of Skill Router follows three core principles:

Zero dependencies. It is just a Markdown file in OpenClaw Skill format, requiring no additional servers, databases, or API
Prompt-Native. It leverages the LLM's own semantic understanding for classification and matching, rather than an external NLP pipeline
Self-documenting. The routing table itself is in Markdown format, human-readable and editable, and requires no learning of a new DSL

7.2 How It Works

User input → 1. LLM parses keywords → 2. Determine category × stage
         → 3. Query routing table to get recommended skill list
         → 4. Read SKILL.md of recommended skills
         → 5. Detect whether follow-up stages are needed
         → 6. Automatically expand pipeline
         → 7. Execute task

7.3 Relationship with Multi-Agent Architecture

Skill Router is not a replacement for a Multi-Agent orchestration framework; it is a pre-routing layer. In a Multi-Agent architecture:

Skill Router (routing layer)
    ↓
Planner (Planning Agent)
    ↓
Research + Analyst (parallel execution Agents)
    ↓
Maker (output Agent)
    ↓
Checker (review Agent)
    ↓
Designer (polishing Agent)

Router is responsible for "what to do", while Multi-Agent is responsible for "how to do it". The two have a clear division of labor.

8. Competitor Comparison

Solution	Skill Discovery	Multi-Stage Expansion	Zero Dependencies	Customization	Chinese Support
Skill Router	🟢 Category × Stage matrix	🟢 Automatic pipeline expansion	🟢 Pure Markdown	🟢 Fully customizable	🟢 Native Chinese
Prompt Engineering	🟡 Depends on Prompt size	🔴 None	🟢	🟡 Requires Prompt modification	🟡
LangChain Tools	🟡 RouterChain	🟡 Requires manual definition	🔴 Heavy dependencies	🟡	🟡
CrewAI	🟢 Agent allocation	🟢	🔴 Python framework	🟢	🔴
AutoGen	🟢 Chat Router	🟢	🔴 Large framework	🟢	🔴

Skill Router's unique positioning: the lightest investment (5KB) in exchange for the greatest improvement in skill usage (+157%). It is not a universal framework, but it excels in the single dimension of "getting Agents to use the right skills."

9. Known Limitations and Future Directions

9.1 Current Limitations

Limitation	Description	Mitigation
Ambiguous intent	"Run an analysis" could mean finance, code, or design	Context memory + user confirmation modal
New skill discovery	Adding a new skill requires manually updating the routing table	`find-skills` automatic scan + suggestions
Cross-domain mixed tasks	"Build a stock analysis website" = finance + code	Priority ranking (currently based primarily on the first match)
Routing table bloat	The more skills there are, the larger the routing table becomes, and LLM matching accuracy decreases	Hierarchical routing (category first, then stage)

9.2 Future Directions

Dynamic routing weights. Automatically adjust priorities based on historical usage frequency.
Context-aware routing. Automatically correct ambiguous matches based on the topic history of the current conversation.
Routing feedback loop. When the Router makes an incorrect recommendation, user corrections automatically update routing rules.
Skill dependency graph. Automatically establish prerequisite/postrequisite relationships between skills, replacing manual pipeline definitions.

10. One-Line Installation

Skill Router can be installed on any OpenClaw Agent with one command:

mkdir -p skills/skill-router && curl -sSL https://raw.githubusercontent.com/Bryan-cmf/agentic-infrastructure/main/skill-router/SKILL.md -o skills/skill-router/SKILL.md

Then add the R0 mandatory pre-check rule at the top of AGENTS.md:

## 🔴 STEP -2: SKILL-ROUTER PRE-CHECK (MANDATORY)

That's it. Your Agent now has the ability to see a task and know which skill to use.

Conclusion: Why a 5KB File Can Solve the Scheduling Problem for 200+ Skills

The value of Skill Router is not in its technical complexity, but in the fact that it solves a meta-problem everyone has overlooked:

"The value of a tool ecosystem = number of tools × discovery rate"

200 skills, 35% discovery rate = 70 effective tools.
200 skills, 90% discovery rate = 180 effective tools.

In the same skill ecosystem, the actual capability gap before and after deploying Router is 2.6 times.

This is not a technical optimization. It is an asset activation.

Your skill library is the intellectual property you invested time to build. Without Router, 70% of that IP sits idle. Skill Router turns them from Markdown files on a hard drive into capabilities that are actually working.

"The best tool is not the one you spent the most time writing. It is the one that lets all the other tools be used correctly."

Production environment: The Junze Zhiku AI assistant (UltraClaw) runs on a Mac Studio M3 Ultra, with an ecosystem of 200+ skills, processing 20+ complex tasks daily. Since deployment, Skill Router has completed 500+ routing operations, and the manual intervention rate has fallen from 2-4 per task to below 0.5 per task.

License: Skill Router is open-sourced under the MIT License. Full technical documentation: GitHub - agentic-infrastructure/skill-router