OpenRouter Auto Code Matches Claude Opus 5.5 for 74% Less: $1.98 a Coding Task

Quick Answer: OpenRouter launched Auto Code on 6 November 2026, a router for coding agents that scores in line with Claude Opus 5.5 across five coding benchmarks while costing 74 percent less per task, at $1.98 per task on Deep SWE in OpenRouter's own published results. You use it by setting the model to openrouter/auto-code in any OpenRouter request, and you pay only the list price of whichever model serves the request, with no routing surcharge.

Key takeaways:

• OpenRouter launched a rebuilt Auto Router and a new coding router, Auto Code, on 6 November 2026.
• Auto Code scores in line with Claude Opus 5.5 across five benchmarks while costing 74 percent less per task, according to OpenRouter's published results.
• On Deep SWE, Auto Code scores 74.3 percent at $1.98 per task in those same published results.
• The router weighs eleven factors per request, plus live pricing, provider health, and cache status, and picks both the model and the reasoning effort.
• There is no routing surcharge: you pay the standard list price of the model that serves each request.
• The new Auto Router is up to 4 times better on benchmarks than the old one, with the routing step 3 times faster at the 90th percentile, 0.65 seconds against 1.96 seconds.
• OpenRouter routes more than 2.5 trillion tokens a month from over 100,000 people, across a catalog of more than 600 models.

What is Auto Code, in plain terms?

OpenRouter is a gateway that lets you reach more than 600 AI models from over 80 providers through one API key and one OpenAI compatible endpoint. Instead of signing up with each provider separately, you send a request to OpenRouter, and it forwards it to the provider that serves the model you asked for. Auto Router is its built-in model picker: you set the model to openrouter/auto, and OpenRouter chooses which model handles each request, based on the task, the price, and what is available.

Auto Code is the new coding specialist version of that picker, launched on 6 November 2026 as openrouter/auto-code. OpenRouter says it built Auto Code because the general-purpose router performed poorly inside coding harnesses, the tools developers use to run agents that write, test, and fix code over many turns. Auto Code starts in a slightly more expensive tier of models than the general router, because coding work rewards stronger models, and it weighs speed more heavily, because responsiveness matters while you build. It also penalises failures more harshly, so it corrects course faster on work where success and failure are clear cut, such as a test passing or failing.

The important thing to understand is what a router is not. It is not a model. It does not write code itself. It is a decision layer that sits in front of the models and picks one for each request, then hands the request to OpenRouter's provider routing, which picks who serves that model. You still pay for the model that does the work, at that model's list price. The router's job is to make sure you are not paying flagship prices for easy tasks, and not getting a weak model for hard ones.

What do the benchmarks actually say?

OpenRouter published benchmark results for the new routers on its model routing benchmarks page, alongside other routers and single-model baselines, and says it reruns them periodically. The headline claim is that Auto Code scores in line with Claude Opus 5.5 across five benchmarks while costing 74 percent less per task. The five benchmarks are Deep SWE, SWE-Atlas QA, Terminal Bench 4.0, the tau-cubed banking benchmark, and MMMU Pro Vision. The table below summarises what OpenRouter published.

| Benchmark | What it tests | Auto Code result (OpenRouter published) | | Deep SWE | Hard software engineering tasks | 74.3 percent, $1.98 per task | | SWE-Atlas QA | Software engineering question answering | In line with Opus 5.5, 74 percent less per task across the five benchmarks | | Terminal Bench 4.0 | Agentic coding in a real terminal | In line with Opus 5.5, 74 percent less per task across the five benchmarks | | Tau-cubed banking benchmark | Multi-turn tool use in a banking scenario | In line with Opus 5.5, 74 percent less per task across the five benchmarks | | MMMU Pro Vision | Multimodal vision and reasoning | In line with Opus 5.5, 74 percent less per task across the five benchmarks |

Two things about that table deserve a closer look. First, the 74.3 percent Deep SWE score and the $1.98 per task figure are OpenRouter's own published numbers, not independent results. No outside lab has replicated them yet, and benchmarks are a controlled test, not your codebase. Treat them as a signal to try Auto Code, not as a guarantee of what it will do on your work. Second, the comparison is against single frontier model calls at comparable accuracy. OpenRouter is open about the trade: it says no router on the market beats the single best frontier model at every point on the cost and quality curve, and that choosing a router trades a little peak performance for consistent, cost-efficient performance over time. If you already know the model that works best for your specific work, OpenRouter itself says to keep using it.

