💻 computer science

SWE-Router: Routing in Multi-turn Agentic Software Engineering Tasks

The paper introduces SWE-Router, a value-based routing framework that improves cost efficiency in multi-turn agentic software engineering by leveraging a cheap model's initial exploratory trajectory to make informed escalation decisions, thereby outperforming traditional description-only routers while maintaining strong performance.

Original authors: Seongho Son, Sangwoong Yoon, Jiahua Tang, Shuhan Wang, Lorenz Wolf, Ilija Bogunovic

Published 2026-07-02

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Seongho Son, Sangwoong Yoon, Jiahua Tang, Shuhan Wang, Lorenz Wolf, Ilija Bogunovic

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Problem: Hiring the Wrong Expert

Imagine you run a repair shop. You have two types of mechanics:

The Apprentice: Cheap, fast, and good at simple fixes (like changing a lightbulb or tightening a loose screw).
The Master Engineer: Extremely expensive, slow, and brilliant at solving complex, multi-layered disasters (like rebuilding a car engine from scratch).

In the world of software, these are Large Language Models (LLMs). The "Master" models are great at fixing code, but they cost a lot of money to run. The "Apprentice" models are cheap but sometimes get stuck on hard problems.

The Current Mistake:
Right now, when a customer brings in a broken piece of code, the shop manager (the router) looks only at the customer's description of the problem.

Customer says: "My car won't start."
Manager thinks: "That sounds serious. Let's call the Master Engineer immediately."

The Reality:
Sometimes, "My car won't start" just means a loose battery cable (a simple fix the Apprentice could handle). Other times, it means the engine block is cracked (requiring the Master). The manager can't tell the difference just by reading the note. This leads to wasting money on the Master for simple jobs.

The Solution: SWE-Router (The "Test Drive" Approach)

The authors of this paper created a new system called SWE-Router. Instead of guessing based on the description, they let the Apprentice try to fix the problem for a few minutes first.

Here is how it works:

The Exploration Phase: The cheap Apprentice model is given the task and allowed to take a few "turns" (steps). It looks at the code, runs tests, and sees what errors pop up.
The Observation: The system watches what the Apprentice does.
- Scenario A: The Apprentice quickly finds a typo and fixes it. The system sees this and says, "Great! The Apprentice can handle this. Let's save money and let them finish."
- Scenario B: The Apprentice gets confused, runs into a wall, and can't figure out where the bug is. The system sees this struggle and says, "Okay, this is too hard. Stop the Apprentice and call the Master Engineer immediately."
The Decision: A special "Value Head" (a smart judge) looks at the Apprentice's progress and decides: Is this easy enough for the Apprentice to finish, or do we need to escalate?

Why This is Better (The "Information" Advantage)

The paper argues that looking at the partial history (what happened during those first few steps) gives you much more information than just reading the original problem description.

The Old Way: Like trying to guess if a movie is a comedy or a tragedy just by reading the title. You might be wrong.
The New Way: Like watching the first 5 minutes of the movie. If you see people laughing, you know it's a comedy. If you see a funeral, you know it's a tragedy. You have more data, so your guess is better.

The paper proves mathematically that having this extra information (the "partial trajectory") never hurts your decision-making. It is always better to know a little bit of the story before deciding who to hire.

The Results

The researchers tested this on real-world coding tasks (fixing bugs in large software projects).

Cost Savings: They saved a lot of money because the cheap Apprentice handled many tasks that used to be sent to the expensive Master.
Success Rate: They didn't lose any quality. When the Apprentice failed, they switched to the Master, so the tasks still got fixed.
Surprise Bonus: In some cases, the Apprentice actually solved problems that the Master would have failed to solve if it had been called immediately. This is because the Apprentice's "exploration" helped clarify the problem in a way the Master's direct approach didn't.

Summary

SWE-Router is a smart traffic cop for software repair. Instead of sending every car to the most expensive mechanic, it lets a cheap mechanic do a quick diagnostic. If the mechanic can fix it, great! If not, they call the expert. This saves money without sacrificing quality, and it works because it learns from the process of trying to fix the problem, not just the problem description itself.

Technical Summary: SWE-Router

Problem Statement

Large Language Models (LLMs) integrated into multi-turn agentic frameworks are achieving state-of-the-art results in software engineering (SWE) tasks, such as resolving repository-scale GitHub issues. However, the inference cost of frontier models is often an order of magnitude higher than competitive open-weight alternatives. A critical inefficiency arises because existing routing strategies treat every task as requiring frontier capability, despite the fact that many issues admit "cheap fixes."

Current LLM routers operate as classifiers or probability estimators based solely on the initial task description ( $q$ ). The authors identify a fundamental limitation in this approach: in agentic settings, a similar issue description can mask vastly different underlying difficulties (e.g., a localized typo versus a multi-module refactor). This ambiguity creates an "information-theoretic Bayes-error floor," where the prompt alone cannot distinguish between easy and hard instances. Consequently, routing decisions based only on $q$ inherit a high error rate, leading to wasteful escalation to expensive models for tasks a cheaper model could solve.

