New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

LLM Router

by jamesrochabrun in jamesrochabrun/skills

This skill should be used when users want to route LLM requests to different AI providers (OpenAI, Grok/xAI, Groq, DeepSeek, OpenRouter) using SwiftOpenAI-CLI.

MITAuto-check passedAI & LLM Engineering

Install LLM Router

skills CLI
$ npx skills add jamesrochabrun/skills --skill llm-router -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install jamesrochabrun/skills llm-router --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/jamesrochabrun/skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/llm-router .claude/skills/llm-router && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
llm-router
GitHub stars
216
Token cost
~3.3k tokens
SKILL.md length
948 words
Files
4 (incl. scripts, references)
Skills in repo
23
Repo updated
First seen
Licence
MIT

At a glance

This skill should be used when users want to route LLM requests to different AI providers (OpenAI, Grok/xAI, Groq, DeepSeek, OpenRouter) using SwiftOpenAI-CLI.

  • Works in 4 steps: Ensure SwiftOpenAI-CLI is Ready → Configure the Provider → Verify API Key → …
  • Users ask to use grok
  • SKILL.md covers Overview, Core Workflow, Usage Patterns and Provider-Specific Considerations, plus 3 more sections
  • Runs Shell scripts from its folder; needs XAI_API_KEY and OPENAI_API_KEY

What it does

LLM Router is an agent skill from jamesrochabrun/skills. This skill should be used when users want to route LLM requests to different AI providers (OpenAI, Grok/xAI, Groq, DeepSeek, OpenRouter) using SwiftOpenAI-CLI. Use this skill when users ask to "use grok", "ask grok", "use groq", "ask deepseek", or any similar request to query a specific LLM provider in agent mode.

Its SKILL.md is about 3.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files, including scripts and reference files (for example `references/providers.md`, `scripts/check_install_cli.sh` and `scripts/configure_provider.sh`).

It sits in AI & LLM Engineering, covering Model routing and gateways. It works with OpenAI, DeepSeek and OpenRouter. The licence is MIT.

When your agent uses it

  • Users ask to use grok
  • Any similar request to query a specific LLM provider in agent mode

Example prompts

  • “use grok”
  • “ask grok”
  • “use groq”
  • “/llm-router”

Requirements

  • Python 3
  • A Bash shell
  • A credential in XAI_API_KEY
  • A credential in GROQ_API_KEY

Workflow steps

4 steps, taken from the step headings in SKILL.md.

  1. Ensure SwiftOpenAI-CLI is Ready
  2. Configure the Provider
  3. Verify API Key
  4. Execute the Agentic Task

What it can do on your machine

Read from SKILL.md and the folder at commit 2482c17. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 2 files in scripts/ (Shell), which the agent can run.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • XAI_API_KEY
    • OPENAI_API_KEY
    • GROQ_API_KEY
    • DEEPSEEK_API_KEY
    • OPENROUTER_API_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

LLM Router loads about 3.3k tokens when it runs, and up to ~5.2k if it reads all its reference files. Until then it costs about 82 tokens; SKILL.md has 948 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~82
When it runs · the whole SKILL.md, loaded when a task matches
~3.3k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~5.2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from jamesrochabrun/skills at commit 2482c17, republished under its MIT licence (© jamesrochabrun). 948 words, ~3,305 tokens.

Download SKILL.mdSave it as .claude/skills/llm-router/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
name
llm-router
description
This skill should be used when users want to route LLM requests to different AI providers (OpenAI, Grok/xAI, Groq, DeepSeek, OpenRouter) using SwiftOpenAI-CLI. Use this skill when users ask to "use grok", "ask grok", "use groq", "ask deepseek", or any similar request to query a specific LLM provider in agent mode.

LLM Router

Overview

Route AI requests to different LLM providers using SwiftOpenAI-CLI's agent mode. This skill automatically configures the CLI to use the requested provider (OpenAI, Grok, Groq, DeepSeek, or OpenRouter), ensures the tool is installed and up-to-date, and executes one-shot agentic tasks.

Core Workflow

When a user requests to use a specific LLM provider (e.g., "use grok to explain quantum computing"), follow this workflow:

Step 1: Ensure SwiftOpenAI-CLI is Ready

Check if SwiftOpenAI-CLI is installed and up-to-date:

bash
scripts/check_install_cli.sh

This script will:

  • Check if swiftopenai is installed
  • Verify the version (minimum 1.4.4)
  • Install or update if necessary
  • Report the current installation status
Step 2: Configure the Provider

Based on the user's request, identify the target provider and configure SwiftOpenAI-CLI:

bash
scripts/configure_provider.sh <provider> [model]