For price context, Claude Opus 5.5 costs $4 per million input tokens and $20 per million output tokens on Anthropic's API, with cache reads at $0.20 per million. Auto Code does not change those prices. It changes which model you pay for on each request, so easy requests go to cheaper models and only hard ones reach the expensive tier. That is where the 74 percent saving comes from: not a discount, but a smarter mix.

What does it cost?

The pricing is simple, and that is part of the appeal. There is no fee for the router itself. The table below lays out the costs as published.

| Cost | Amount | | Auto Code routing surcharge | $0. You pay the standard list price of the model that serves each request. | | Auto Code per Deep SWE task (OpenRouter benchmark) | $1.98 | | Single frontier model per task at comparable accuracy (OpenRouter comparison) | About $7.62, implied by the 74 percent less figure | | Claude Opus 5.5 API, for comparison | $4 per million input tokens, $20 per million output tokens | | OpenRouter credit top-up fee, Standard plan, card | 5.5 percent, $0.80 minimum per purchase | | OpenRouter credit top-up fee, crypto | 5 percent | | OpenRouter minimum credit purchase | $5 | | Free models on OpenRouter | 50 requests a day, rising to 1,000 a day after $10 of credits purchased |

The implied $7.62 per task for a single frontier model is our arithmetic on OpenRouter's figures: $1.98 divided by 0.26, since 74 percent less means Auto Code costs 26 percent of the single-model price. OpenRouter did not publish that dollar figure directly, and your own tasks will differ from benchmark tasks, so treat it as a way to understand the scale of the claim, not as a price you will be charged.

One practical note on the top-up fee: OpenRouter passes through provider token prices with no markup, and takes its cut when you buy credits. On the Standard plan, a card top-up costs 5.5 percent with a $0.80 minimum, so a $10 top-up actually costs $10.80. If you top up $100, the fee is $5.50. That fee matters more on small top-ups, so buy credit in larger amounts when you can. Bring-your-own-key usage is fee-free up to $25,000 a month of list-price inference, then 5 percent.

How does the router choose?

The new generation works differently from the old one. The previous Auto Router relied on a couple of imprecise signals, such as task type, to drive model selection. The new Auto Router and Auto Code weigh eleven factors about each request and combine them with live pricing, provider health, and cache status. In one call, a fast decision model rates things like what kind of task it 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. The routing policy then picks both the model and the reasoning effort.

Three design choices in the announcement are worth knowing, because they shape how Auto Code behaves in a real coding session.

First, it is restrained about switching models, to protect caching benefits. Switching models costs extra while the new model rebuilds the input token cache, so the router favours a change in reasoning effort when that is enough, and switches only when the gain is worth the cache it gives up. In OpenRouter's beta period it stayed on the same model for nearly nine of every ten agent turns.

Second, it adapts to failures. When a session is going wrong in ways that point at the model, such as the same error coming back or tests failing after an edit, those signals raise the odds of a switch. That makes it much less likely a session stays stuck with a model that was the wrong pick early on.

Third, it is tuned on real usage as well as benchmarks. In beta, against the previous router, invalid tool calls were 4 times lower and agentic responses were cut off half as often. Those are OpenRouter's beta figures, not independent measurements, but they describe the kind of everyday failure the router is trying to reduce.

The router also respects your governance rules. Guardrails, zero data retention requirements, provider restrictions, allowed and excluded model lists, and bring-your-own-key settings define which models are considered, and the router picks the cost-optimal model inside that pool. If you prefer the old behaviour, where the router drifted toward the cheapest models, you can set cost_tier to low to get similar cost performance. OpenRouter says it deliberately moved the default pricing back up this release to include a greater variety of models.

How do you try Auto Code today?

There are two routes, and both take minutes.

The easiest is the chatroom. Open Auto Router or Auto Code in the OpenRouter chatroom, send the prompt you would normally hand-pick a model for, and a routing insights panel appears beside each reply showing why the router picked that model, including the task type, the selection share across candidate models, and judgments about difficulty, precision, and whether a larger model would help. The same analysis is available through the API when you enable router metadata. The model pages for Auto Router and Auto Code also show a live routing mix, which models each router picks most often, split by session type, and how the mix shifts as difficulty rises.

