llm-router

Make Claude Code, Codex, and Gemini CLI use the cheapest model that can still do the job well.
Save 35-80% on routine prompts, protect premium quota, and fall back automatically when providers fail.

Install in 30 seconds

pip install llm-routing   # PyPI name is llm-routing; the CLI command is llm-router

_{Works with Claude Code, Codex, and Gemini CLI · No API keys required on Claude Pro/Max}

Local-first. No hosted proxy. No account required.

Why People Install This

AI coding tools send too many prompts to premium models by default.

That means:

• You waste paid tokens on simple questions
• You burn through Claude, Gemini, or OpenAI quota faster than necessary
• You stop working when one provider is rate-limited or down

llm-router sits between your coding tool and your model providers. It classifies each prompt, tries the cheapest capable model first, and falls back automatically when needed.

You keep the same workflow. The router changes the model choice underneath.

On the RouterArena leaderboard

llm-router is independently benchmarked on RouterArena, a community leaderboard that scores model routers on an accuracy-versus-cost curve, plus optimality, robustness and latency. Rank moves as new routers land — see the live leaderboard for the current standing.

Quick Start

1. Install

pip install llm-routing
llm-router install

Package name: llm-routing on PyPI. CLI command: llm-router.

2. Add providers (optional)

export OPENAI_API_KEY="sk-..."          # GPT-4o, o3
export GEMINI_API_KEY="AIza..."         # Gemini Flash/Pro (free tier available)
export OLLAMA_BASE_URL="http://localhost:11434"  # Local models (free)
export OPENROUTER_API_KEY="sk-or-v1-…"  # 343 OpenRouter models (qwen, deepseek, grok, …)

Works with zero API keys on Claude Code Pro/Max subscriptions — routing uses MCP tools that call external models only when beneficial. Add OPENROUTER_API_KEY to unlock the open-weight workhorse pool used by the cost_aggressive policy.

3. Verify

llm-router health            # Check provider connectivity

If you already use Claude Code, Codex, or Gemini CLI, keep your existing workflow and let llm-router choose models underneath it.

Example Routing

The exact chain depends on your configured providers, budget profile, and routing policy.

Works With

• Full auto-routing means hooks intercept prompts and route automatically with no workflow change.
• Manual MCP tools means routing is available on demand through tools such as llm_query.

llm-router install                    # Claude Code (default)
llm-router install --host codex       # Codex CLI
llm-router install --host gemini-cli  # Gemini CLI
llm-router install --host vscode      # VS Code
llm-router install --host cursor      # Cursor

See guide/HOST_SUPPORT_MATRIX.md for full details on each host.

Protect your Claude Code 5-hour quota

enforce: smart + mode: zero_claude makes prompts either complete externally or stop before native Claude runs — see guide/GETTING_STARTED.md.

How It Works

User prompt
    │
    ▼
┌──────────────────────┐
│ Complexity Classifier │  ← Heuristic (free, instant) or Ollama/Flash ($0.0001)
└──────────┬───────────┘
           │
           ▼
┌──────────────────────┐
│  Free-First Router   │  ← Tries cheapest model first, walks up the chain
│                      │
│  Ollama (free)       │
│  → Codex (prepaid)   │
│  → Gemini Flash      │
│  → GPT-4o / Claude   │
└──────────┬───────────┘
           │
           ▼
┌──────────────────────┐
│  Guards (parallel)   │  ← Circuit breaker, budget pressure, quality check
└──────────┬───────────┘
           │
           ▼
      Response + cost logged to local SQLite

Classification is free for many tasks (regex heuristics catch ~70%) or near-free for ambiguous prompts when using local Ollama or Gemini Flash.

Features

Beyond "send cheap prompts to cheap models":

• Secrets never leave your machine. A prompt containing an API key, token or private key routes to local models only — fail-closed, so it cannot reach an external provider.
• Cost-inverted subscription routing. Free/local first for simple and moderate prompts, your one paid seat first for complex ones, and the seat demoted when its quota is strained. Opt in with LLM_ROUTER_SUBSCRIPTION_PROVIDER.
• Automatic fallback with circuit breakers. A provider that fails or rate-limits is skipped, not retried into the ground.
• You can see it working. A status line, terminal title and OS notification show the last model routed, savings and health — for hosts with no native statusline.
• Session-end summary. Savings vs baseline, tier mix, per-provider cost, latency p50/p95/p99 and top routes.
• Media and pipelines too. llm_image / llm_video / llm_audio, and llm_orchestrate for multi-step research.

CLI

llm-router install      # wire up your host (Claude Code by default)
llm-router health       # provider connectivity
llm-router status       # savings + quota at a glance
llm-router doctor       # diagnose a broken setup

Full command reference: guide/GETTING_STARTED.md

Providers

