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
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 |
|---|
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 150 lines. It needs Python 3.10+ and git, asks for no privileges, installs nothing system-wide, and touches only these four 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 of four models, if you have none.
Keys are referenced by environment-variable name; none is ever written to it.~/.local/bin/auto-router — one launcher.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 # http://127.0.0.1:8787/v1
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.
Every one of these was run against a router installed by the command above, on a clean machine, on 18 September 2026. Where a tool does not work, it says so instead.
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.
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. Send one request and show me the response headers:
curl -sD - http://127.0.0.1:8787/v1/chat/completions -H 'Content-Type: application/json' \
-d '{"model":"auto","messages":[{"role":"user","content":"Say OK"}],"max_tokens":20}' \
| grep -i '^x-router'
X-Router-Model is the model it chose, X-Router-Reason is why. If there is no answer,
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: ANTHROPIC_BASE_URL=http://127.0.0.1:8787 and any ANTHROPIC_API_KEY value,
in my shell profile. Note in one line that this means my Claude subscription is not
used for these turns.
- 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 try. It requires a Responses-API provider since Feb 2026 and the
router does not speak that yet. Tell me so and skip this step.
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.
The honest answer is that a flat-rate plan can only be spent through its own official
client. Anthropic's own gateway documentation is explicit in both directions: set a
gateway credential and “the credential replaces the subscription login for that session,
and the subscription's usage limits don't apply”; set only
ANTHROPIC_BASE_URL and “a saved claude.ai login remains the active credential,
so its usage limits and billing apply” — but in that mode Anthropic
“doesn't support routing Claude Code to non-Claude models through any gateway”, so there is
nothing for a router to decide. Codex's ChatGPT plan is the same shape through the Codex CLI.
So the router does not pretend. It routes what it is allowed to route — metered APIs, free tiers, your own hardware, the peer-to-peer network — and where a subscription is the right place for a turn, the thing to start is that subscription's own client, with the task, from outside.
And please do not put a proxy in front of somebody else's plan. Anthropic does not permit developers “to route requests through Free, Pro, or Max plan credentials on behalf of their users”, and the same goes for every other flat rate.
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 stores one session id and your theme choice in your browser's local storage.
productivity-boost.com Betriebs UG (haftungsbeschränkt) & Co. KG — see the Impressum.
Impressum
productivity-boost.com Betriebs UG (haftungsbeschränkt) & Co. KG
Vertreten durch die productivity-boost.com Verwaltungs UG (haftungsbeschränkt),
diese vertreten durch den Geschäftsführer Florian Standhartinger
Kirschbaumweg 4
94032 Passau
Deutschland
E-Mail: florian.standhartinger@gmail.com
Umsatzsteuer-Identifikationsnummer gemäß § 27a UStG: DE296812612
Florian Standhartinger, Anschrift wie oben.
Diese Seite ist eine kostenlose, nicht-kommerzielle technische Demonstration. Die Antworten stammen von Sprachmodellen Dritter und können falsch sein. Für Inhalte externer Links sind deren Betreiber verantwortlich.
Plattform der EU-Kommission zur Online-Streitbeilegung: ec.europa.eu/consumers/odr. Wir sind nicht verpflichtet und nicht bereit, an Streitbeilegungsverfahren vor einer Verbraucherschlichtungsstelle teilzunehmen.