acceptodds
Under review as a conference paper at ICLR 2027

RouteWeaver: Weaving Mode Selection and Execution into Unified LLM Routing

Abstract

LLM routing dynamically selects and coordinates heterogeneous language models across diverse tasks. However, existing approaches are largely built around a predefined execution paradigm, such as single-round, multi-round, or agentic routing, which fixes how model calls are organized and limits adaptation to different query needs. We propose \ours, a unified routing framework that integrates these routing modes within a single LLM policy, jointly learning which mode to use and how to select models within that mode. To jointly optimize mode selection and within-mode execution, we develop COMET-GRPO (COordinated Mode–Execution Training), which decouples the trajectory-level advantage into separate signals for mode selection and within-mode execution, enabling more targeted credit assignment to each decision level. We further introduce progressive exploration, which gradually shifts training from externally assigned modes to autonomous selection, so that the router first learns how to execute each mode before deciding when to use it. We evaluate \ours across mathematics, coding, knowledge, logical reasoning, and factual recall. \ours achieves an average accuracy of 61.4%, an 11.03% relative improvement over the strongest baseline, and outperforms all compared baselines in each of the five domains. Ablations show that both COMET-GRPO and progressive exploration are important for adaptive routing; without progressive exploration, the routing policy collapses entirely to single-round execution.

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM Routing, Reinforcement Learning, Multi-Agent Systems

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_jtJ4OpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper introduces RouteWeaver, a unified LLM routing framework that uses a Qwen3-4B-based router to coordinate six frozen Worker models and select among single-round, multi-round, and role-based agentic execution modes for each query. To jointly learn mode selection and within-mode execution, the authors propose COMET-GRPO, which separates reinforcement learning feedback into signals for these two decision levels. They also introduce progressive exploration, allowing the router to first practice executing different modes before gradually taking control of mode selection, thereby preventing premature concentration on a single mode. Experiments across mathematics, coding, knowledge, logical reasoning, and factual recall achieve an average accuracy of 61.4%, compared with 55.3% for the strongest baseline, an improvement of 6.1 percentage points. Ablations, performance–cost analyses, and evaluations on held-out benchmarks further examine the method’s effectiveness. Its central contribution is to integrate model selection and execution organization into a single trainable routing policy.

Critical strengths
  1. The authors propose a unified framework that integrates single-round, multi-round, and agentic routing, allowing the router to jointly decide which LLMs to invoke and how to organize their execution.

  2. The authors introduce COMET-GRPO and progressive exploration to train the router through reinforcement learning, achieving substantial performance improvements using a training set assembled from existing benchmarks.

  3. Through ablation studies and additional analyses, the authors demonstrate the effectiveness of the proposed components, examine the trade-off between accuracy and Worker inference cost, and evaluate generalization to held-out benchmarks within a fixed Worker pool. Their analysis also shows that the learned router selects different execution modes across datasets.

Critical weaknesses
  1. The cost analysis does not account for the overhead of the complete system.
    The paper reports only Worker inference costs, excluding the Qwen3-4B router itself. The router repeatedly processes interaction histories, generates routing instructions, and may organize workflows with multiple layers. This overhead cannot simply be assumed to be negligible.

  2. The generalization experiments are limited to a fixed model pool and do not establish adaptability to changes in deployment.
    All training and evaluation use the same six Workers. Although the results on AIME, GPQA-D, and BBH support transfer to held-out benchmarks, the paper does not evaluate performance when models are added, removed, or upgraded, or when their prices change.

  3. The ablation studies do not sufficiently disentangle the contributions of different training mechanisms.
    COMET-GRPO combines mode/execution advantage decomposition with separate normalization by the token count of each segment. The latter itself changes the relative training weight assigned to short mode-selection decisions and longer execution sequences. The current ablations do not clearly isolate the contributions of these two design choices.

Questions for authors
  1. Can the authors provide more comprehensive generalization experiments?
    Some evaluations in Table 1 use datasets also used during training, while Table 3 covers a limited set of benchmarks and baselines. Could the evaluation be extended to domains such as coding and factual recall, with additional competitive routing baselines?

  2. Are the data splits and baseline implementations fair?
    Please clarify the sampling, splitting, and deduplication procedures, along with each baseline’s implementation, tuning, and budget settings. Several complex methods substantially underperform simple baselines such as Router-KNN. Can the authors explain why?

  3. Can the authors report the usage distribution of the six Workers?
    Please provide each model’s share of calls across tasks and execution modes, as well as the number of distinct models used per trajectory, to clarify whether the system primarily relies on a small subset of Workers.

  4. Why is agentic execution selected for 99% of SATBench questions but only 12% of BBH questions?
    Please explain this difference and provide complete successful and unsuccessful trajectories, together with a comparison of execution modes on SATBench.

  5. Does adaptive mode selection actually outperform fixed execution modes?
    Could the authors train fixed single-round, multi-round, and agentic baselines using the same model pool, training data, and comparable budgets, and compare them with the adaptive policy to distinguish the benefits of mode selection from those of additional computation?