20+ providers, free-first. Ollama (local, free) leads the chain; OpenRouter (343 models behind one key) is the biggest single unlock; Gemini and Groq have usable free tiers. Anthropic works via your existing Claude subscription — no API key needed.

Every provider, its models, cost tier and env var: guide/PROVIDERS.md

Routing Policies

A policy sets how eagerly the router routes away from your premium model — conservative (10–15% savings) through balanced (the default, 35–45%) to cost_aggressive (70–85%, needs OPENROUTER_API_KEY).

llm-router policy set cost_aggressive

All six policies, thresholds and the YAML schema: guide/POLICIES.md

MCP Tools

60 tools across routing, analysis, code, media, budget and diagnostics — exposed to any MCP host. The default consolidated surface shows 11 front-door tools; set LLM_ROUTER_SLIM=full for all 60.

Every tool with its signature: guide/TOOLS.md

Savings: How It Works

Savings are calculated by comparing actual spend against a baseline of routing every task to Claude Sonnet/Opus.

Methodology:

1. Each routed task logs: model used, tokens consumed, estimated cost
2. A baseline cost is computed as if the same tokens were processed by the most expensive model in the chain
3. Savings = (baseline - actual) / baseline

Assumptions and limitations:

• Baseline assumes you would have used Opus/Sonnet for everything (worst case)
• Token estimates use len(text) / 4 approximation, not exact tokenizer counts
• Cost data comes from LiteLLM's pricing tables (may lag provider price changes)
• Savings vary significantly by workload — code-heavy sessions route more to cheap models
• The router itself adds small overhead (classification costs ~$0.0001 per ambiguous task)

Observed range: 35–80% savings depending on policy and task mix. The "87%" figure in some docs represents a single-user peak over a specific development period, not a guaranteed outcome.

Trust, Privacy, and Local-First Design

llm-router runs entirely on your machine. There is no hosted proxy, no telemetry, no account required.

What we do:

• Scrub API keys from structured logs
• Detect hook deadlocks before installation
• Store all data locally in ~/.llm-router/
• Respect provider rate limits and TOS

What you should know:

• Prompts are sent to whichever provider the router selects — review your provider's privacy policy
• Usage logs (SQLite) are not encrypted at rest — use full-disk encryption if needed
• The router cannot prevent model jailbreaks or prompt injection at the provider level

LLM_ROUTER_DIRECT_EXECUTION — read this before your first run

This is on by default. When enabled, hooks/auto-route.py tries to answer a prompt locally before Claude Code sees it. For prompts it classifies as needing file work, it runs a tool-calling agent loop that hands the local model three tools — write_file, edit_file and run_command — unsupervised, with no confirmation step, for up to 15 iterations. run_command executes through a shell.

What is actually enforced:

• write_file / edit_file are confined to the project root. This works as described.
• run_command is filtered by a small regex blocklist of top-level destructive patterns.

What that blocklist does not stop (measured, not estimated): targeted deletes inside the project (rm -rf ./src), $HOME deletes via shell expansion, git push --force, git reset --hard, arbitrary npm/pip install, reads outside the project (cat ../../.ssh/id_rsa), network exfiltration (curl -X POST … -d @.env), and echoing API keys. It stops catastrophic system damage — not project damage, credential disclosure, or exfiltration.

Turn it off:

export LLM_ROUTER_DIRECT_EXECUTION=false

Routing still works with it disabled; you lose only the local pre-answer path.

See SECURITY.md for the full analysis and the responsible disclosure policy.

Configuration

Everything is environment variables — no config file required to start:

export OPENROUTER_API_KEY="sk-or-v1-..."          # biggest single unlock
export OLLAMA_BASE_URL="http://localhost:11434"   # local, free
export LLM_ROUTER_POLICY="cost_aggressive"        # routing policy
export LLM_ROUTER_ENFORCE="smart"                 # off | advise | smart | hard

Full reference, config file schema and per-host overrides: guide/GETTING_STARTED.md

Documentation

Full index: guide/README.md

Enterprise

llm-router is built for individual developers and small teams: local cost savings, zero ops overhead, no hosted anything. If you need team-wide policy enforcement, audit export, SSO or per-org budgets, that is what Chuzom is for.

Contributing

Contributions welcome. See CONTRIBUTING.md for full guidelines.

git clone https://github.com/ypollak2/llm-router.git
cd llm-router
uv sync --extra dev
uv run pytest tests/ -q         # Run tests (1900+)
uv run ruff check src/ tests/   # Lint

-|-----------| | llm-routing | Current PyPI package (pip install llm-routing) | | llm-router | CLI command and GitHub repo name | | claude-code-llm-router | Deprecated legacy package (redirects to llm-routing) |

_{⭐ If llm-router saved you money, star the repo — it helps other developers discover it.}

Issues · Discussions · PyPI · Changelog

_{MIT License}