Stop picking models yourself: OpenRouter's rebuilt Auto Router and coding-first Auto Code
On November 6 OpenRouter rebuilt Auto Router from scratch and launched Auto Code, a router tuned for coding. Auto Code matches Claude Opus 5.5 across five benchmarks at 74% lower cost per task — but the default cost tier changed too, so existing users should check their bills.

On November 6, OpenRouter shipped a next-generation Auto Router and a new coding-specialized router, Auto Code. The announcement sets the tone in its first sentence: everything learned from running Auto Router for the past three years went into a rebuild from the ground up. In live testing, the routing step is 3× faster at p90 (0.65 seconds versus 1.96 seconds), and the new router outperforms the old one by up to 4× depending on the benchmark.
For vibe coders who deal with models every day, the point is not "a few times faster" — it is that picking a model is itself being outsourced. OpenRouter's Auto Router handles more than 2.5 trillion tokens a month from over 100,000 people. At that scale, trying models one by one, memorizing prices, and tracking new releases by hand stopped being workable a while ago. The new Auto Router and Auto Code want you to choose once: set the model to openrouter/auto or openrouter/auto-code, and let the router handle the rest.

1. What shipped: one general-purpose router, one coding router
First, tell the two new roles apart. Auto Router (openrouter/auto) is the flagship general-purpose router, for mixed traffic and general agents, favoring a cost-efficient tier of models. Auto Code (openrouter/auto-code) is a brand-new coding-specialized router, for coding agents and harnesses, starting at a higher cost tier and weighing measured pass rate, speed, and cost per solved task across models and reasoning efforts.
Both run on the same routing engine, but Auto Code is tuned for writing code from the ground up. OpenRouter admits in the announcement that the most common complaint about previous versions of Auto Router was how it performed in coding harnesses. So Auto Code favors a slightly more expensive tier of models whose strengths match coding work; it weighs speed more heavily, because responsiveness matters while you build; and it penalizes failures more harshly, so it course-corrects faster on work where success and failure are clear-cut. Across five benchmarks — Deep SWE, SWE-Atlas QA, Terminal Bench 4.0, τ³-bench Banking, and MMMU Pro Vision — Auto Code scores in line with Claude Opus 5.5 while costing 74% less per task. Both numbers come from OpenRouter's own benchmark testing, not independent evaluation — read them with that qualifier attached.
There is one more detail that is easy to miss: the previous generation of Auto Router had a flaw — the lowest-cost models were so remarkably efficient that the router kept drifting lower on cost per task, leaving many exceptional models out. With this release, OpenRouter decided to return pricing to closer to where Auto was a few months ago, in order to bring in a greater variety of models. If you preferred the previous behavior, you can set cost_tier to low for similar cost performance. The subtext matters: existing users don't need to change anything to keep using it, but the default behavior has already changed — the same openrouter/auto will now pick a more expensive, more varied mix of models, and your bill and latency profile will change with it.
2. How the router picks a model: eleven factors, five steps
The previous Auto Router relied on a couple of imprecise signals, such as task type, to drive model selection — a limit required to keep latency low and judgments consistent. The new generation works differently: a fast decision model evaluates eleven factors in a single call — what kind of task this is, whether the task just changed, how hard it is, whether speed matters, whether it needs vision or knowledge of a codebase, and whether a bigger model, more thinking, or a cheaper model would serve it better — combined with live pricing, provider health, and cache status to pick the model and the reasoning effort.
A request moves through Auto Router in five steps. First, the model pool is narrowed: guardrails, zero data retention requirements, model capabilities, provider restrictions, BYOK keys, and any allowed or excluded model lists decide which models are considered. Second, the fast decision model rates the eleven factors. Third, the routing policy weighs live prices, cache status, and benchmark performance to pick both the model and the reasoning effort. Fourth, the request goes through the same provider routing a direct request to that model would, landing on the best provider for that model. Fifth, the results of each turn inform the next turn's model selection: whether the model is struggling and what is already cached carry into the next decision.
Two design choices matter most for vibe coders. The first is restraint about switching. Switching models costs extra while the new model rebuilds the input token cache. Auto Router favors a change in reasoning effort when that is enough, and switches only when the gain is worth the cache it gives up. In the beta period it stayed on the same model for nearly nine of every ten agent turns. For long coding-agent sessions, that means the context cache is less likely to be broken by frequent model switches, and sessions stay steadier. The second is adapting to failures. When a session is going wrong in ways that point at the model — the same error coming back, or tests failing after an edit — those signals raise the odds of a switch, so a session is much less likely to stay stuck with a model that was the wrong pick early on. The beta numbers: against the previous router, invalid tool calls were 4× lower and agentic responses were cut off half as often — again, the vendor's own beta figures, to be read with the qualifier.
3. Model selection becomes visible for the first time: the routing insights panel in the chatroom
The most interesting product detail in this release is not in the benchmark table — it is in the chatroom. Pick Auto Router or Auto Code in OpenRouter's chatroom, and a routing insights panel appears beside each reply, showing why the router picked that model. The announcement's example: a Python RecursionError debugging question was answered by DeepSeek V4.1 Flash on InferenceNet, with the panel showing the task type as Debugging (98%), the selection share across candidate models, and judgments about difficulty, precision, and whether a larger model would help.
The same analysis is available via the API when you enable router metadata. The model pages for Auto Router and Auto Code now also show the live routing mix: which models each router picks most often, split by session type, and how the mix shifts as difficulty rises. In the announcement's screenshot, GPT-6.1 Sol leads the past day's requests with a 33.8% share.
This matters more than it looks. The biggest frustration with openrouter/auto used to be not knowing who it picked for you or why — when something went wrong, you could only guess. Now that routing decisions come with readable reasons, debugging has something to grab onto: when an answer is poor, the panel shows whether the model was the wrong pick, the difficulty was misjudged, or the caching strategy got in the way. For anyone wiring Auto Code into a coding agent, that is more useful than the 74% figure — how much cost you save is a result, but knowing why this model is the precondition for improving it over time.
4. A note for existing users: nothing needs changing, but the behavior already has
The FAQ in the announcement is explicit: switching from the old Auto Router requires no changes. The slug is still openrouter/auto, and the auto-router plugin settings — cost_tier, allowed_models, excluded_models — still work. Auto Router Beta (openrouter/auto-beta) is the release channel for the next version: new routing changes ship there first and graduate to openrouter/auto once they prove out.
But "nothing to change" and "nothing changed" are two different things, and the announcement contains at least three changes existing users need to know. First, the default cost tier changed: the new release returns pricing to roughly where it was a few months ago, with a more varied model mix — at the cost of the same work possibly costing more than before. Anyone who wants the old behavior needs to actively set cost_tier to low. Second, the model-pool logic changed: every one of the 600+ models on OpenRouter enters the consideration set the day it is added, with benchmarks and popularity signals deciding whether it earns a place in the cost-optimal set — which means a new model release could start serving your requests without any notice. Third, Auto Code's very existence is a split: coding traffic that used to be mixed into the general router now has a dedicated destination. If you ran coding agents on openrouter/auto and found it hit-or-miss, switching to openrouter/auto-code may be the most direct improvement.
One more thing on governance. The router only picks inside the pool you allow: guardrails, zero data retention requirements, provider restrictions, allowed and excluded model lists, and BYOK keys jointly draw the boundary. For team use, that means the router's "automatic" is not unbounded automatic — you can still use an allowlist to keep models with compliance problems out, and ZDR to make sure data is not retained. The announcement says the routers charge no extra routing fee: you pay the standard price of whichever model serves the request, and the response's model field tells you which one it was.
5. OpenRouter said the honest part first: no router beats the best single model at every point
There is a section in the announcement called "Routers versus single models," written more honestly than most vendor launches: benchmarks consistently show that no router on the market beats the single best frontier model at every point on the cost and quality curve. The new Auto Router is no exception, and OpenRouter publishes its benchmarks to show its strengths and weaknesses plainly.
That sentence is worth unpacking. A router's value is not "picking the best model for every task" — it is "keeping performance stable and cost-efficient over a large pile of tasks, over time." Routers earn their place when the work is varied, when an organization needs to hold costs steady, and for people who don't have the time or interest to keep up with the constant stream of model releases. Conversely, if you already know which model fits your specific work — say, you have measured that one model writes the most reliable code for your project — the announcement's own advice is to keep using it. Choosing a router over a single model trades a little peak performance for consistent, cost-efficient performance over time.
For vibe coders, that decision framework is worth remembering more than the 74%. Auto Code's selling point is "Opus 5.5-level performance at 74% lower cost," but that number is premised on "average performance across five benchmarks," not "your project." Your project has its own codebase, its own tests, and its own failure modes; whether the router saves you money and stays stable there can only be verified against your own tasks. OpenRouter publishes the benchmark results on its model routing benchmarks page and reruns them periodically — handing you the ruler for verification. Before adopting it, look at where your task type sits on that table; that beats trusting the headline number outright.
6. The bigger picture: model selection is turning from a craft into infrastructure
There is another layer to this release that the announcement doesn't spell out but is worth naming: model selection is turning from a craft into a layer of infrastructure. Three years ago, when Auto Router first launched, picking models was still each team's own homework — someone had to track new releases, run evaluations, do the pricing math, and write the conclusions into configuration. Now there are 600+ models in OpenRouter's catalog, each entering the candidate pool the day it is added, with benchmarks and popularity signals deciding whether it makes the cost-optimal set. Keeping up with that pace by hand is no longer realistic.
That is actually good news for small teams and independent developers. A large team can afford someone dedicated to model selection; a small team can't — your time belongs on the product, not on recalculating which model is cheapest every week. A router outsources model selection to a system that sees more than 2.5 trillion tokens a month: it has seen more task types than you have, tried more model combinations than you have, and made more mistakes than you have. The lessons in the announcement — split coding traffic out, restrain switching to protect the cache, switch adaptively after failures — were learned by colliding with real traffic, not dreamed up in a lab.
But outsourcing has its price. The most direct one is explainability: when you picked models yourself, you knew whom to blame and whom to swap when something went wrong; now that the router picks for you, you first have to read the routing insights panel to judge whether the model was wrong, the task was just hard, or the provider had a problem. The announcement's move to make routing decisions visible in a panel and to publish benchmarks that are rerun regularly is exactly addressing this — "automatic" does not mean "black box," at least in OpenRouter's design. But it also means users need a new habit: checking the routing log regularly, instead of only investigating when the bill explodes.
There is also the lock-in question. The openrouter/auto identifier hasn't changed in three years, and the announcement pointedly notes that if you set it in an agent years ago, "you're still getting the latest cost-optimal choice today." That sounds like a promise, but it is also a reminder: by handing model selection to an intermediary, you trade the convenience of never chasing new models yourself for the fact that your agent's behavior follows the router's versions. The Auto Router Beta channel exists for people who care about this — new routing changes ship to openrouter/auto-beta first and graduate once proven. People who want an early look take the beta channel; people who want stability stay on the stable one. That layering is itself part of the router product.
7. How to try it: understand it in the chatroom first, then wire it into your agent
If you want to try it now, the announcement's path is simple: set the model to openrouter/auto or openrouter/auto-code in any request, or open Auto Router in the chatroom. But the order is better reversed: try it in the chatroom first.
Step one: test it in the chatroom with the kind of prompt that usually gives you the most trouble — for example, "add a retry with backoff to this function" or "what does this error mean" — then open the routing insights panel and check which model it picked, whether the task-type judgment was right, and whether the difficulty assessment was reasonable. If it keeps misclassifying debugging questions as something else, the router's task classification isn't reliable in your scenario yet, and you should plan a fallback before wiring it into an agent.
Step two: before wiring it into an agent, enable router metadata in your API requests and log every routing decision. After a few days you will see your own task distribution: how often it picked a cheap model, how often an expensive one, how often it switched, and whether it actually switched after failures. That tells you more than the bill alone — the bill tells you how much you spent; the routing log tells you whether the money was well spent.
Step three: put coding agents on Auto Code first, and leave general tasks on Auto Router. Auto Code is tuned for coding harnesses: faster, more focused on measured pass rates, harsher on failures. If your agent is a coding tool like Claude Code or Cursor, or a coding pipeline you built yourself, openrouter/auto-code is the better-matched entry point. General Q&A, writing docs, and research — the mixed traffic — can stay on openrouter/auto; there is no need to move everything over just because something is new.
One last reminder: if you are an existing user, watch your bill and latency in the first week after the upgrade. The default cost tier changed and the model mix changed, so the same tasks might cost more than before — or run faster because the caching strategy changed. Observe for a week before deciding whether to set cost_tier back to low or to put certain models on the exclusion list. Letting a router pick models for you is a good thing, but reviewing the picks afterwards is still your job.
Comments (0)
Sources
Related articles
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.
On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.
On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.