4 comments

We sincerely thank you for your careful review and constructive feedback. Your comments have helped us strengthen the evaluation and clarify the presentation. We address your concerns below. Changes in the revised PDF are highlighted in blue.

W1: Accounting for router computation

Thank you for pointing out the router overhead. We include both Worker costs and the token costs of LLM-based routing components. For RouteWeaver, router accounting includes input and output tokens across all interaction turns, including repeated processing of interaction histories, using the accounting rule and prices in Appendix E (Table 10).

MethodWorker cost ($)LLM-router cost ($)Total cost ($)
GraphRouter0.248--0.248
Router-R11.4820.1731.655
MasRouter0.720--0.720
RouteWeaver1.7060.1601.867

Costs are totals over the same 1,060 evaluation questions and are rounded. GraphRouter and MasRouter use non-generative routing controllers and incur no additional LLM-router token charge; their LLM execution costs are included in the Worker column. Across 1,060 questions, RouteWeaver's router accounts for approximately 8.6% of its total cost and adds about 9.4% to its Worker-only cost. The multi-alpha cost curve reports Worker-only costs; the router-inclusive total here is for the main evaluated model.

W2 / Q1: Generalization across benchmarks and Worker pools

Thank you for suggesting broader generalization tests. We extend the held-out evaluation to coding (BigCodeBench, BCB) and factual recall (NQ Open), and compare against GraphRouter, Router-R1, and MasRouter alongside the existing AIME, GPQA-D, and BBH evaluations (Section 5.5, Table 4).

RouteWeaver achieves 46.6% average accuracy and leads on all five benchmarks, including 43.3% on BCB and 28.3% on NQ Open. Evaluation sample sizes are given in Appendix B.

Section 5.5 (Table 5) evaluates a modified six-Worker pool with reassigned Worker IDs and three model replacements; the replacement models are specified in that section. We reuse the original RouteWeaver checkpoint without retraining or fine-tuning, updating only the Worker descriptions, prices, and call mappings.

RouteWeaver achieves 62.8% average accuracy with the modified pool, exceeding Router-R1 by 6.9 percentage points and its own original-pool result by 1.4 percentage points. These results demonstrate transfer to the modified Worker pool without retraining RouteWeaver.

W3: Advantage decomposition versus segment normalization

The matched control in Section 5.4 (Table 2) uses ordinary GRPO advantages for both mode and execution tokens while retaining COMET-GRPO's token masks, separate segment normalization, and segment weights. All other training settings are held fixed. COMET-GRPO achieves 61.4% average accuracy versus 57.0% for this control, a 4.4-percentage-point gain with improvements in all five domains. This comparison supports the contribution of advantage decomposition beyond separate segment normalization.

Q2: Data separation and baseline implementation

We randomly sample questions without replacement within each dataset according to the quotas in Appendix B and exclude training--test overlap using question IDs. Trainable and retrieval-based routers use the same 2,880 training queries, and all methods are evaluated on the same 1,060 test questions with the same six frozen Workers.

Starting from each baseline's original settings, we adapt its implementation to our data, Worker pool, and execution limits, and tune method-specific hyperparameters to select the best-performing configuration among those evaluated under this shared setup. Router-KNN, Router-MLP, RouterDC, GraphRouter, and Router-KNN-MR use UIUC LLMRouter; Router-R1, R2-Reasoner, MasRouter, and GraphPlanner use their official implementations. Prompt LLM follows Router-R1's prompting baseline. All generative routing components use Qwen3-4B-Instruct-2507. Encoders use released pretrained checkpoints, while added heads and controllers are randomly initialized; no baseline resumes from an intermediate checkpoint. Appendix G details initialization, training budgets, and maximum Worker-call limits (Table 11).