Supported providers:

  • openai - OpenAI (GPT-4, GPT-5, etc.)
  • grok - xAI Grok models
  • groq - Groq (Llama, Mixtral, etc.)
  • deepseek - DeepSeek models
  • openrouter - OpenRouter (300+ models)

Examples:

bash
# Configure for Grok
scripts/configure_provider.sh grok grok-4-0709

# Configure for Groq with Llama
scripts/configure_provider.sh groq llama-3.3-70b-versatile

# Configure for DeepSeek Reasoner
scripts/configure_provider.sh deepseek deepseek-reasoner

# Configure for OpenAI GPT-5
scripts/configure_provider.sh openai gpt-5

The script automatically:

  • Sets the provider configuration
  • Sets the appropriate base URL
  • Sets the default model
  • Provides guidance on API key configuration
Step 3: Verify API Key

The configuration script automatically checks if an API key is set and will stop with clear instructions if no API key is found.

If API key is missing:

The script exits with error code 1 and displays:

  • ⚠️ Warning that API key is not set
  • Instructions for setting via environment variable
  • Instructions for setting via config (persistent)

Do not proceed to Step 4 if the configuration script fails due to missing API key.

Instead, inform the user they need to set their API key first:

Option 1 - Environment variable (session only):

bash
export XAI_API_KEY=xai-...           # for Grok
export GROQ_API_KEY=gsk_...          # for Groq
export DEEPSEEK_API_KEY=sk-...       # for DeepSeek
export OPENROUTER_API_KEY=sk-or-...  # for OpenRouter
export OPENAI_API_KEY=sk-...         # for OpenAI

Option 2 - Config file (persistent):

bash
swiftopenai config set api-key <api-key-value>

After the user sets their API key, re-run the configuration script to verify.

Step 4: Execute the Agentic Task

Run the user's request using agent mode:

bash
swiftopenai agent "<user's question or task>"

Agent mode features:

  • One-shot task execution
  • Built-in tool calling
  • MCP (Model Context Protocol) integration support
  • Conversation memory with session IDs
  • Multiple output formats

Examples:

bash
# Simple question
swiftopenai agent "What is quantum entanglement?"

# With specific model override
swiftopenai agent "Write a Python function" --model grok-3

# With session for conversation continuity
swiftopenai agent "Remember my name is Alice" --session-id chat-123
swiftopenai agent "What's my name?" --session-id chat-123

# With MCP tools (filesystem example)
swiftopenai agent "Read the README.md file" \
  --mcp-servers filesystem \
  --allowed-tools "mcp__filesystem__*"

Usage Patterns

Pattern 1: Simple Provider Routing

User Request: "Use grok to explain quantum computing"

Execution:

bash
# 1. Check CLI installation
scripts/check_install_cli.sh

# 2. Configure for Grok
scripts/configure_provider.sh grok grok-4-0709

# 3. Execute the task
swiftopenai agent "Explain quantum computing"
Pattern 2: Specific Model Selection

User Request: "Ask DeepSeek Reasoner to solve this math problem step by step"

Execution:

bash
# 1. Check CLI installation
scripts/check_install_cli.sh

# 2. Configure for DeepSeek with Reasoner model
scripts/configure_provider.sh deepseek deepseek-reasoner

# 3. Execute with explicit model
swiftopenai agent "Solve x^2 + 5x + 6 = 0 step by step" --model deepseek-reasoner
Pattern 3: Fast Inference with Groq

User Request: "Use groq to generate code quickly"

Execution:

bash
# 1. Check CLI installation
scripts/check_install_cli.sh

# 2. Configure for Groq (known for fast inference)
scripts/configure_provider.sh groq llama-3.3-70b-versatile

# 3. Execute the task
swiftopenai agent "Write a function to calculate fibonacci numbers"
Pattern 4: Access Multiple Models via OpenRouter

User Request: "Use OpenRouter to access Claude"

Execution:

bash
# 1. Check CLI installation
scripts/check_install_cli.sh

# 2. Configure for OpenRouter
scripts/configure_provider.sh openrouter anthropic/claude-3.5-sonnet

# 3. Execute with Claude via OpenRouter
swiftopenai agent "Explain the benefits of functional programming"

Provider-Specific Considerations

OpenAI (GPT-5 Models)

GPT-5 models support advanced parameters:

bash
# Minimal reasoning for fast coding tasks
swiftopenai agent "Write a sort function" \
  --model gpt-5 \
  --reasoning minimal \
  --verbose low

# High reasoning for complex problems
swiftopenai agent "Explain quantum mechanics" \
  --model gpt-5 \
  --reasoning high \
  --verbose high

