An LLM router chooses a model or provider for each AI request, using rules or a learned decision. As of November 2026, Requesty's coding-policy replay offers one reason to test routing: a Jev-based policy solved 120 of 129 tasks at 72% of the cost of sending every task to Claude Opus 5.5. Routing is worth testing when tasks vary in difficulty, model costs are high, or you need a fallback.
A router chooses where each request goes
Your application sends a request to the router, whose policy selects a model or provider. The selected model returns a response; if a configured attempt fails, a fallback policy can try another destination.

The policy can be a plain priority list, or it can use a classifier to choose a model for the task. AWS describes an approach called semantic routing: embed the prompt, compare it with reference prompts from task categories, then send it to the model associated with the closest category.
A router can sit inside a gateway, which is the broader service. Alongside routing, the gateway can provide a common API, authentication, budgets and usage tracking. For that broader API and access-control layer, see our guide to what an LLM gateway does.
Do you need an LLM router?
A single-provider prototype with acceptable cost and reliability can start with a direct integration. Adding a router is worth testing when you have a specific reason to send requests somewhere else.
Should you test an LLM router?
0 of 5 done
Start with one model if it meets your needs. Test routing when a second model or provider could improve cost, quality or availability, and you can measure the result against your current setup.
Routing methods use different signals
| Approach | Input signal | How it selects a destination | When to test it |
|---|---|---|---|
| Rule-based | A configured priority, weight or operational metric | Applies an explicit policy, such as trying models in order or distributing traffic by weight. | You need fallback or want to distribute traffic across providers. |
| Learned classifier | A prompt and a model trained on preference data | Predicts a route from learned patterns. | You want to test whether a classifier can distinguish requests suited to different models. |
| Decision model | A message or task context and defined route choices | Returns a decision among the choices; a policy can use a confidence threshold and fallback. | You can describe your routes and want a decision for each session. |
These categories overlap: a decision model can itself be a learned model. The distinction helps when setting up the policy, since an explicit priority list, a preference-trained classifier and a typed decision call give you different signals to work with.
Take RouteLLM: it includes a matrix factorization router and a BERT classifier trained on preference data.
Requesty's Auto Routing beta, announced in October 2026, uses a decision model to classify the first user message against user-defined routes. If the decision misses the configured confidence threshold, it uses a fallback. The selected route stays pinned for the session.
What can routing change in cost and quality?
Model choice can change both the bill and the number of tasks solved. In Requesty's coding benchmark, 25 models worked on the same 129 private backend tasks with the same coding agent, tools and 80-turn budget. A task counted as solved only when its hidden tests and existing tests passed.
| Model | Tasks solved | Cost per task | Cost per solve |
|---|---|---|---|
| Claude Opus 5.5 | 92.2% | $0.93 | $1.01 |
| Claude Haiku 5.5 | 81.4% | $0.11 | $0.14 |
The gap depends on task difficulty. Haiku solved 100% of the easy and medium tasks and 55.6% of the extreme tasks; Opus solved 92.9% of the easy tasks, 100% of the medium tasks and 77.8% of the extreme tasks. The benchmark had 14 easy, 28 medium, 39 hard, 30 extra-hard and 18 extreme tasks.
Cost per task includes retries, so token price alone won't tell you the cost per solve. Cache behavior and token use also affect the bill: Haiku had a 100% cache-hit rate and used 1.66 million tokens per task in this benchmark; measure your own workload.
Our assumptions: each task is one session, with 500 sessions going to Haiku and 500 to Opus. We apply the benchmark averages equally to the assigned tasks and assume one Jev decision per session at $0.00002, using the experiment's short-instruction figure.
- All Opus: 1,000 × $0.93 = $930.
- Mixed model calls: 500 × $0.11 + 500 × $0.93 = $520.
- Routing decisions: 1,000 × $0.00002 = $0.02.
- Mixed total: $520.02, or $409.98 less than all Opus.
The assignment can change how many tasks are solved, and costs depend on the workload and cache behavior.
What did the Jev policy do?
In our coding-policy experiment, Jev 1.14 classified the kind of change using codebase context and four labels. The policy sent three of those labels to Haiku 5.5. Across all 129 tasks, that policy solved 120 at 72% of the cost of all Opus, which solved 119.
The decision calls were real production calls, but most of the comparison looked up previously measured agent outcomes instead of rerunning the agents for every policy. On the locked set of 43 tasks, the policy solved 40 and all Opus solved 41; we described those results as matching within noise.
Another decision model in the experiment, Cloudflare Clef, illustrates the tradeoff. Its policy solved 115 of 129 tasks at 57% of the all-Opus cost. The lower bill came with fewer solved tasks, so the right choice depends on what errors cost in your application.
Can routing improve reliability?
Fallback answers a different question: what happens when the chosen destination fails? Requesty fallback policies try configured models in priority order, with configured retries before moving to the next model.
Our eventual-success data counts a request as successful if an attempt in its fallback chain succeeds. The managed-fallback and direct cohorts had these results:
| Month in 2026 | Managed-fallback policy cohort | Direct cohort |
|---|---|---|
| January | 97.50% | 94.50% |
| April | 99.25% | 85.01% |
The data note compares observed production cohorts that chose different policies. That is a reason to measure eventual success across attempts in your own application, alongside error rates and latency. For more on provider failures, see our guide to rate limits and multi-provider fallback.
Latency needs its own measurement. Requesty's live latency rankings show latency per model and provider from production traffic, which is the signal our latency routing uses to pick a provider.
Start with a baseline
- 1Measure one model
Choose a set of tasks and record whether the model succeeds, along with cost per task and latency. Keep that baseline for comparison with each routing policy.
- 2Select candidates
Test other models on the same tasks. Check cost per solve as well as cost per task, and consider which models are acceptable fallbacks when a provider fails.
- 3Choose a policy
Start with explicit rules if you need a fallback or want to distribute traffic. For a decision-model policy, define the routes and test whether its classifications improve the result.
- 4Configure fallback
Set the model priority and retries in a fallback policy. Test what your application returns when the primary destination fails.
- 5Measure the routed workload
Compare solved tasks, cost, latency, cache behavior and errors with the baseline. User feedback can help you review quality after a routing decision.
Requesty's quickstart connects an application through an OpenAI-compatible API, and the model catalog covers 600+ models. You can test Auto Routing for session-level decisions, or use weighted load balancing and latency routing for operational policies.
If you have location requirements, check the model inference region separately from the EU gateway region. When estimating new usage, include the 5% pay-as-you-go markup on model costs.
Frequently asked questions
- What is LLM routing?
- LLM routing is the selection of a model or provider for an AI request using rules or a learned decision. A router can use signals such as task category, cost or availability.
- What is the difference between an LLM router and an LLM gateway?
- An LLM router selects the destination for a model request. An LLM gateway can include routing alongside a common API, authentication, budgets and usage tracking.
- Do I need an LLM router for one model?
- A single-provider prototype with acceptable cost and reliability can start with a direct model integration. Routing is worth testing when a second model or provider could improve cost, quality or availability.
- Does LLM routing always save money without reducing quality?
- No. In Requesty's coding-policy replay, a Clef-based policy cost 57% of the all-Opus baseline and solved 115 of 129 tasks, compared with 119 for all Opus.
- Can an LLM router handle provider failures?
- A fallback policy can try another configured model after retries on the first model. Requesty's fallback policies try models in a configured priority order.
- How much does a decision-model routing call cost?
- In Requesty's coding-policy experiment, a short Jev routing call cost about $0.00002 per session and had a median latency of 0.34 seconds.
- Does Requesty Auto Routing reconsider every agent turn?
- Requesty's Auto Routing beta classifies the first user message and pins the selected route for the rest of the session.
- OCT '26
What Is an LLM Gateway, and Do You Need One? (2026)
What is an LLM gateway? Learn how it routes model requests, what it costs and when your app needs shared budgets, security controls and fallback.
- OCT '26
Routing coding agents with one question: what a decision model on the first message is worth
We asked a decision model one question about the first message of a coding agent session and used the answer to pick the model. On 129 real tasks from our own Go monorepo it matched Claude Opus 5.5 on tasks solved at 72% of the cost. This is the full method, every variant we tried, and where it stops working.
- FEB '26
Closing the loop: how to turn user feedback into a routing signal
A thumbs-up or thumbs-down attached to an LLM response is the single most underused production signal. Here's how to wire it to Requesty's Request Feedback API and use it to drive model selection, prompt changes, and quality regressions.