The second route is the API. Auto Code works wherever you would put a model string. Set the model to openrouter/auto-code in any request, and OpenRouter handles the rest. A minimal example, using the curl request from OpenRouter's own announcement, looks like this:

curl https://openrouter.ai/api/v1/chat/completions -H "Authorization: Bearer $OPENROUTER_API_KEY" -H "Content-Type: application/json" -d '{"model": "openrouter/auto-code", "messages": [{"role": "user", "content": "Add a retry with backoff to fetchUser in api/users.ts"}]}'

The response's model field tells you which model actually served the request, and you are billed at that model's list price. The slug openrouter/auto is unchanged for the general router, and the auto-router plugin settings cost_tier, allowed_models, and excluded_models still work. New routing changes ship to openrouter/auto-beta first and graduate to openrouter/auto once they prove out, so use the beta slug only if you want to see what is coming in advance.

Start with a task you can check. Give Auto Code a bug you have already fixed, or a small feature you already built, and compare three things: whether the result works, how many turns it took, and what it cost. Then run the same task through the single model you use now. That gives you a real price and quality comparison in an afternoon, on your own work, which is worth more than any benchmark table.

What are the catches?

There are five, and they are all worth knowing before you build on Auto Code.

First, benchmarks are not your codebase. Deep SWE, Terminal Bench, and the rest are controlled tests. Your repository has its own quirks, dependencies, and failure modes. The 74 percent saving and the 74.3 percent score are OpenRouter's published results on those tests, and your mileage will vary.

Second, the router trades peak performance for consistency. OpenRouter says so itself. On a task where the best single model is clearly better, the router may still pick a cheaper one if the gain does not justify the cost. If you need the strongest model on every request, route to it directly instead.

Third, the default got more expensive than the old router. OpenRouter says the previous generation drifted toward the cheapest models, and this release deliberately returns pricing closer to where Auto was a few months ago, to include a greater variety of models. If your bills rise after the change, that is why, and cost_tier low is the way back to the old behaviour.

Fourth, you do not control the exact model. The router picks, and the mix changes as new models are added and benchmarks are rerun. Every model enters the consideration set the day it is added, and popularity and benchmark signals decide whether it earns a place in the cost-optimal set. If your workflow depends on one specific model, pin it instead of routing.

Fifth, the free tier is limited. Free models on OpenRouter are capped at 20 requests a minute and 50 requests a day, rising to 1,000 a day once your account has bought at least $10 of credits. Auto Code itself is a paid routing service, so the free tier is a way to try the platform, not a way to run production coding work for free.

Who gets the most value from this?

Three groups should try Auto Code this week. Developers who run coding agents will feel the difference first, because agentic coding is the most token-hungry work most people do, and a router that keeps easy turns cheap while reserving strong models for hard turns cuts the bill without asking you to think about model choice. Small teams and indie builders who pay their own API bills get a way to use near-frontier coding quality without a frontier price on every request. And anyone building an app or agent on top of OpenRouter gets a single model string that stays current as new models arrive, instead of a hardcoded model that goes stale.

The test to run is simple. Take a coding task you have already solved, run it through Auto Code, and compare the result, the turns, and the cost against your current model. If all three look good, you have found a cheaper default. If the result is worse, you have spent a few dollars learning exactly where the router falls short, and you still have the option to pin a single model for the jobs that need it.

Sources: OpenRouter, "Introducing the New Auto and Auto Code Routers", 6 November 2026; OpenRouter Auto Code model page, as reported 6 November 2026; Anthropic pricing page, Claude Opus 5.5 at $4 input and $20 output per million tokens, as reported 3 November 2026; OpenRouter pricing page and FAQ, 5.5 percent card top-up fee and free model limits, as reported 22 October 2026.

Internal links: Category hub: https://www.topuseai.com/blog | Related live posts: https://www.topuseai.com/blog/openai-decisions-api-cost-10000-tickets | https://www.topuseai.com/blog/kimi-k3-1-pro-2-dollar-1-million-tokens-agent