Methodology: SWE-Router

The paper introduces SWE-Router, a value-based temporal routing framework designed to overcome the information limitations of prompt-only routing. Instead of making an immediate decision based on $q$ , SWE-Router employs a "try-before-you-buy" strategy:

Exploratory Phase: A cheap, weak model ( $m_1$ ) is allowed to run for $K$ exploratory turns. During these turns, the agent generates a partial trajectory ( $\mathcal{T}_{\le K}$ ) consisting of thoughts, actions, and observations (e.g., failed tests, file contents, stack traces).
Value Estimation: A learned value head (a classifier trained on binary trajectory rewards) reads the partial trajectory $\mathcal{T}_{\le K}$ and predicts the probability that $m_1$ will eventually solve the task.
Routing Decision: The system compares the cost-adjusted expected utility of continuing with $m_1$ $m_{1}$ versus escalating to a stronger, expensive model ( $m_2$ $m_{2}$ ).
- If the predicted success probability of $m_1$ exceeds a cost-adjusted threshold, $m_1$ continues the task.
- Otherwise, the system escalates to $m_2$ , which restarts the task from the original prompt $q$ (avoiding bias from $m_1$ 's reasoning).

Theoretical Foundation:
The authors provide a Bayes-optimality theorem (Theorem 4.1) proving that conditioning on the partial trajectory $\mathcal{T}_{\le K}$ never harms routing performance compared to conditioning on $q$ alone. The theorem establishes that the partial trajectory carries strictly more information than the prompt. The routing improvement is strict whenever the exploration turns provide informative signals about the task's difficulty (i.e., when the conditional gap in utilities is not measurable by the prompt alone).

Implementation Details:

Value Head: A pretrained LLM (Qwen2.5-Coder-7B-Instruct) with a small classification head, fine-tuned via LoRA on binary trajectory rewards.
Training Data: The framework utilizes a multi-LLM trajectory dataset generated by running weak models on SWE-Smith and SWE-Bench datasets.
Routing Rule: The authors simplify the decision rule to a one-sided routing approach: continue with $m_1$ if $\hat{r}_1(\mathcal{T}_{\le K}) \ge \lambda'$ , where $\lambda'$ is a threshold tuned on validation data.

Key Contributions

Identification of Bayes-Error Floor: The paper identifies that prompt-conditioned routers in multi-turn agentic SWE inherit an information-theoretic limit because the task description often fails to distinguish between localized and complex issues.
Temporal Routing Framework: SWE-Router is the first routing framework to condition routing decisions on the agent's own intermediate observations (partial trajectory) rather than just the prompt.
Theoretical Guarantee: A proof demonstrating that partial-trajectory conditioning strictly improves routing optimality when exploration is informative.
Empirical Validation: Extensive experiments showing that SWE-Router significantly improves cost efficiency while maintaining the resolution rates of stronger models.
Dataset Release: The authors release a multi-LLM trajectory dataset to enable reproduction of trajectory-level routing research.

Experimental Results

The authors evaluated SWE-Router on the SWE-Bench Verified and SWE-Smith datasets using two pairs of LLMs (Weak: gpt-5-mini or deepseek-v3.2; Strong: gemini-3-pro-preview).

Cost-Performance Pareto Frontier: SWE-Router (with $K=3$ ) traces a Pareto frontier that strictly dominates embedding-based baselines (Logistic Regression, k-NN, XGBoost) and non-temporal routers ( $K=0$ ) across most of the cost range.
Route-AUC Improvements: On the SWE-Bench Verified test split, SWE-Router achieved a Route-AUC of 0.780 (using deepseek-v3.2 as $m_1$ ), representing a +15.3 percentage point improvement over the non-temporal baseline. The gpt-5-mini pair showed a +12 percentage point improvement.
Synergistic Effects: The routing curves occasionally exceeded the performance of the "all-strong" baseline. This indicates that correctly routing easy instances to the weak model resolved cases where the strong model (when forced to run on all tasks) failed, likely due to the weak model's ability to explore without the strong model's specific failure modes or cost constraints.
Metric Correlation: The authors note that the AUROC of the value head (discriminative quality) is not strongly correlated with actual routing performance (Route-AUC), suggesting that the value head captures nuanced signals relevant to the specific cost-benefit trade-off rather than just raw accuracy.

Significance and Claims

The paper claims that SWE-Router offers a clear positive impact by reducing the inference cost and energy consumption of frontier models with minimal trade-off in overall performance. By operationalizing the insight that intermediate agent observations contain structural signals (like bug localization data) unavailable in the initial prompt, the framework breaks the information-theoretic ceiling faced by prompt-only routers.

The authors modestly frame their contribution as a method to "greatly improve the cost efficiency of SWE tasks" while maintaining the majority of the stronger model's performance. They acknowledge that while their approach reduces costs, the use of partial trajectories could theoretically be misused to bypass safety-focused models, identifying safety-aware routing as an important direction for future work. The core significance lies in shifting the routing paradigm from static prompt analysis to dynamic, trajectory-aware decision-making in agentic software engineering.