Table 1 shows task-dependent gains: GraphPlanner exceeds Router-KNN on Code (48.3% vs. 34.8%), and MasRouter exceeds it on Code and Knowledge. Router-R1 also achieves higher average accuracy (55.3% vs. 48.7%); the lower averages of some baselines reflect losses in other domains.

Q3: Worker usage across tasks and execution modes

Appendix D (Table 9) reports Worker-call shares by task and execution mode. Across 1,060 evaluation questions, RouteWeaver makes 2,372 calls (2.24 per question). RouteWeaver uses an average of 1.58 distinct Workers per trajectory, with repeated calls to the same Worker counted once. W3 receives 62.39% of calls; W4, W5, and W6 receive 14.33%, 10.88%, and 11.21%, respectively, accounting for 36.42% together.

W3 accounts for 47.89% of Code calls and 76.52% of Reasoning calls; its share is 86.36%, 41.11%, and 71.68% in single-round, multi-round, and agentic execution, respectively. W4--W6 jointly receive 55.89% of multi-round calls. These shares include repeated calls to the same Worker.

Q4: SATBench versus BBH mode preferences and execution cases

RouteWeaver selects agentic execution for 99% of SATBench questions versus 12% on BBH. SATBench's interacting logical constraints provide explicit checks for verification and revision. BBH spans heterogeneous tasks, where the value of additional decomposition and verification varies by task.

We compare execution modes on SATBench using the same RouteWeaver checkpoint, clamping its mode at evaluation time without retraining:

ModeSATBench accuracy (%)
Clamped-single69.2
Clamped-multi69.2
Clamped-agentic73.3
Adaptive RouteWeaver76.7

Clamped-agentic exceeds both clamped-single and clamped-multi by 4.1 percentage points, supporting the usefulness of agentic execution on SATBench.

Successful case (Appendix A.2.1). In satbench_ev_0111, the first executor concludes UNSAT after the planner incorrectly fixes a variable. The verifier identifies the exact error, and the router requests re-execution. Selected excerpts are shown below; ellipses omit intervening text.

Executor (n2):
<answer>UNSAT</answer>

Verifier (n3):
FAIL
Location: Step 4, Sub-task D, Critical Observation
...
There is no direct contradiction here. The statement "if X(A,1,2) is false,
then Condition 24 requires the other three to be false" is incorrect.

Router -> executor (refs="n1,n2,n3"):
Re-evaluate the core logical constraints without assuming X(A,1,2) = true.
...

Final router output:
<answer>SAT</answer>

An independent substitution check confirms that a satisfying assignment exists for all 25 original constraints. Here, a specific verifier finding triggers corrective execution and a correct final answer.

Failed case (Appendix A.2.2). In satbench_ev_0067, original condition 6 is J1 OR NOT L2, but the planner adds a negation to J1. The later stages accept an assignment for this altered representation:

Planner (n1), translated condition 6:
6. $ \neg J_1 \vee \neg L_2 $
...

Executor (n2):
<answer>SAT</answer>

Verifier (n3):
PASS

Final router output:
<answer>SAT</answer>

The accepted assignment J1=false, L1=true, L2=true violates original condition 6. The original problem is UNSAT, as established in Appendix A.2.2. This case shows how a shared representation error can survive verification. Together, the cases illustrate both the corrective value of verification and the need to check intermediate reasoning against the original question. Appendix A.2 provides the complete call sequence and dependencies for both trajectories, with observations summarized for readability.

Q5: Adaptive versus fixed execution modes

We train fixed-single, fixed-multi, and fixed-agentic policies using the same Qwen3-4B router architecture, base initialization, training queries, six-Worker pool, and training budget as RouteWeaver. Each policy is restricted to its designated mode from the start of training through evaluation, while learning Worker selection and within-mode execution.

Worker-call limits are 1/4/8, respectively, matching RouteWeaver's corresponding mode limits. Fixed-agentic therefore shares RouteWeaver's maximum allowance of eight calls.

Section 5.4 (Table 3) reports 61.4% average accuracy for RouteWeaver versus 56.4%, 57.1%, and 58.6% for fixed-single, fixed-multi, and fixed-agentic. RouteWeaver exceeds the strongest fixed-mode policy by 2.8 percentage points and outperforms all three in every domain, supporting the benefit of adaptive mode selection under matched training settings and mode-specific call limits.

