More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more
    RE

    Route Each Task to the Right Model

    1

    Your agent stops using one model for everything — easy work goes to a free local model, hard work escalates only when a check fails.

    $12

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    RE

    Route Each Task to the Right Model

    Example session with this skill installed

    Explain how to set up a Cascade tier that uses a local model for drafts and escalates to a hosted model if the response is too short or lacks a code block.

    • Read your context and instructions
    • Compiled the route each task

    To implement a Cascade tier, you must define the models in your modelrouter.yaml and set the escalation triggers. The router evaluates the first draft against your configured quality gates before deciding whether to call the stronger model.

    Cascade Configuration Example

    models:
      - id: llama3-local
        endpoint: http://localhost:11434/v1
        price_input: 0.0
        price_output: 0.0
      - id: gpt-4o
        endpoint: https://api.openai.com/v1
        key_env: OPENAI_API_KEY
        price_input: 5.0
        price_output: 15.0
    
    tiers:
      cascade:
        draft: llama3-local
        strong: gpt-4o
        gates:
          min_length: 50
          require_code: true
          refusal_patterns:
            - "as an ai"
            - "i cannot"
    
    policies:
      budget: 10.0
    

    The router will now process calls to model: "cascade". If llama3-local returns 30 characters or no triple-backtick code block, it automatically triggers a request to gpt-4o.

    Next steps

    1. Run python -m modelrouter serve to activate the endpoint.
    2. Monitor http://127.0.0.1:4000/ to see real-time escalation reasons.
    3. Test your gates using python -m modelrouter route --explain "Write a python script" --tier cascade.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Point an agent at one strong model and you pay strong-model prices to rename variables. Point it at one cheap model and hard problems get weak answers. This skill sets up modelrouter-ai, a free proxy I built, between your agent and your models. The agent sends one request; the router decides which model answers — a free local model, a cheap hosted one, or a strong one.

    Inside the package: the skill file covering install and configuration, a filled example config, and a routing-patterns reference that maps task types to the model each deserves — boilerplate and renames stay local, everyday feature work escalates on failure, subtle debugging and security review go to the strong tier. The proxy itself is free and MIT-licensed on GitHub; this package is the setup, the routing judgment, and the cost controls.

    A run goes like this: the router offers three patterns. Single — one model answers, no hidden fallback. Cascade — a cheap or local model drafts, simple quality checks judge the draft (empty answer, a refusal, code missing when code was asked for), and only a failed check escalates to the strong model, with the reason logged. Critique — a second model scores the draft and sends it back for revision below a score you set. Every call is priced from a table you control, and a daily budget cap warns at 80% and stops at 100%, so an agent loop can't burn a card overnight.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse All Claude Skills.

    Streaming is non-incremental until the full response is gated. Binds to 127.0.0.1; requires manual auth for remote access. Quality gates may cause double billing on high-effort escalations.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 6 days ago

    Accounts
    Ollama
    oran OpenAI-compatible API key
    Software
    Python 3.10+modelrouter-ai (free, MIT, OpenAI-compatible)

    Permissions

    Read Files
    Terminal / Shell
    Write Files
    Network Access
    Environment Variables
    Listed6 days ago

    What's inside

    Frequently Asked Questions

    This skill solves the 'one-size-fits-all' LLM problem by automatically routing simple tasks to cheap local models and saving expensive models for complex logic, all while enforcing budget caps to prevent runaway agent costs.

    It is compatible with any agent that supports custom OpenAI-compatible endpoints, including popular tools like Cursor, Claude Code, OpenCode, and custom Python-based agents.

    Yes, the router includes a 'Quality Gate' feature that scans for empty responses, missing code blocks, or refusals, automatically escalating the task to a more powerful model if the first attempt fails.

    You will receive the full modelrouter-ai implementation, a pre-configured `modelrouter.yaml` template, setup documentation, and access to the local monitoring dashboard for tracking real-time costs and routing decisions.

    Installation requires Python and Ollama (for local inference); you simply configure your API keys in the YAML file and point your agent's Base URL to the local proxy address.

    The router uses SHA-256 hashing for logs to track performance without storing raw prompt text, and it prioritizes local Ollama instances to ensure sensitive boilerplate code never leaves your machine.