Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    RouteNex AI Gateway — Zero-429 & Token Optimizer

    1

    Stop losing coding sessions to mid-refactor `HTTP 429 Too Many Requests` errors and runaway token bills.

    Free

    Security scanned
    RouteNex AI Gateway — Zero-429 & Token Optimizer

    RouteNex AI Gateway — Zero-429 & Token Optimizer

    Example session with this skill installed

    Set up RouteNex (`npx routenex`) for my Claude Code and Cursor workflow so I never hit HTTP 429 rate limits, enable the 4-stage Token Optimizer (`LogPrune` + `TurnDedup`), and run a live test against `auto:balanced` and `worker/pr-guardian` to show me the token savings.

    • Read your context and instructions
    • Compiled the routenex ai gateway

    ## Summary Launched the local **RouteNex AI Gateway (`v0.2.3`)** on `http://localhost:3001`, configured both **Claude Code** (`/v1/messages`) and **Cursor** (`/v1/chat/completions`) endpoints, and verified the 4-stage Token Optimizer and `worker/pr-guardian` Action Shield pipeline. | Metric / Capability | Before RouteNex | After RouteNex (`npx routenex`) | | :--- | :--- | :--- | | **Rate Limit Handling (`HTTP 429`)** | Session aborts on single-key 429 | Zero-downtime key rotation + multi-provider Smart Combo failover | | **Prompt & Log Token Footprint** | `4,280` raw tokens (uncompressed stack trace + multi-turn history) | `1,640` tokens (`-61.7%` saved via `LogPrune` + `TurnDedup` + `LexiPack`) | | **Protocol Compatibility** | Locked to a single vendor endpoint | Unified OpenAI (`/v1/chat/completions`), Anthropic (`/v1/messages`), & Gemini (`/v1beta`) | | **Autonomous Worker Guardrails** | Unsupervised tool execution | `worker/pr-guardian` gated by **Action Shield** (`auto:free` policy guard in `22ms`) | ### Applied Client Configuration ```bash # 1. Start the RouteNex Gateway & Studio Control Plane npx routenex@latest # 2. Connect Claude Code (Native Anthropic /v1/messages Protocol) export ANTHROPIC_BASE_URL="http://localhost:3001" export ANTHROPIC_API_KEY="routenex-local" # 3. Connect Cursor / Codex CLI / Cline (OpenAI /v1 Protocol) export OPENAI_BASE_URL="http://localhost:3001/v1" export OPENAI_API_KEY="routenex-local"

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

    About this skill

    Stop losing coding sessions to mid-refactor `HTTP 429 Too Many Requests` errors and runaway token bills. **RouteNex AI Gateway (`routenex-llm-gateway`)** teaches your AI coding agent (Claude Code, Cursor, Codex CLI, Cline, Windsurf, or Gemini CLI) how to launch, configure, and route traffic through **[RouteNex](https://github.com/harshil1876/RouteNex)** (`npx routenex`)—an open-source (MIT), local-first AI Gateway, 4-Stage Token Optimizer, and Autonomous Worker Control Plane. ### What Problem Does This Skill Solve? 1. **Eliminates Mid-Session 429 Rate Limits & Outages**: Pools multiple API keys or OAuth sessions per provider and automatically fails over across 38+ LLM providers (`OpenAI`, `Anthropic`, `Google Gemini`, `Groq`, `DeepSeek`, `OpenRouter`, `Ollama`, and zero-key free gateways) with circuit breakers and exponential cooldowns. 2. **Cuts Prompt Token Costs by 40%–70%**: Automatically runs every prompt and tool output through RouteNex's 4-stage lossless compression pipeline: - **Stage 1 (Whitespace & Comment Normalization)**: Strips redundant prompt whitespace while keeping code blocks untouched. - **Stage 2 (`LogPrune`)**: Truncates massive stack traces and terminal build logs, stripping ANSI escape codes and collapsing repeated lines. - **Stage 3 (`TurnDedup`)**: Deduplicates repeated system instructions and identical tool outputs across multi-turn agent loops. - **Stage 4 (`LexiPack`)**: Compresses conversational filler while preserving fenced code blocks (` ``` `), JSON schemas, and URLs byte-for-byte. 3. **Adaptive Param Shield**: Intercepts `HTTP 400` unsupported parameter errors (such as `reasoning_effort` or `top_k` mismatches across providers), strips the unsupported field, retries transparently, and remembers the rule. 4. **Autonomous Specialist Workers (`NexWorkers`) with Action Shield**: Exposes pre-configured background workers as standard model IDs (`worker/pr-guardian`, `worker/inbox-triage`, `worker/cost-watchdog`, `worker/release-architect`) guarded by plain-English safety rules and human-in-the-loop approval cards. ### What Your Agent Will Do With This Skill - Verify your Node.js (`>=20.0.0`) environment and launch the local gateway via `npx routenex@latest` on `http://localhost:3001`. - Configure `ANTHROPIC_BASE_URL` (for Claude Code) or `OPENAI_BASE_URL` (for Cursor, Codex CLI, Cline, or custom SDKs). - Run a live diagnostic probe and report your active upstream provider, latency, and exact percentage of tokens saved via `X-RouteNex-Tokens-Saved`.

    Requires Node.js >= 20.0.0 on the local machine to run the RouteNex gateway daemon on port 3001. Zero-key free models (auto:free) work immediately out of the box; routing to paid frontier models (Anthropic, OpenAI, Gemini, Groq, DeepSeek) requires adding your own API keys or OAuth sessions inside the local AES-256-GCM encrypted RouteNex Studio keystore.

    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 any payment.

    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

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 5 days ago

    • Free with an Agensi account

    Requires

    GitHub
    Anthropic
    OpenAI
    Npmjs
    routenex
    Node.js
    npx

    Permissions

    Network Access
    Environment Variables
    Terminal / Shell
    Read Files

    Allowed Hosts

    api.github.com
    api.anthropic.com
    api.openai.com
    github.com
    npmjs.com
    anthropic.com
    openai.com

    File Scopes

    .env*
    ~/.routenex/**

    Terminal/Shell and Network Access (localhost:3001) are used to launch the open-source RouteNex gateway via npx routenex and verify health and token compression headers. Environment Variables configure ANTHROPIC_BASE_URL or OPENAI_BASE_URL for your coding agent after your confirmation.

    Listed5 days ago

    What's inside

    Frequently Asked Questions

    The skill addresses two major bottlenecks in AI development: high token costs and '429 Rate Limit Exceeded' errors. It solves these by compressing redundant prompt data and automatically rotating between multiple API keys to ensure your workflow is never interrupted.

    This skill is fully compatible with popular AI-native coding tools including Claude Code, Cursor, Cline, Continue, and Windsurf. It works by routing their traffic through a local gateway that supports OpenAI, Anthropic, and Google Gemini SDKs.

    Setup is straightforward: once the skill initializes the local gateway via npx, you simply point your coding tool's base URL to your localhost. The skill handles the environment variable configuration and provider routing logic automatically.

    The 4-stage optimization uses techniques like whitespace normalization and 'TurnDedup' to remove redundant agent loops and stack trace bloat. Depending on the density of your prompts and logs, you can expect to see an API cost reduction between 40% and 70%.

    You receive the complete configuration for the RouteNex local gateway, including pre-defined routing strategies (like 'auto:nitro') and the Adaptive Param Shielding logic. The purchase also includes access to autonomous NexWorkers for background tasks like PR reviews.

    Yes, the skill requires Node.js 20 or higher to be installed on your local machine. Because it functions as a local-first gateway, it does not require external cloud infrastructure, keeping your API keys and data on your own hardware.

    Yes. RouteNex is 100% open-source under the MIT license (github.com/harshil1876/RouteNex). All API keys and OAuth tokens are encrypted at rest on your own machine using AES-256-GCM and stored locally in SQLite WAL—never sent to any third-party cloud.

    RouteNex runs a 4-stage deterministic Token Optimizer (Whitespace Normalization, LogPrune stack-trace truncation, TurnDedup multi-turn deduplication, and LexiPack filler compression) that strictly preserves fenced code blocks, inline code, JSON schemas, and URLs byte-for-byte.

    New in LLM Ops