I thank the authors for the additional experiments and clarifications. The expanded cross-benchmark evaluation, the ablation controlling for segment normalization, the Worker utilization statistics, and the newly trained fixed-mode policies have addressed several of my concerns. However, a few issues remain insufficiently clarified. First, the code evaluation includes intermediate Worker outputs in the candidate set, potentially giving different execution modes different numbers of opportunities to produce a correct answer. This may affect the fairness of the comparison. Second, the authors have added an experiment that replaces three models and reassigns Worker IDs without retraining, but it does not cover adding or removing models, or changing prices independently. Moreover, the improvement from 61.4% to 62.8% does not isolate the contribution of routing adaptability from that of stronger Worker models. Although the revision strengthens the paper’s empirical support, I have decided to keep my original score unchanged.

Thank you for the detailed assessment of the revised manuscript.

First, on the Code candidate set. We rescore the retained trajectories by each system's final submitted answer only, applying the same rule to three representative baselines (for RouteWeaver, the router's final output):

MethodOriginalFinal-answer-only
GraphRouter36.136.1
Router-R152.848.4
GraphPlanner48.347.0
RouteWeaver58.254.0

RouteWeaver is still the strongest, 5.6 points above Router-R1 and 7.0 above GraphPlanner, and the five-domain average is 60.6 against 61.4 under the original protocol. The ranking does not change. We make the same clarification in our reply to Reviewer unsC.

Second, on the modified Worker pool.

(i) Prices. The router never sees prices: they are used only to compute the reported cost and, when α > 0, in the efficiency reward, so a price change moves the cost figure but not the routing decisions.

(ii) Unseen model. We add Qwen3.5-35B-A3B as a seventh Worker. The policy was trained without it and is not retrained:

PoolMathCodeKnow.Reason.RecallAvg.
Original (6 Workers)74.658.255.076.742.561.4
Qwen3.5-35B-A3B added (7 Workers)75.462.857.575.842.562.8

It selects the new Worker in 8.2% of calls, guided only by its description, and the average rises from 61.4 to 62.8, showing that the policy generalizes to unseen Workers. The gain is concentrated in Code (+4.6), Math (+0.8) and Knowledge (+2.5). The other two domains fluctuate slightly: Recall is unchanged at 42.5 and Reasoning is one question lower (76.7 to 75.8).

(iii) Adaptability. The router is frozen, so a stronger model can affect accuracy only if the router selects it. The gain therefore cannot come from the new models alone: they enter the system only through the router's calls. The policy makes those calls on a pool it has never seen. That is the adaptability we claim.

We thank the reviewer again for the careful reading of the revision and for the time given to this discussion.

Reviewer_yMpnOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

RouteWeaver trains a single router to select an execution mode—single-round, multi-round, or agentic—and then select and coordinate frozen worker models within that mode. COMET-GRPO assigns separate relative advantages to mode-selection and execution tokens. A progressive exploration schedule first trains execution under assigned modes and gradually releases mode selection to the router. Experiments evaluate accuracy, worker inference cost, routing behavior, and generalization to held-out benchmarks.

Critical strengths
  1. Learning how to organize model calls is a worthwhile extension of model routing. The common action format makes the proposal concrete, and the results are strong across several task domains. The held-out benchmark results provide additional evidence that the learned router is doing more than fitting the training datasets.

  2. The paper examines both performance and training behavior. Removing progressive exploration produces complete collapse to single-round execution and a substantial accuracy loss. Replacing COMET-GRPO with ordinary GRPO also reduces performance. The cost-aware experiments further show that the same framework can learn different accuracy–worker-cost operating points.

Critical weaknesses
  1. The most direct test of adaptive mode selection is missing. The paper compares against existing routers, but does not train three fixed-mode versions using the same router, execution grammar, worker pool, and budget. Such controls would show whether selecting a mode per query is better than simply improving execution within one mode. The strongest individual worker and a router-only baseline would also help establish the value of routing itself. Without these comparisons, part of the gain could come from differences in execution or training rather than mode adaptation.

  2. The COMET-GRPO ablation changes both the advantage assignment and the relative weighting of mode and execution tokens. Equation (9) normalizes the two segments separately, whereas ordinary GRPO uses a global token average. The improvement therefore does not isolate the proposed credit decomposition. With eight rollouts divided across three modes, some mode subsets may also contain only one trajectory, giving zero within-mode advantage. The paper does not report how often this removes the execution-learning signal. Evaluation uses one system rollout per question and provides no uncertainty estimates.