Verbosity levels: low, medium, high Reasoning effort: minimal, low, medium, high

Grok (xAI)

Grok models are optimized for real-time information and coding:

  • grok-4-0709 - Latest with enhanced reasoning
  • grok-3 - General purpose
  • grok-code-fast-1 - Optimized for code generation
Groq

Known for ultra-fast inference with open-source models:

  • llama-3.3-70b-versatile - Best general purpose
  • mixtral-8x7b-32768 - Mixture of experts
DeepSeek

Specialized in reasoning and coding:

  • deepseek-reasoner - Advanced step-by-step reasoning
  • deepseek-coder - Coding specialist
  • deepseek-chat - General chat
OpenRouter

Provides access to 300+ models:

  • Anthropic Claude models
  • OpenAI models
  • Google Gemini models
  • Meta Llama models
  • And many more

API Key Management

The best practice for using multiple providers is to set all API keys as environment variables. This allows seamless switching between providers without reconfiguring keys.

Add to your shell profile (~/.zshrc or ~/.bashrc):

bash
# API Keys for LLM Providers
export OPENAI_API_KEY=sk-...
export XAI_API_KEY=xai-...
export GROQ_API_KEY=gsk_...
export DEEPSEEK_API_KEY=sk-...
export OPENROUTER_API_KEY=sk-or-v1-...

After adding these, reload your shell:

bash
source ~/.zshrc  # or source ~/.bashrc

How it works:

  • SwiftOpenAI-CLI automatically uses the correct provider-specific key based on the configured provider
  • When you switch to Grok, it uses XAI_API_KEY
  • When you switch to OpenAI, it uses OPENAI_API_KEY
  • No need to reconfigure keys each time
Show full SKILL.md (385 more words)Show less

If you only use one provider, you can store the key in the config file:

bash
swiftopenai config set api-key <your-key>

Limitation: The config file only stores ONE api-key. If you switch providers, you'd need to reconfigure the key each time.

Checking Current API Key
bash
# View current configuration (API key is masked)
swiftopenai config list

# Get specific API key setting
swiftopenai config get api-key

Priority: Provider-specific environment variables take precedence over config file settings.

Advanced Features

Interactive Configuration

For complex setups, use the interactive wizard:

bash
swiftopenai config setup

This launches a guided setup that walks through:

  • Provider selection
  • API key entry
  • Model selection
  • Debug mode configuration
  • Base URL setup (if needed)
Session Management

Maintain conversation context across multiple requests:

bash
# Start a session
swiftopenai agent "My project is a React app" --session-id project-123

# Continue the session
swiftopenai agent "What framework did I mention?" --session-id project-123
MCP Tool Integration

Connect to external services via Model Context Protocol:

bash
# With GitHub MCP
swiftopenai agent "List my repos" \
  --mcp-servers github \
  --allowed-tools "mcp__github__*"

# With filesystem MCP
swiftopenai agent "Read package.json and explain dependencies" \
  --mcp-servers filesystem \
  --allowed-tools "mcp__filesystem__*"

# Multiple MCP servers
swiftopenai agent "Complex task" \
  --mcp-servers github,filesystem,postgres \
  --allowed-tools "mcp__*"
Output Formats

Control how results are presented:

bash
# Plain text (default)
swiftopenai agent "Calculate 5 + 3" --output-format plain

# Structured JSON
swiftopenai agent "List 3 colors" --output-format json

# Streaming JSON events (Claude SDK style)
swiftopenai agent "Analyze data" --output-format stream-json

Troubleshooting

Common Issues

Issue: "swiftopenai: command not found"

Solution: Run the check_install_cli.sh script, which will install the CLI automatically.

Issue: Authentication errors

Solution: Verify the correct API key is set for the provider:

bash
# Check current config
swiftopenai config list

# Set the appropriate API key
swiftopenai config set api-key <your-key>

# Or use environment variable
export XAI_API_KEY=xai-...  # for Grok

Issue: Model not available

Solution: Verify the model name matches the provider's available models. Check references/providers.md for correct model names or run:

bash
swiftopenai models

Issue: Rate limiting or quota errors

Solution: These are provider-specific limits. Consider:

  • Using a different model tier
  • Switching to a different provider temporarily
  • Checking your API usage dashboard
Debug Mode

Enable debug mode to see detailed HTTP information:

bash
swiftopenai config set debug true

This shows:

  • HTTP status codes and headers
  • API request details
  • Response metadata

Resources

This skill includes bundled resources to support LLM routing:

scripts/
  • check_install_cli.sh - Ensures SwiftOpenAI-CLI is installed and up-to-date
  • configure_provider.sh - Configures the CLI for a specific provider
