A live router, not a mock-up
Every request is classified in about half a second, every model is priced for this request at what it actually costs including the risk of having to redo it, and the cheapest expected total wins. Then the answer streams back from whichever model that turned out to be — and if it came from a cheap one, Jev checks it before you see it.
Run it on your own machine
curl -fsSL whichmodel.app.mintapis.com/install.sh | sh
Free and MIT-licensed. Put it in front of Claude Code, Codex, opencode or Cursor: easy turns go to cheap models on your own key, and your Claude or ChatGPT plan's limits are left for the work that needs them. Setup for each tool.
Waiting for the candidates…
| Model | Capabilityin this topic | Price / 1Min · out · cache read | P(success)measured | This turncall cost | Expected timeto a finished answer | Expectedincl. risk and waiting |
|---|
The part most routers get wrong
A provider that has already read your conversation bills the next turn at roughly a tenth of the input price. Move to another model and the whole prefix is written again at full price. So the question at every turn is not "which model is best" but "is the better model worth leaving a warm cache for" — and the answer changes as the clock runs out on the cache.
This is the live policy object answering a question instead of a request — the only honest way to show what a 100k-token agent prefix does to a decision without paying for one. The free endpoints are hidden by default: a free route has no cache price, so with them in the catalog there is nothing to trade off.
| Route | Cache | This turn, staying | This turn, cold | The cache is worth | Expected total |
|---|
Only the clock changes between these rows. When the cache expires, staying stops being worth anything and the decision flips.
A real conversation with a pasted document, routed turn by turn by the same router. Every answer is really generated; the strip under each one is what the router decided and why. Use the pause control to make the clock jump before you send.
Measured, 17–18 September 2026
Eight models on 78 graded tasks, a replay of one week of real coding-agent traffic (1,638 sessions, 57,696 calls, 8.7 billion input tokens of which 96 % were cache reads), and a live run of the router itself. Read the dollar columns as arithmetic: real traffic and measured success rates priced at public list prices. No invoice was compared. No money was saved and none was measured.
Loading the numbers…
How it works
One call to Jev, TypeSafe's System One model, on a scrubbed and truncated summary of the turn — never the raw prompt. It answers typed questions with calibrated probabilities: topic, difficulty, whether tools or a long context are needed, whether this builds on the previous turn, and how costly a subtly wrong answer would be. About 0.65 s. On our 78 tasks it named the topic correctly every time, and its difficulty score predicted which tasks a cheap model would fail better than the task's own difficulty label did.
The catalog is not a hard-coded price list. Every model is looked up in the Benchmark Heaven API: capability per topic, list price per offer including the cache read and cache write price, context length, and a benchmaxxing penalty — each number carrying its basis and how strong that basis is. Cached locally with a TTL, so a benchmark site being down never takes routing down.
Capability read from benchmark headlines mis-ranks specific models and effort levels. Where we have measured a model on a topic and difficulty, the measurement wins. That single change was worth three points of task success and cut spend to a third in the replay.
For each candidate: what this turn costs there given what it still holds in cache, times the chance it gets the turn right, plus what a failure would cost — a retry on a stronger model if the failure is noticed, the price of a wrong answer if it is not. Lowest total wins. Inside an agent's tool loop the router never switches, because that throws away a cache that is seconds old.
Only a cheap one. Jev is not stronger than a frontier model, so grading one would produce false alarms rather than quality — and a question about a document Jev was never shown cannot be graded at all. But a small model's answer to a self-contained request is a different question, and a measured one: one typed question, about 0.7 s, 85 % of wrong coding answers caught at a 10 % false-alarm rate and 73 % of wrong maths answers at none. A rejected answer is re-run on the cheapest route at least four capability points stronger; you see the first answer collapsed above the second, and the chip says what Jev objected to. Across 192 cheap answers that lifted correctness from 76 % to 85 % at about $0.03 a rescue.
This is also why the candidate table marks some rows judged: a route whose failures get caught for a fraction of a cent is worth more than one whose failures reach you, and that is already priced into its expected cost.
The router is an OpenAI-compatible proxy — point any tool that speaks
/v1/chat/completions at it, or Claude Code at its Anthropic endpoint, and it
routes per user turn with your own keys and no caps. One command installs it:
curl -fsSL https://whichmodel.app.mintapis.com/install.sh | shRun it yourself — the whole recipe
Per-tool configuration for Claude Code, opencode, Cursor and the rest, a prompt you can paste into a coding agent to have it set all of this up, and what is and is not possible with a flat-rate subscription: all on that page.
A router should not care whether a model runs in a data centre or in somebody's browser. The Bonsai swarm is a set of volunteers running a ternary 27B model on WebGPU, reachable over the same OpenAI-compatible shape as every other provider. It enters the catalog with a price of zero, a small context window, no prefix cache and a modest capability — and then competes on those numbers. It wins easy and medium turns and loses hard ones, which is exactly what an expected-cost rule should do with a cheap, slow, best-effort route.
Read live from the benchmark API when the demo started. The last column is the exact
basis of that model's coding capability — hover it for every other topic. Every route in
here is one you could use yourself today: an OpenRouter public endpoint at its public
price, including the :free ones, or the peer-to-peer swarm. There is nothing
in this catalog that depends on an account you cannot get.
| Model | Context | Price / 1M in · out · cache read | Cache TTL · hit rate | Capability basis |
|---|
This demo, the router and the model data behind it are a one-person hobby project, and the servers and model calls are paid out of pocket. If it saved you money or time, you can support this project with whatever amount you like. Payments go to productivity-boost.com Betriebs UG (haftungsbeschränkt) & Co. KG, the one-person company behind these projects.
Run it yourself
Everything on this site runs on your own machine: an OpenAI-compatible endpoint on
127.0.0.1, your keys, your bill, no limits and no demo caps. Jev
classifies each turn, Benchmark Heaven prices every candidate for it, and the
expected-cost rule picks one — in front of whatever tool you already use.
curl -fsSL https://whichmodel.app.mintapis.com/install.sh | shPiping an installer into a shell is a thing you should be suspicious of, so read it first — it is about 360 lines, most of them the two starter configs. It needs Python 3.10+ and git, asks for no privileges, installs nothing system-wide, and touches only these five things:
~/.auto-router/src — a clone of
auto-model-router (MIT).~/.auto-router/venv — a virtualenv with its four dependencies.~/.auto-router/config.yaml — a starter catalog, if you have none: cheap and
free routes, Claude Opus 5, and the two frontier models (Claude Fable 5.1, GPT-6 Astra).
Keys are referenced by environment-variable name; none is ever written to it.~/.auto-router/launcher.yaml — the job launcher's config (Codex on your
ChatGPT plan, Claude Code on your Claude plan, a cheap model through opencode).~/.local/bin/auto-router — one command.Then give it a key and start it:
export OPENROUTER_API_KEY=... # or edit ~/.auto-router/config.yaml for your own providers
export TYPESAFE_API_KEY=... # optional: Jev. Without it a cautious default is used.
auto-router # serves http://127.0.0.1:8787/v1
auto-router check # in a second terminal: proves it answers and routes
auto-router check sends one tiny request and prints the model the router
chose and why. If it says OK, every tool below will work.
GET /health answers when it is up, GET /v1/models shows what it
knows about each route, and GET /v1/router/decisions gives you the last
decisions with the numbers behind them — the same record this site draws.
Four ways, and they do different things. All are within what Anthropic and OpenAI document for their clients; what neither allows is also said below, so nobody gets surprised.
auto-router # terminal 1: the router
auto-router switch # terminal 2: instead of `claude`
Claude Code starts on cheap models through the router. Before each prompt the router
decides; when your Claude plan is the better choice, Claude Code restarts signed in with
your plan, straight to Anthropic, and resumes the same conversation. A cheap model that
gets stuck mid-task is handed over the same way. ~plan / ~cheap
at the start of a prompt decides it yourself.
The router never sees your plan's login: in plan mode it is not in the path at all.
Automatic switching to the plan needs a usage reader (usage_command in
~/.auto-router/config.yaml), so the router knows how full your plan is;
until then ~plan works. Switching is not free (the new side reads the
conversation cold), so it stays on the plan once there unless a prompt is clearly easy.
claude mcp add auto-router-delegate -- auto-router delegate
codex mcp add auto-router-delegate -- auto-router delegate
Adds one tool, delegate, to Claude Code or Codex running normally on your
plan. The model hands a self-contained sub-task to the cheapest route that can do it and
checks the result itself.
Measured: it pays off for big, separable sub-tasks. On small ones the plan model's own
overhead dominates and plan use stays about the same. Tell the model to use it
(“you are the orchestrator; delegate the implementation”): with a soft hint it rarely
does. For codex exec, set default_tools_approval_mode = "approve"
on the server.
auto-router claudeStarts Claude Code with the router as its gateway and a local gateway credential. Each turn goes to whichever model the router picks — a free or cheap model for the easy ones, Opus 5 or Fable 5.1 for the hard ones — and is paid per token on your OpenRouter key.
Your Claude plan is not used for that session at all, so its usage limits stay untouched. Anthropic's gateway page: “the credential replaces the subscription login for that session, and the subscription's usage limits don't apply”. Anthropic does not support routing Claude Code to non-Claude models, so if a Claude Code update breaks something, that is ours to fix, not theirs.
auto-router run --dry-run "fix the flaky upload test" # which tool, and why
auto-router run "fix the flaky upload test" # then start it
The router picks which program does the job and starts it as its vendor
ships it: codex exec signed in to your ChatGPT plan,
claude -p signed in to your Claude plan, or a cheap model through
opencode. It never touches their traffic, never reads a login token, and clears
OPENAI_API_KEY / ANTHROPIC_API_KEY for the child so a
stray key cannot silently turn a plan run into a per-token bill.
It paces the plans: a plan is only used below a weekly reserve and never above 80 %
of the week, so easy jobs go to cheap models and the plan is kept for the jobs that
need it. Codex reports its own usage, so that plan works out of the box; for
Claude, point usage_command in ~/.auto-router/launcher.yaml
at something that prints your usage, or the Claude plan stays closed.
Not allowed, and not done here: taking a plan's login token out of the official client to use it from other software, or serving anyone else's requests from your personal plan. Anthropic does not permit developers “to route requests through Free, Pro, or Max plan credentials on behalf of their users”. Your plan, your machine, your own work. The details, with the vendors' own words.
Each configuration was run against a router installed by the command above on a clean
machine (18 September 2026); the installer, auto-router check and the job
launcher were re-run on a clean container on 19 September. Where a tool does not work,
it says so instead.
The short way is auto-router claude. It is the same as Claude Code's
documented gateway configuration, plus a credential:
export ANTHROPIC_BASE_URL=http://127.0.0.1:8787
export ANTHROPIC_API_KEY=local-router # any value; it never leaves your machine
claudeThe key matters, and not for security. Anthropic's gateway page: while a gateway credential is active, “the credential replaces the subscription login for that session, and the subscription's usage limits don't apply”. Set it, and your turns go to whichever model the router picks. Leave it unset, and your claude.ai login stays the active credential — see subscriptions below.
Add a provider to ~/.config/opencode/opencode.json:
{
"$schema": "https://opencode.ai/config.json",
"model": "autorouter/auto",
"provider": {
"autorouter": {
"npm": "@ai-sdk/openai-compatible",
"name": "Local auto-router",
"options": {
"baseURL": "http://127.0.0.1:8787/v1",
"apiKey": "not-needed"
},
"models": { "auto": { "name": "auto (the router picks)" } }
}
}
}Then opencode run -m autorouter/auto "…".
Two settings, wherever that client keeps them:
base URL: http://127.0.0.1:8787/v1
API key: anything
model: auto
For a library or a script, the same two as environment variables:
OPENAI_BASE_URL=http://127.0.0.1:8787/v1 and
OPENAI_API_KEY=anything. Every reply carries
X-Router-Model, X-Router-Reason and
X-Router-Cache, so you can see what happened without reading a log.
For whole jobs, auto-router run "…" starts Codex on your ChatGPT plan
whenever the router picks it (see above). Routing each single turn is not possible yet:
Codex removed chat-completions providers in February 2026: a custom
model_provider must now speak the Responses API, and
wire_api = "chat" is refused outright —
“`wire_api = "chat"` is no longer supported” (codex-cli 0.154.0). The router
speaks OpenAI chat-completions and the Anthropic Messages API, so there is nothing
honest to paste here yet. A Responses endpoint is
tracked in the repo;
when it lands the config will be:
# ~/.codex/config.toml — once the router speaks /v1/responses
model = "auto"
model_provider = "autorouter"
[model_providers.autorouter]
name = "Local auto-router"
base_url = "http://127.0.0.1:8787/v1"
env_key = "AUTO_ROUTER_KEY"
wire_api = "responses"Paste this into Claude Code, opencode, Cursor or any agent with a shell. It installs the router, starts it, proves it answers, and rewrites that tool's own configuration to use it — and it is written to stop and tell you if a step does not hold.
Install the auto model router on this machine and make it my default model endpoint.
1. Run: curl -fsSL https://whichmodel.app.mintapis.com/install.sh | sh
Read the script first and tell me in one line what it does. It needs Python 3.10+ and git.
2. Open ~/.auto-router/config.yaml. It references API keys by environment-variable NAME only.
Tell me which variables it wants and which of them are already set in my shell; do not
print any key value. If OPENROUTER_API_KEY is missing, stop and ask me for it.
3. Start the router in the background: `auto-router` (it serves http://127.0.0.1:8787/v1).
Wait until `curl -s http://127.0.0.1:8787/health` returns {"status":"ok",...}.
4. Prove it routes: run `auto-router check` and show me its output. It prints the model the
router chose and why, and ends with "OK". If it does not, stop and show me the router's
output rather than changing any configuration.
5. Now configure THIS tool - the one you are running inside - to use the router, backing up
the file you touch first and showing me the diff:
- Claude Code: do not change my shell profile. If I have a Claude Pro/Max plan, tell me to
start it with `auto-router switch` (cheap routes by default, my plan when the router or I
choose it with `~plan`); otherwise with `auto-router claude`. Note in one line which of my
accounts pays in each mode.
- opencode: a provider "autorouter" in ~/.config/opencode/opencode.json with
npm "@ai-sdk/openai-compatible", baseURL http://127.0.0.1:8787/v1, model "auto",
and set the default model to autorouter/auto. Keep every existing provider.
- Cursor or another OpenAI-compatible client: base URL http://127.0.0.1:8787/v1,
key "anything", model "auto".
- Codex CLI: do NOT edit ~/.codex/config.toml. Codex needs a Responses-API provider and
the router does not speak that yet. Instead run
`auto-router run --dry-run "write a unit test for the parser"` and show me which tool
the router would start for that job, and why.
6. Finally: start a new session in the tool you just configured, ask it one trivial question,
and show me from `curl -s http://127.0.0.1:8787/v1/router/metrics` that the request went
through the router and which model answered.Keep it, and use the router anyway: your plan's limits are only spent on the turns that actually go to the plan. We tested four ways on 19 September 2026 with a real Claude Max login, and read the vendors' current terms for each.
auto-router switch.
Claude Code starts on cheap models through the router, using the router's own
credential. Anthropic's gateway page says “the credential replaces the subscription login
for that session, and the subscription's usage limits don't apply”, so nothing goes to
your plan. Before each prompt the router decides. When your plan's model is the better
choice, Claude Code restarts in its normal plan mode (your own login, straight to
Anthropic, no router in between) and resumes the same conversation. If the cheap model
gets stuck in the middle of a task, the router hands the conversation over the same way.
Start a prompt with ~plan or ~cheap to decide yourself.delegate, which hands a
sub-task (tests, boilerplate, a mechanical refactor) to a cheap model and returns the result
for checking. This is ordinary use of MCP, which both clients document.auto-router run "…" picks the tool for a task and
starts it unmodified: Codex on your ChatGPT plan, Claude Code on your Claude plan, or a cheap
model.ANTHROPIC_BASE_URL set, “a saved claude.ai login remains the active credential,
so its usage limits and billing apply”. Forwarding those requests unchanged is documented.
Answering some of them with other models also works, but Anthropic “doesn't support routing
Claude Code to non-Claude models through any gateway”, and your plan's token passes through
the router on every request. So this mode is off by default and is for your own login on
your own machine only.What a switch costs. The side you switch to reads the whole conversation without a warm cache. Moving one of our test conversations to the plan half-way used 3.4× the plan quota of simply staying on the plan. So the router decides at the start, switches rarely, and only leaves the plan for a clearly easy prompt.
Not allowed, and not done here: taking a plan's login token out of the official client, or serving anyone else's requests from your plan. Anthropic does not permit developers “to route requests through Free, Pro, or Max plan credentials on behalf of their users”, and OpenAI's terms say you “may not share your account credentials or make your account available to anyone else”. For Codex, whole jobs and the delegate tool work today. A per-turn cheap mode for Codex needs an OpenAI Responses API, which the router does not have yet.
A peer-to-peer network of volunteered GPUs: people open a browser tab, it runs a ternary 27B model on WebGPU, and that tab answers other people's requests. Free, slow, best effort — which is exactly the shape of route an expected-cost rule is good at placing. It is a candidate in this demo's catalog like any other, and when nobody is online it is removed rather than sent requests nobody will answer.
Privacy
Your prompt is sent to two places: to TypeSafe for classification (scrubbed of recognisable credentials and truncated first), and to the model the router picks, which is hosted by a third-party inference provider. If the peer-to-peer route is chosen, your prompt is processed on a volunteer's computer and the page says so before you use it.
Nothing that you typed. The server keeps counters — how many runs an address has started this hour, how many runs and how many cents the demo has used today — and a prompt-free routing record in memory for the page you are looking at. Your address is only ever held as a salted hash that is thrown away when the process restarts, and the salt changes with every restart.
Multi-turn conversations are kept in the server's memory for the length of your session so the cache logic has something to be about. They are dropped when the session falls out of the ring buffer or the process restarts, and they are never written to disk.
This is a public playground running on third-party inference providers and, when it is online, on strangers' GPUs. Treat everything you type as public.
No cookies, no analytics, no third-party scripts. The page keeps a session id, your theme choice, whether you hid the install bar, and your own recent runs in your browser's local storage; none of it is sent anywhere but this site. The server counts page views, runs and installer downloads per day as plain totals — no address, no identifier, nothing per visitor.
productivity-boost.com Betriebs UG (haftungsbeschränkt) & Co. KG — see the Legal notice.
Legal notice
Information pursuant to § 5 of the German Digital Services Act (DDG):
productivity-boost.com Betriebs UG (haftungsbeschränkt) & Co. KG
represented by its general partner, productivity-boost.com Verwaltungs UG (haftungsbeschränkt),
itself represented by its managing director, Florian Standhartinger
Kirschbaumweg 4
94032 Passau
Germany
Email: florian.standhartinger@gmail.com
VAT ID (§ 27a UStG): DE296812612
Florian Standhartinger, address as above.
This site is a free, non-commercial technical demonstration. The answers come from third-party language models and can be wrong. The operators of linked external sites are responsible for their content.
The European Commission's online dispute resolution platform: ec.europa.eu/consumers/odr. We are neither obliged nor willing to take part in dispute resolution proceedings before a consumer arbitration board.