Questions for authors
  1. How does RouteWeaver compare with fixed-single, fixed-multi, and fixed-agentic policies trained within the same framework? What are the strongest individual-worker and router-only results?

  2. Does COMET-GRPO still improve over GRPO when both use the same separate normalization of mode and execution tokens? How frequent are singleton mode subsets and zero execution advantages?

  3. Could you separate the effects of forced-mode scheduling and the mode-support penalty? The current ablation removes both.

  4. How does the cost comparison change when router computation is included? Please also clarify the training and call budgets used for the strongest baselines and report uncertainty for the main accuracy differences.

5 comments

We sincerely thank you for your careful review and constructive feedback. Your comments have helped us strengthen the evaluation and clarify the presentation. We address your concerns below. Changes in the revised PDF are highlighted in blue.

W1 / Q1: Fixed-mode policies and direct-answer baselines

We train fixed-single, fixed-multi, and fixed-agentic policies within the same framework, sharing RouteWeaver's router architecture, training queries, six-Worker pool, and training budget. Each policy uses its designated mode throughout training and evaluation, with Worker-call limits of 1/4/8. Here, fixed-* policies are trained from the same base initialization with the mode fixed from the start; clamped-* variants instead lock the same trained RouteWeaver checkpoint to a mode only at evaluation time.

Section 5.4 (Table 3) reports the domain-level results. RouteWeaver achieves 61.4% average accuracy versus 56.4%, 57.1%, and 58.6% for fixed-single, fixed-multi, and fixed-agentic, respectively. It exceeds the strongest fixed-mode policy by 2.8 percentage points and outperforms all three policies in every domain.

Table 3 also reports direct-answer controls: the strongest Worker, Qwen3-30B-A3B-Instruct-2507 (44.8% Avg.), and the base and trained routers (32.3% and 26.8%). These controls answer the original questions directly without routing or Worker interactions.

W2 / Q2: Separating advantage decomposition from segment normalization

Thank you for identifying this confound. We evaluate a GRPO + segment normalization control that uses ordinary group-relative advantages for both mode and execution tokens, while retaining the same token masks, separate segment normalization, and segment weights as COMET-GRPO. All other training settings are held fixed.

Section 5.4 (Table 2) reports 61.4% average accuracy for COMET-GRPO versus 57.0% for this control. With segment normalization matched, the gain is 4.4 percentage points, and performance improves in all five domains. This comparison supports the contribution of mode/execution advantage decomposition beyond separate segment normalization.

After cold start, there are 9,936 autonomously selected rollouts and 6,704 forced-mode rollouts. Among the autonomous rollouts, 749 (7.54%) belong to singleton mode subsets, and 967 (9.73%) have zero execution advantage.

StatisticCount / autonomous rolloutsPercentage
Rollouts in singleton mode subsets749 / 9,9367.54%
Rollouts with zero execution advantage967 / 9,9369.73%

Singleton subsets necessarily produce zero within-mode execution advantage; non-singleton subsets can also produce zero advantage when their rewards coincide. A zero execution advantage does not imply zero mode-selection advantage.

Q3: Separating forced-mode scheduling and the support penalty

Thank you for suggesting these separate controls. We remove the support penalty while retaining forced-mode scheduling, and separately remove forced-mode scheduling while retaining the original support-penalty coefficient schedule. All other training settings are held fixed.

Section 5.4 (Table 2) reports 51.9% average accuracy without the support penalty and 55.5% without forced-mode scheduling, compared with 61.4% for RouteWeaver: decreases of 9.5 and 5.9 percentage points, respectively. Both removals reduce performance in every domain, supporting a contribution from each mechanism when the other is retained. Forced-mode scheduling provides execution experience across modes, while the support penalty discourages premature concentration of mode-selection probabilities.

Q4: Router-inclusive costs, budgets, and uncertainty

Thank you for pointing out the router overhead. We include both Worker costs and the token costs of LLM-based routing components. For RouteWeaver, router accounting includes input and output tokens across all interaction turns, including repeated processing of interaction histories, using the accounting rule and prices in Appendix E (Table 10).

MethodWorker cost ($)LLM-router cost ($)Total cost ($)
GraphRouter0.248--0.248
Router-R11.4820.1731.655
MasRouter0.720--0.720
RouteWeaver1.7060.1601.867

Costs are totals over the same 1,060 evaluation questions and are rounded. GraphRouter and MasRouter use non-generative routing controllers and incur no additional LLM-router token charge; their LLM execution costs are included in the Worker column. Across 1,060 questions, RouteWeaver's router accounts for approximately 8.6% of its total cost and adds about 9.4% to its Worker-only cost. The multi-alpha cost curve reports Worker-only costs; the router-inclusive total here is for the main evaluated model.