references/
  • providers.md - Comprehensive reference on all supported providers, models, configurations, and capabilities

Best Practices

  1. Always check installation first - Run check_install_cli.sh before routing requests
  2. Configure provider explicitly - Use configure_provider.sh to ensure correct setup
  3. Verify API keys - Check that the appropriate API key is set for the target provider
  4. Choose the right model - Match the model to the task (coding, reasoning, general chat)
  5. Use sessions for continuity - Leverage --session-id for multi-turn conversations
  6. Enable debug mode for troubleshooting - When issues arise, debug mode provides valuable insights
  7. Reference provider documentation - Consult references/providers.md for detailed provider information

Examples

Example 1: Routing to Grok for Real-Time Information
bash
# User: "Use grok to tell me about recent AI developments"

scripts/check_install_cli.sh
scripts/configure_provider.sh grok grok-4-0709
swiftopenai agent "Tell me about recent AI developments"
Example 2: Using DeepSeek for Step-by-Step Reasoning
bash
# User: "Ask deepseek to explain how to solve this algorithm problem"

scripts/check_install_cli.sh
scripts/configure_provider.sh deepseek deepseek-reasoner
swiftopenai agent "Explain step by step how to implement quicksort"
Example 3: Fast Code Generation with Groq
bash
# User: "Use groq to quickly generate a REST API"

scripts/check_install_cli.sh
scripts/configure_provider.sh groq llama-3.3-70b-versatile
swiftopenai agent "Generate a REST API with authentication in Python"
Example 4: Accessing Claude via OpenRouter
bash
# User: "Use openrouter to access claude and write documentation"

scripts/check_install_cli.sh
scripts/configure_provider.sh openrouter anthropic/claude-3.5-sonnet
swiftopenai agent "Write comprehensive documentation for a todo app API"
Example 5: GPT-5 with Custom Parameters
bash
# User: "Use gpt-5 with high reasoning to solve this complex problem"

scripts/check_install_cli.sh
scripts/configure_provider.sh openai gpt-5
swiftopenai agent "Design a distributed caching system" \
  --model gpt-5 \
  --reasoning high \
  --verbose high

© jamesrochabrun, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 3 other files (scripts, references) in skills/llm-router of jamesrochabrun/skills.

  • SKILL.md
  • references/providers.md
  • scripts/check_install_cli.sh
  • scripts/configure_provider.sh

Open the folder on GitHubat commit 2482c17

Compare with similar skills

LLM Router next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

LLM Router compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
LLM Router this skilljamesrochabrun/skills216—~3.3kAutomated safety check: PassMIT
Configuring Visionoxbshw/watch-skill469—~509Automated safety check: NotesMIT
OpenCode Agent Provider for NanoClawnanocoai/nanoclaw31k—~5kAutomated safety check: NotesMIT
Embeddings via 9Routerdecolua/9router30k—~604Automated safety check: PassMIT
Using Ccproxy Inspectorstarbaser/ccproxy350—~2.7kAutomated safety check: PassCustom licence
Mecatl Model Router Configstacklok/mecatl250—~2.7kAutomated safety check: PassApache-2.0

Similar skills

  • Configuring Vision

    oxbshw/watch-skill

    The user wants to connect an LLM or vision provider, already has an API key, asks "can I use OpenAI/Anthropic/Gemini/OpenRouter", wants local Ollama, or needs different cheap and strong models.

    469 GitHub stars~509 tokensUpdated 25 days ago
    AI & LLM EngineeringAuto-check: notes

  • OpenCode Agent Provider for NanoClaw

    nanocoai/nanoclaw

    Installs OpenCode as an optional NanoClaw agent runtime, reaching OpenRouter, OpenAI, Google, DeepSeek and others through OpenCode's own configuration.

    31k GitHub stars~5k tokensUpdated 3 days ago
    AI & LLM EngineeringAuto-check: notes

  • Embeddings via 9Router

    decolua/9router

    Generates vector embeddings through the 9Router /v1/embeddings endpoint, using models from providers such as OpenAI, Gemini, Mistral and Voyage for RAG and semantic search.

    30k GitHub stars~604 tokensUpdated yesterday
    AI & LLM EngineeringAuto-check passed

  • Using Ccproxy Inspector

    starbaser/ccproxy

    Operates the ccproxy inspector MITM system for intercepting, inspecting, and transforming LLM API traffic.

    350 GitHub stars~2.7k tokensUpdated 2 mo ago
    AI & LLM EngineeringAuto-check passed

  • Mecatl Model Router Config

    stacklok/mecatl

    Interviews you about provider, cost, openness and image needs, then designs the models section of a mecatl settings file with aliases, slots and router categories.

    250 GitHub stars~2.7k tokensUpdated today
    AI & LLM EngineeringAuto-check passed

  • Using Ccproxy API

    starbaser/ccproxy

    Guides users through ccproxy as an OpenAI-compatible and Anthropic-compatible LLM API server with SDK integration, OAuth authentication, sentinel key substitution, model routing, and troubleshooting.

    350 GitHub stars~4k tokensUpdated 2 mo ago
    AI & LLM EngineeringAuto-check passed

More from jamesrochabrun/skills

All 23 skills in this repo

  • Prd Generator

    jamesrochabrun/skills

    Generate comprehensive Product Requirements Documents (PRDs) for product managers.

    216 GitHub starsUsed in 2 repos~3.8k tokens
    Auto-check passed

  • Technical Launch Planner

    jamesrochabrun/skills

    Plan and execute technical product launches for developer tools, APIs, and technical products.

    216 GitHub starsUsed in 1 repo~3.8k tokens
    Auto-check passed

  • Design Brief Generator

    jamesrochabrun/skills

    Generate comprehensive design briefs for design projects. An agent skill from jamesrochabrun/skills.

    216 GitHub stars~3.3k tokensUpdated 8 mo ago
    Auto-check passed

  • Git Worktrees

    jamesrochabrun/skills

    Manage Git worktrees for parallel Claude Code development. An agent skill from jamesrochabrun/skills.

    216 GitHub stars~4.2k tokensUpdated 8 mo ago
    Auto-check passed

  • Content Brief Generator

    jamesrochabrun/skills

    Generate comprehensive content briefs for writers, ensuring clarity, alignment, and strategic content creation across all formats.

    216 GitHub starsUsed in 1 repo~2.9k tokens
    Auto-check passed

  • Swiftui Animation

    jamesrochabrun/skills

    This skill provides comprehensive guidance for implementing advanced SwiftUI animations, transitions, matched geometry effects, and Metal shader integration.

    216 GitHub starsUsed in 1 repo~1.6k tokens
    Auto-check passed

Works with

Categories

Questions about LLM Router

What does LLM Router do?

This skill should be used when users want to route LLM requests to different AI providers (OpenAI, Grok/xAI, Groq, DeepSeek, OpenRouter) using SwiftOpenAI-CLI. LLM Router is an agent skill from jamesrochabrun/skills. This skill should be used when users want to route LLM requests to different AI providers (OpenAI, Grok/xAI, Groq, DeepSeek, OpenRouter) using SwiftOpenAI-CLI.

When should I use LLM Router?

LLM Router fits situations like: users ask to use grok; any similar request to query a specific LLM provider in agent mode.

How do I install LLM Router in Claude Code?

Run `npx skills add jamesrochabrun/skills --skill llm-router -a claude-code`. Or copy the skill folder (skills/llm-router in jamesrochabrun/skills) into .claude/skills/llm-router in your project. Claude Code loads it when a task matches its description.

How do I install LLM Router in Codex?

Run `npx skills add jamesrochabrun/skills --skill llm-router -a codex`. Or copy the skill folder (skills/llm-router in jamesrochabrun/skills) into .agents/skills/llm-router in your project. Codex loads it when a task matches its description.

Can I use LLM Router in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add jamesrochabrun/skills --skill llm-router -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/llm-router, .gemini/skills/llm-router, .github/skills/llm-router and .opencode/skills/llm-router in your project.

What does LLM Router need to run?

Going by SKILL.md and its folder, LLM Router needs a shell for the scripts in its folder and credentials named XAI_API_KEY, OPENAI_API_KEY, GROQ_API_KEY and DEEPSEEK_API_KEY. Our summary lists: Python 3; A Bash shell; A credential in XAI_API_KEY; A credential in GROQ_API_KEY.

Does LLM Router access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is LLM Router safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does LLM Router use?

LLM Router is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does LLM Router use?

About 3.3k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.9k tokens, read only when the agent opens those files.

What are the alternatives to LLM Router?

Skills that share tags, products or a category with LLM Router: Configuring Vision (oxbshw/watch-skill, 469 stars), OpenCode Agent Provider for NanoClaw (nanocoai/nanoclaw, 31k stars), Embeddings via 9Router (decolua/9router, 30k stars) and Using Ccproxy Inspector (starbaser/ccproxy, 350 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains LLM Router?

jamesrochabrun (a GitHub user) maintains it in jamesrochabrun/skills, which has 216 GitHub stars. The repository holds 23 skills in this directory. The repository was last updated on January 14, 2026.

Source: jamesrochabrun/skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.