For the strongest external baseline, Router-R1 uses PPO for 45 steps with 64 queries per batch and one rollout per query, with at most four Worker calls per question. RouteWeaver uses 90 steps with 32 queries per batch and eight rollouts per query, including cold start, and mode-specific call limits of 1/4/8. Both use the same 2,880 training queries and six frozen Workers; method-specific settings are summarized in Appendix G (Table 11). The trained fixed-mode policies and the GRPO + segment normalization control use the same training budget as RouteWeaver.

We report 95% confidence intervals for the main average-accuracy differences, computed using paired bootstrap resampling of the evaluation questions:

Comparison with RouteWeaverComparator Avg. (%)Difference (pp)95% CI of difference (pp)
Router-R155.3+6.1[1.70, 10.50]
Fixed-agentic58.6+2.8[-1.57, 7.17]
GRPO + segment normalization57.0+4.4[0.0, 8.8]

These differences use RouteWeaver's 61.4% average accuracy and the corresponding main/control evaluation results. RouteWeaver improves over each comparator in all five domains. The intervals quantify question-level sampling uncertainty for the evaluated checkpoints.

Dear Reviewer yMpn,

We understand that the discussion schedule may not align perfectly with your availability, but we would greatly value your feedback before it closes. Could you please let us know whether our rebuttal and additional experiments have sufficiently addressed your concerns?

Thank you again for your constructive feedback. If you find that your concerns have been resolved, we would be grateful if you could reconsider your review score.

Reviewer_unsCOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

RouteWeaver uses one trainable router to select among single-round, multi-round, and role/dependency-structured agentic execution with a frozen pool of six Worker models. COMET-GRPO assigns separate group-relative advantages to mode selection and within-mode execution, while progressive exploration transitions from assigned modes to autonomous selection. Experiments cover five domains, compare routers from three paradigms, study Worker-cost trade-offs, and evaluate transfer to held-out benchmarks. The main setting reaches 61.4% domain-averaged accuracy versus 55.3% for Router-R1.

Critical strengths
  1. Jointly adapting execution structure and Worker choice is a useful routing objective. The common action grammar makes the three supported modes explicit, and the separation of context observations from trainable router tokens is clearly documented. The method also recognizes that learning a mode choice requires sufficient experience executing that mode, making the progressive schedule well motivated.

  2. The evaluation spans several domains and includes both optimization ablations and held-out benchmarks. Removing COMET-GRPO reduces the reported average from 61.4 to 58.8, while removing progressive exploration leads to single-mode collapse and a 55.6 average. The reported 53.7 average on AIME/GPQA-D/BBH versus 45.4 for Router-R1 is also encouraging. Detailed treatment of masks, forced groups, singleton-mode groups, and cost definitions helps readers understand the implementation and avoids claiming an unbiased policy gradient that the decomposition alone would not establish.

Critical weaknesses
  1. The coding evaluation does not isolate final-solution quality from additional candidate opportunities. Appendix C explicitly states that the scorer considers code blocks from Worker outputs as well as the final router answer, with the candidate count depending on execution mode; it is therefore not standard pass@1. Together with different mode call limits, this can reward producing more candidates even when the router does not select a correct final solution. The disclosure is helpful, and this issue does not invalidate the non-code results. However, without final-answer-only rescoring and a clear account of baseline candidate/call budgets, the Code improvement and its contribution to the headline average are difficult to interpret as evidence of better routing.

  2. The central benefit attributed to adaptive mode selection is not cleanly isolated from the execution policy and training recipe. Table 2 tests the optimizer and curriculum, but both variants still use the unified action space. Comparisons with separate published routers change several ingredients beyond whether the mode is fixed, and some domains choose essentially one mode almost all the time. Thus, the results do not yet establish how much is gained by per-query mode choice over a simpler fixed or domain-conditioned policy using the same learned executor. The current ablations support the overall training system, but leave an evidence gap for the central unification claim.

Questions for authors
  1. Could you rescore the existing code trajectories using only the final submitted router answer, and apply the same rule to the main baselines where their outputs are available? Please report candidate counts and actual Worker-call distributions, and explain whether the training reward also uses the union scorer. This requires re-scoring retained outputs rather than generating a new coding benchmark.

  2. Could you provide a small controlled comparison in which the existing router checkpoint is forced to use each mode, along with the learned mode choices, under a common final-answer scorer and comparable call/token limits? A simple fixed or domain-conditioned mode policy would help assess the value of per-query adaptation. Please acknowledge that clamping an existing checkpoint is a diagnostic rather than an optimally retrained fixed-mode specialist; full retraining of three specialists is not necessary for this response.

  3. Please tabulate the main baselines' router initialization, optimization data, training budget, Worker pool, maximum calls, and scoring protocol. These details would show which comparisons control the execution resources and which demonstrate a broader system-level advantage. In particular, clarify whether all multi-call code baselines receive the same union-scoring opportunity.

4 comments

We sincerely thank you for your careful review and constructive feedback. Your comments have helped us strengthen the evaluation and clarify the presentation. We address your concerns below. Changes in the revised PDF are highlighted in blue.

W1 / Q1: Final-answer-only Code evaluation

Thank you for highlighting this distinction. We rescore the retained Code trajectories using only each system's final submitted answer, excluding intermediate candidates, and apply this rule consistently to three representative baselines. For RouteWeaver, this is the router's final output.

MethodOriginalFinal-answer-only
GraphRouter36.136.1
Router-R152.848.4
GraphPlanner48.347.0
RouteWeaver58.254.0

Code accuracy (%). RouteWeaver remains the strongest method among these comparisons under final-answer-only scoring, exceeding Router-R1 by 5.6 percentage points and GraphPlanner by 7.0 percentage points. With the non-Code scores unchanged, RouteWeaver's five-domain average becomes 60.6%, compared with 61.4% under the original scoring protocol.

The training reward uses the original union scorer described in Appendix C. The results above are obtained by rescoring retained outputs without retraining.

The following candidate and Worker-call statistics cover the Code domain only.

MethodAvg. candidates (original scorer)Avg. Worker calls1 call2–3 calls4+ calls
GraphRouter1.001.00100%0%0%
Router-R12.721.7636%64%0%
GraphPlanner3.043.040%70%30%
RouteWeaver3.502.584%85%11%

Call distributions report the percentage of questions in each bin. Under the updated protocol, each method has one final-answer evaluation opportunity per question; intermediate code candidates are excluded. GraphRouter makes one Worker call and uses that Worker's output as its final submitted answer.

W2 / Q2: Isolating the benefit of adaptive mode selection

Thank you for suggesting this diagnostic. We evaluate the existing RouteWeaver checkpoint with its execution mode clamped to single, multi, or agentic, without retraining. All variants use the same Workers and evaluation questions and are scored using only their final submitted answers. For RouteWeaver, this is the router's final output. The mode-specific Worker-call limits remain 1, 4, and 8, respectively; adaptive RouteWeaver uses the same limit for its selected mode. All variants use the same token limits specified in Appendix F: 6,144 prompt tokens, a 12,288-token multi-turn response budget, and 2,048 tokens per observation.

MethodMathCodeKnowledgeReasoningRecallAvg.
Clamped-single71.343.851.769.242.155.6
Clamped-multi72.952.750.869.239.657.0
Clamped-agentic73.851.949.273.340.057.6
RouteWeaver74.654.055.076.742.560.6

Accuracy (%); Avg. is the unweighted mean across the five domains. Adaptive RouteWeaver achieves 60.6% average accuracy, exceeding the strongest clamped-mode variant (57.6%) by 3.0 percentage points and outperforming all three variants in every domain. Clamped-agentic shares the same maximum allowance of eight Worker calls. As requested, we interpret checkpoint clamping as a diagnostic, rather than an optimally trained fixed-mode specialist. Separately trained fixed-mode policies are reported in Section 5.4 (Table 3).

Q3: Baseline initialization, training data, and execution budgets

Thank you for asking us to clarify the comparison settings. All LLM-based routing components are initialized from Qwen3-4B-Instruct-2507. Trainable and retrieval-based routers use the same 2,880 training queries. Encoders are loaded from their released pretrained checkpoints, and all added heads and controllers are randomly initialized with no warm start from other methods (Appendix G). No baseline resumes from an intermediate checkpoint. All methods share the same six frozen Workers and evaluation questions. Starting from each baseline's original settings, we adapt its implementation to this shared experimental setup and tune method-specific hyperparameters to obtain the best-performing configuration among those evaluated, supporting a fair comparison with RouteWeaver under consistent conditions.

Appendix G (Table 11) tabulates the router backbones, training budgets, and maximum Worker calls. We retain each method's training procedure: Router-KNN, Router-KNN-MR, and Prompt LLM need no gradient updates, while trainable baselines use their method-specific optimization schedules. For example, Router-R1 uses PPO for 45 steps with batch size 64 and one rollout per query; RouteWeaver uses 90 steps with batch size 32 and eight rollouts per query, including cold start.

The maximum Worker-call limits are 1, 4, and 8 for single-round, multi-round, and agentic execution, respectively. Under the original scoring protocol, all multi-call Code baselines receive the same union-scoring opportunity as RouteWeaver. The final-answer-only rescoring in W1/Q1 likewise applies the same rule to all compared methods. The scoring protocol is described in Appendix C. These comparisons control the training-query set, Worker pool, and evaluation protocol while retaining method-specific training schedules and execution budgets.

Thank you for rescoring the final answers and adding the fixed-mode comparisons. The advantage on Code persists when each system is scored only on its final answer, and adaptive routing consistently outperforms the individual modes when the checkpoint is held fixed. These analyses address my two main concerns. Training budgets still matter when interpreting comparisons across systems, but the new evidence is sufficient for me to raise my overall rating from 2 to 3.

Thank you for the updated assessment. On the training-budget point, the budgets in Table 11 are those of each method's own implementation: all methods are trained on the same query subset, and we did not shorten any baseline's schedule to fit ours. Each system is therefore compared as released. We will state this explicitly where Table 11 is introduced in the final version.

Thank you again for your time and thoughtful evaluation. We truly appreciate your constructive feedback and support.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of Revisions and Additional Experiments

We sincerely thank the Area Chair and all reviewers for their thoughtful and constructive feedback. During the rebuttal, we have strengthened RouteWeaver through additional controlled experiments, expanded generalization evaluations, and more comprehensive methodological and experimental analyses. Below, we summarize the major concerns, our actions, and key findings.

DimensionKey ConcernsOur Main ActionsKey Findings
Adaptive Mode SelectionDoes adaptive routing outperform fixed execution modes under comparable settings?Added separately trained fixed-mode policies and same-checkpoint clamped-mode comparisons.RouteWeaver outperforms the strongest fixed and clamped variants by 2.8 and 3.0 percentage points, respectively.
Baseline Settings & Cost AnalysisAre baseline comparisons fair, and how much overhead does the router introduce?Clarified baseline initialization, training data, optimization budgets, and Worker-call limits. Added router-inclusive cost and uncertainty analyses.Trainable and retrieval-based routers share the same training-query set and all methods use the same Worker pool, with method-specific training schedules. Router computation accounts for 8.6% of RouteWeaver's total token cost.
Methodological ValidationWhat are the individual contributions of COMET-GRPO and progressive exploration?Added a segment-normalization-matched GRPO control and separate ablations of forced-mode scheduling and the support penalty.COMET-GRPO improves accuracy by 4.4 points over the matched control. Removing forced-mode scheduling or the support penalty reduces accuracy by 5.9 and 9.5 points, respectively.
Generalization & AdaptabilityCan RouteWeaver generalize to unseen benchmarks and changes in the Worker pool?Expanded held-out evaluations and conducted Worker replacement and addition experiments without retraining.RouteWeaver outperforms all compared baselines across five held-out benchmarks, achieves 62.8% average accuracy after Worker replacement, and assigns 8.2% of calls to a newly introduced Worker, without retraining.
Evaluation FairnessDoes the Code scoring protocol favor methods with more intermediate candidates?Conducted final-answer-only evaluations across RouteWeaver and three representative baselines, with additional candidate and Worker-call statistics.RouteWeaver retains its advantage on Code (54.0% vs. 48.4% for Router-R1), achieving 60.6% average accuracy across five domains.

Overall Assessment After Rebuttal

The additional experiments strengthen the empirical evidence for three central contributions of RouteWeaver:

  1. Unified routing: Adaptive mode selection consistently improves upon separately trained fixed-mode policies and same-checkpoint controls.
  2. Effective optimization: COMET-GRPO and progressive exploration contribute to learning a unified routing and execution policy.
  3. Generalization: The learned routing policy transfers across held-out benchmarks and adapts to previously unseen Workers without retraining.

Appreciation

We sincerely appreciate the Area Chair and reviewers for their valuable time, careful assessments, and constructive suggestions. Their feedback has substantially improved the experimental rigor, clarity, and reproducibility of RouteWeaver. We hope the additional results and clarifications provide a stronger basis for evaluating our work.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.