acceptodds
Under review as a conference paper at ICLR 2027

PAIR: Pool-Adapter Inference for Routing in Training-Free LoRA Composition

Abstract

Large language models are increasingly deployed with growing libraries of task-specific low-rank adaptation (LoRA) adapters that share a backbone. A practical router must operate without task labels or examples, accommodate newly arriving adapters, and avoid scoring the entire pool for every input. We introduce PAIR (Pool-Adapter Inference for Routing), a training-free hierarchical router that treats a LoRA library as a searchable index rather than a flat list. PAIR constructs weight-only fingerprints from each adapter's last-block LoRA factors and organizes them with an online Dirichlet-process Gaussian mixture. New adapters are incorporated from their LoRA weights alone; no learned router is trained or retrained. For routing, a single adapter-free backbone forward produces the hidden state used to rank cluster representatives. PAIR then evaluates additional candidates only within selected clusters and composes the selected adapters with a calibrated compatibility score. We evaluate PAIR on 26 datasets, three 7B/8B backbones, and three backbone-specific pools of 260 adapters. On LLaMA-3.1-8B, PAIR achieves a five-family macro score of , versus for the strongest evaluated non-PAIR baseline. Holding top- uniform composition fixed, hierarchical routing alone improves the macro by points while reducing adapter-score evaluations from to a median of per input. In an isolated single-threaded CPU benchmark, median per-adapter insertion time is – ms across the tested pool sizes of – adapters, with no backbone forward.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Low-Rank Adaptation (LoRA), Parameter-Efficient Fine-Tuning (PEFT), Adapter Routing, Adapter Composition, Training-Free Routing

Reviews

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

This paper studies routing over a large pool of LoRA adapters sharing the same backbone. PAIR builds compact fingerprints for adapters, clusters them, and uses hierarchical routing to select and combine a small set of adapters for each input. It does not require task labels or a trained router. Experiments across several backbones and datasets show better performance than existing routing baselines while reducing the number of adapter evaluations.

Critical strengths
  1. Scoring every adapter becomes expensive as the pool grows, so this is a useful problem to study.
  2. Fixing the composition strategy while changing only the router gives a cleaner comparison.
Critical weaknesses
  1. Eq. (4) worries me because sm(x)s_m(x) changes with the set of adapters scored together. Level-1 and Level-2 use different sets, but the paper still reuses and compares these scores. I do not see why they should be comparable across stages.
  2. I am also not convinced by the JL argument. The projection is only applied to one side of ΔW\Delta W, while the standard JL lemma assumes a full random projection. The paper should clarify what is actually preserved and what assumptions on BB are needed.
Questions for authors
  1. Table 1 reports around 190 adapter-score evaluations per input, while the last row of Table 3 reports 92 for what seems to be the same setting. What causes this difference?
  2. How were the routing hyperparameters chosen, eg. (kc,kprobe,ks)(k_c, k_{\text{probe}}, k_s), top-20 composition, η\eta, and τz\tau_z? The paper says no evaluation examples are used for tuning, so it would be useful to clarify what data was used.
4 comments

Thank you for your review. It recognises the practical routing problem and the comparison that fixes the composition and changes only the router. Your two technical concerns lead to the clarifications below: we state the stage-specific scoring rule, test a shared-reference alternative, and give the row-wise argument for the one-sided sketch. The Update are listed in the general response.

W1. Comparing scores across stages

The two stages make separate rankings with their own reference sets. Level-1 standardised scores are not reused in the Level-2 ranking. We denote by sm(x;S)s_m(x;\mathcal S) the response of adapter mm to input xx, standardised within the reference set S\mathcal S. Eq. (4) then reads:

s_m^{(2,k)}(x)=s_m(x;\mathcal M_k).$$ Here $\mathcal R$ contains all representatives and $\mathcal M_k$ the candidates of cluster $k$. Level 1 compares clusters within $\mathcal R$. Level 2 ranks the candidates of a selected cluster within $\mathcal M_k$. The final weight is $$\pi_m(x)=\widetilde s_{k(m)}(x)\cdot\nu_m\cdot s_m^{(2,k(m))}(x),$$ where $\widetilde s_{k(m)}$ is the cluster score of adapter $m$ and $\nu_m$ its centrality. The three factors are relative; they are not calibrated to a common absolute scale. On a fixed routed set, the product adds **+0.30 [0.03, 0.56]** over uniform weights. **We tested the shared-reference alternative that your concern suggests.** The ablation standardises Level-2 responses with the Level-1 reference statistics, so that both stages share one reference set. The routed set stays the same for 99.5% of 5,637 inputs. The weights concentrate: the effective number of adapters $1/\sum_m w_m^2$, with $w_m=\pi_m/\sum_j\pi_j$, falls from 7.5 to 3.8. The macro falls by **5.61 [4.97, 6.27]**. This supports local standardisation for the tested weighting rule. **The matched control does not depend on the weight product.** It uses uniform weights. It evaluates the complete selection procedure, which includes the stage-specific standardisation. Algorithm 1 states that Level 2 reuses cached Level-1 outputs; this does not describe the implementation (Update 3). ### W2. What the one-sided projection preserves **A full random projection of the vectorised update is not required. A one-sided Gaussian projection suffices for the Frobenius-distance guarantee on the raw sketch.** Right multiplication by the sketch matrix $\Xi$ applies a Gaussian projection to every row of the update. The argument has three steps: Gaussian concentration for each row, a union bound over rows and adapter pairs, and the sum over squared row norms. These steps bound the pairwise Frobenius distances within distortion $\varepsilon$, with failure probability $\delta$, for sketch width $N=O(\varepsilon^{-2}\log(d_LM/\delta))$. Here $d_L$ is the number of rows and $M$ the pool size. For a fixed nonzero difference $D$ of two updates and independent entries $\Xi_{ij}\sim\mathcal N(0,1/N)$, $$\mathbb E\lVert D\Xi\rVert_F^2=\lVert D\rVert_F^2,\qquad \frac{\operatorname{Var}\lVert D\Xi\rVert_F^2}{\lVert D\rVert_F^4} =\frac{2\lVert D^\top D\rVert_F^2}{N\lVert D\rVert_F^4}\le\frac2N.$$ The second relation gives the scale of the distortion. The argument assumes a fixed finite pool that is independent of the shared $\Xi$. It requires no rank or incoherence condition. **The formal guarantee applies to the raw sketch.** Normalisation and PCA are later representation stages, and the Appendix B sentence should not have extended the guarantee to them. At width $N=64$, we drew five independent sketches of all 33,670 LLaMA adapter pairs. The ratio of sketched to exact distances has pooled 1st–99th percentiles of **0.864–1.090**, and the mean rank correlation is **0.995**.

Q1. Why 190 in Table 1 but 92 in Table 3?

We traced the difference to the Level-1 counter of Table 3, which counted 80 clusters instead of 178 representatives and therefore undercounts by 98. The complete count has median 190 and range 185–200. A replay of all 60,619 inputs with unchanged routed sets confirms it. The count includes repeated scores of the same adapter across stages; the number of distinct adapters has median 179 (Update 3).

Q2. Hyperparameter selection

The configuration was developed on LLaMA with BBH sweeps and a fixed subset of up to 128 examples per task. Both overlap the evaluation suite, which updates the submission's statement that no evaluation examples informed tuning (Update 1). The composition cap of 20 matches LoGo. The stored development runs vary kck_c, kprobek_{\mathrm{probe}}, the per-cluster quota, η\eta, and the selection and scoring rules on these sets, including the rule that expands from four to five clusters. Six scoring variants were also compared on the full suite, and the final configuration had the highest macro.

Qwen and DeepSeek use the LLaMA configuration without further tuning. After excluding all BBH tasks and the development subset, 57,562 examples remain across 18 tasks. On their four-family macro, a post-hoc analysis gives a matched LLaMA selection difference of +0.91 [0.76, 1.06] (Update 1).

Summary. This reply gives the stage-specific scoring definitions, a direct standardisation ablation, and the row-wise argument for the raw-sketch guarantee. Together with the updated count and the fixed-composition comparison that your review recognises, they are the evidence for PAIR's selection procedure. We would appreciate your reassessment in light of these additions and of the configuration-selection protocol in Q2. Thank you again for your time and for the precise questions.

Thank you for the detailed response. The stage-specific scoring explanation and the clarification of the raw-sketch guarantee address much of my technical concern, and the evaluation-count discrepancy is now explained. However, the tuning protocol raises a more substantial concern: scoring variants were compared on the full evaluation suite, and the best-performing configuration was selected. Removing the development subset afterwards does not provide an independent evaluation. I would need results on an untouched test set with the configuration fixed to be convinced of the reported gains. I am therefore keeping my rating at 2.

Thank you for confirming that the scoring, sketch, and count questions are resolved.

We evaluated the unchanged submitted configuration on 6,799 previously unused validation examples from 14 non-BBH tasks. These examples were not used for development or for any reported evaluation. The arms, the primary comparison and both scoring rules were fixed in writing before the run. LoGo and LoRARetriever used their Table 1 settings and the same generation budgets as PAIR.

With ARC answers credited as either option letters or option text, and all other scoring unchanged, the four-family macro differences are:

ContrastDifference, 95% bootstrap interval
PAIR − Base+1.79 [1.26, 2.34]
PAIR − Flat, matched adapter count+0.91 [0.52, 1.31]
PAIR − LoGo+1.63 [1.23, 2.05]
PAIR − LoRARetriever+1.16 [0.68, 1.65]
PAIR − Fixed combination from development inputs+0.05 [−0.16, 0.26]

The fixed combination applies PAIR's average weights on the development subset to every input, without routing. Under the paper scorer the five differences are +1.51, +2.27, +1.52, +0.96 and −0.19; the first four intervals exclude zero.

The prespecified hierarchy−flat comparison, with uniform weights in both arms, gives +1.73 [1.23, 2.23] under the paper scorer and +0.28 [−0.09, 0.65] under the predefined ARC content-scoring check. On a separate evaluation of 19 BBH tasks outside the suite, exact match is below 5% in every arm because the outputs are mostly option text; scored by option content on the 17 multiple-choice tasks, a rule defined after those outputs were seen, the same comparison gives −0.99 [−2.37, 0.40].

The requested independent evaluation is now available: full PAIR retains positive gains over Base, Flat, LoGo, and LoRARetriever on previously unused examples. We distinguish these full-method gains from the more limited evidence for hierarchy alone or dynamic routing over fixed composition. We would appreciate your reassessment in light of this new evidence.

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

PAIR proposes a training-free router for a growing library of LoRA adapters sharing a backbone. It builds an index from weight-only adapter fingerprints using an online Dirichlet-process Gaussian mixture, then selects adapters through representative-first, two-stage routing and combines them with input-dependent weights. The paper evaluates downstream task quality, routing efficiency, and incremental index maintenance. Its central finding is that structured selection can improve the resulting adapter set, rather than merely approximating exhaustive ranking more cheaply.

Critical strengths
  1. Practical and well-defined problem. Training-free, input-dependent selection from a changing LoRA library is an important deployment problem. The weight-only indexing setup directly addresses the lack of task data and the cost of retraining a learned router.
  2. Evidence for selection quality, not just search efficiency. The controlled comparison separating active-set selection from composition weights supports the paper's most consequential claim: the hierarchy can produce a more effective adapter set than flat ranking under matched composition.
Critical weaknesses
  1. The need for the proposed DP-based machinery is not established. The approach combines familiar sketching, clustering, and hierarchical retrieval components, without an adequately matched comparison to a simpler index. Consequently, the distinctive methodological contribution remains uncertain.
  2. The scalability case is not yet convincing. Representative scoring still covers much of the pool, the study uses relatively limited and homogeneous libraries, and the large serving-speed advantage is entangled with differences in backbone capture and adapter activation. This leaves the independent benefit of hierarchical indexing unclear.
Questions for authors
  1. Methodological necessity: Under matched fingerprints, representative budgets, scoring, and composition, what does the DP-based index improve over K-means or a fixed-component GMM index?
  2. Scalability: As the pool grows and new task families arrive, how do representative count, routing quality, and the full per-insertion maintenance cost scale, including any reassignment of stored adapters?
  3. Efficiency attribution: Can flat and hierarchical routing be compared using the same backbone-state capture and adapter-activation implementation, so that the latency benefit of the search strategy is isolated?
1 comment

Thank you for your thoughtful review and clear questions. It identifies two strengths of PAIR: the practical problem of training-free, input-dependent routing over a changing adapter library, and the evidence for selection quality under matched composition.

Weight-only indexing addresses a deployment constraint. For a fixed configuration, PAIR builds and updates its index from adapter weights. It requires no adapter training examples and trains no router.

The matched control evaluates selection quality, not only search efficiency. On LLaMA, PAIR's selection improves the macro by 2.43 points [2.03, 2.84] over flat selection. Both arms use the same backbone capture, raw adapter-response computation, per-input composition cardinality, and uniform weights. The difference therefore comes from the selection procedure, not from composition size or weighting. As your summary states, the index guides the construction of the composed set; it does not only approximate a flat ranking at lower cost.

Q1. DP-GMA versus GMM and K-means: matched component count, shared caps

DP-GMA has the highest macro of the three tested indexes under shared routing rules and caps. It also determines the component count from the pool. DP-GMA selected K=80K=80 components. We fitted the GMM and K-means at the same KK. All three indexes ran in one job over 60,619 inputs with identical fingerprints, routing rules, caps, and composition rule.

IndexRepresentativesMacroDifference to DP-GMA
DP-GMA17847.88—
Diagonal GMM18547.03−0.85 [−1.20, −0.52]
K-means18946.39−1.49 [−1.80, −1.17]

Outside BBH and the development subset, the differences are −0.16 [−0.30, −0.02] and −1.90 [−2.08, −1.72]. With tasks also resampled, the intervals are [−0.41, 0.09] and [−3.35, −0.79]. Each arm replaces the complete index state, so the representative counts and the mean composition sizes (12.23/11.43/11.12) differ. K-means uses nearest-centroid representatives and cluster-size shares as weights.

Q2. Pool size, insertion cost, and arriving task families

Representative count. We denote by RR the number of Level-1 representatives and by MM the pool size. In separately fitted pools of 65/130/195/260 adapters (three random subsets per size and one refit of the full pool), the fraction R/MR/M falls from 97% to 70%. With one representative per cluster (Table 3), PAIR scores 80 representatives and uses a mean of 92 evaluations per input. This count is correct for this variant. Its macro is 47.42 against 47.94, and outside BBH and the development subset the difference is +0.01 [−0.15, 0.18].

Complete insertion, including the refresh that recomputes the assignment of every stored adapter, costs O(Cfp+MtKtd)O(C_{\mathrm{fp}}+M_tK_td) and takes 32–34 ms at 260 adapters (Update 4).

Arrival quality. We compare a streamed index with a fresh fit of the same final pool on 60,619 inputs. The streamed index scores lower:

Initial pool and arrivalsMacroDifference to full fit (47.71)
Random 200, then 60 arrivals45.30−2.41 [−2.79, −2.03]
233 outside evaluation-task families, then those 27 arrivals46.16−1.56 [−1.97, −1.15]

One likely contributor is poor representation of the arrivals by the PCA basis, which is frozen at the initial fit. Insertion makes new members available at once. A full rebuild takes about 6 s on eight CPU threads at this size. The 47.71 reference is a new fit of the 260 adapters. It assigns 235 of them to the same cluster as the paper's stored index (paired difference −0.17 [−0.47, 0.13]).

Q3. Isolating the search strategy's latency benefit

Hierarchical routing executes a median of 190 adapter evaluations, where flat scoring executes 260. The available timings do not isolate a wall-clock speedup from this reduction. The recorded hierarchical and flat routing profiles use different batch configurations, so they cannot be compared. Single-request measurements place the gap to LoGo in the capture step. Capture takes 1.08–1.36 s with all adapters active and 21–69 ms adapter-free, while scoring is below 3 ms for both. The serving-time difference reported in the paper should therefore not be read as a hierarchy-only speedup.

Summary. The central empirical finding is the LLaMA matched control: selection guided by the weight-only index improves the composed set under matched generation settings. The index comparison (Q1) and the maintenance measurements (Q2) characterise the trade-offs of this design. The reduction in adapter evaluations (Q3) is reported separately from end-to-end serving speed. Thank you again for your time and consideration.

Comments on the paper

6 comments

Thank you for the detailed and constructive review. We are grateful that it identified the accounting inconsistency and the controls needed to assess PAIR. Your review lists the weight-only index and the controlled comparisons with matched uniform composition among the strengths. We first state what this matched control shows about the method.

PAIR uses the structure of the adapter pool to construct the composed set, the set of adapters that is composed for an input. The index is part of the selection procedure; it is not only a way to reduce the cost of a flat ranking. Flat selection scores every adapter and keeps the highest-scoring ones. A full scan is exhaustive with respect to the individual scoring rule, but it is not an oracle for the quality of the composed set. PAIR first selects clusters of the weight-only index and then selects members within each selected cluster. The matched control tests this selection procedure. Both arms use the same backbone capture, raw adapter-response computation, per-input composition cardinality, and uniform weights; only the selection procedure changes. On LLaMA, PAIR's selection improves the macro by 2.43 points [2.03, 2.84] over flat selection. The paper's introduction presents this control as its more important result. The control is separate from serving time.

The points below address three separate questions. Points 2 and 3 update the cost accounting. The updated count comes from a replay that reproduces every routed set, so the update changes the accounting and not the selection result. Points 5 and 7 examine the composed set; the quota sweep that you requested shows that retaining several members of a selected cluster improves the composition. Points 1, 4 and 6 concern deployment cost and transfer.

1. Extra backbone prefill

PAIR performs one extra adapter-free prefill, and its KV cache is not reused for composed generation. We measured single requests on an H100, with 30 prompts per length, and report medians. For prompts of 114–1,834 tokens, routing takes 26–73 ms, while the base model's time to first token is 20–66 ms. Within routing, capture takes 21–69 ms and scoring about 2.6 ms. LoGo's capture, with all 260 adapters active, takes 1.08–1.36 s in the tested implementation. The extra prefill is therefore a cost that grows with prompt length. These are component timings. We did not run a comparison with a trained router.

As a shared-generation control, we composed LoRARetriever's top-20 sets and PAIR's routed sets (12.7 adapters on average) with the same uniform rule and generation code on 10,137 inputs. PAIR's routed sets lead by 8.2 points on BBH, which was used in development. Each other family differs by at most 1.5 points, in either direction.

2. Adapter-scoring counts

We traced the discrepancy to the Level-1 counter, which counted 80 clusters instead of 178 representatives .

QuantityRangeMedian
Old counter87–10292
Complete adapter-score evaluations185–200190
Distinct adapters scored178–186179

We obtained these counts from an instrumented replay of all 60,619 inputs. The replay changes only the instrumentation, not the executed path, and reproduces every routed set. Level 2 re-executes the factor chain for representatives that are also candidates, because raw responses are not cached. Each cluster has up to three representatives, so Level 1 already scores most candidates of the selected clusters, and Level 2 adds few new adapters (median one). In this configuration, Level 2 ranks the members within the selected clusters and sets the local factor of the weights. Table 3's two affected entries are per-input means, as in that column. They become 192 and 190.

Executed cluster rule. The implementation selects five clusters when the highest cluster score is below 1.3 times the second, and four otherwise. This rule was part of the default configuration in every reported run. It selects five clusters on 90.5% of LLaMA inputs. The ceiling on evaluations is therefore 253, where the paper states 238 for four clusters. To measure the rule's effect, we remove the fifth cluster's adapters from the routed sets, keep the first four clusters unchanged, and renormalise the weights. The macro changes by −0.35 [−0.72, 0.01] on 5,637 inputs.

3. Full insertion complexity

Complete insertion, including the refresh over the whole pool, takes 32.2–34.1 ms at 260 adapters on one CPU thread. Its cost is O(Cfp+MtKtd)O(C_{\mathrm{fp}}+M_tK_td). Here CfpC_{\mathrm{fp}} is the fingerprint cost, MtM_t the pool size, KtK_t the number of components, and dd the fingerprint dimension. The times are per-order medians over three arrival orders, with adapter factors in memory. At 100 adapters they are 28.2–28.7 ms. The refresh recomputes responsibilities once and rebuilds the statistics and routing objects. It requires no backbone forward, PCA refit, or EM iterations. These measurements replace the original 20–21 ms, which omitted the refresh.

4. Model scale

We ran the matched control on the paper's two other backbones and added a 0.78B cross-architecture study. The advantage of hierarchical over flat selection varies with the backbone and the pool. Both other backbones use the LLaMA configuration without further tuning. The matched control with uniform weights gives:

BackboneHierarchy minus flat
LLaMA-3.1-8B+2.43 [2.03, 2.84]
DeepSeek-LLM-7B-Base+1.09 [0.74, 1.45]
Qwen-2.5-7B−0.35 [−0.59, −0.11]

On flan-t5-large (0.78B; 196 LoRAHub adapters; 3,811 examples of 27 BBH tasks), an initial design with the probe in the decoder gave no gain over the base model. We then moved the probe to the encoder. In this setting, PAIR improves over the base model by 3.00 [2.25, 3.76] and trails flat selection of the same size by 1.11 [0.62, 1.61]. Scale, architecture, pool, and benchmark change together in this study. We did not evaluate models of 30B and above.

5. Adapter interference and last-block weights

Following your suggestion, we tested conflict-aware composition on the same routed sets and generation code. Neither norm-matched TIES variant improves on PAIR's weights. PAIR's score does not model pairwise interference. PAIR also applies one adapter-level weight, computed at the last block, to every adapted layer. The comparison uses 5,637 inputs and rescales each projection to the norm of the uniform linear merge:

CompositionFive-family macroOutside BBH and the development subset
PAIR weights48.5946.50
Norm-matched TIES, density 0.545.2046.34
Norm-matched TIES, density 0.244.7846.26

Outside BBH and the development subset, the differences from PAIR's weights are −0.17 [−0.73, 0.39] and −0.25 [−0.82, 0.32]; both intervals include zero.

6. Different ranks and target modules

Rank equality is not required. The dimensions of B(AΞ)B(A\Xi) and B(Ah)B(Ah) are set by the layer and the shared projection, not by the rank. Here BB and AA are the LoRA factors, Ξ\Xi is the projection, and hh is the hidden state. Zero-padding the factors for batching preserves each update exactly when each adapter keeps its own scaling factor. Different target modules require a common fingerprint representation and a rule for absent modules. As a pilot, we built an index over the last-block q/v updates shared by a pool that mixes two collections. The index builds, and 235 of the 260 original adapters keep their cluster assignment.

7. Within-cluster composition quota

Thank you for proposing this control. We ran the sweep with the selected clusters and the member ranking fixed. Only the per-cluster quota changes. Under PAIR's weights, on 5,637 inputs:

Per-cluster quotaMean adapters composedMacroDifference to quota 5
14.8847.09−1.50 [−2.13, −0.87]
28.3548.48−0.11 [−0.42, 0.20]
512.7948.59—

Retaining several members of a selected cluster improves composition quality. Quota five is 1.50 points above quota one, and a uniform-weight sweep on 10,137 inputs agrees (−1.57 [−2.09, −1.08]). Quota two is a lower-budget operating point. Its macro differs from quota five by −0.11 points [−0.42, 0.20], and it composes about 35% fewer adapters. The experiment supports multi-member composition and identifies an alternative to the default quota. The 4.88 adapters at quota one reflect the four-or-five-cluster rule (Update 2).

Thank you again for the thorough review and for the time you have given to this paper.

We thank the three reviewers for their careful reading and constructive questions. PAIR's central contribution is a weight-only pool index that guides input-conditioned adapter selection without training a router. The central controlled result is the LLaMA matched control, which compares PAIR's selection with flat selection. Flat selection scores all 260 adapters and keeps the highest-scoring ones. Both arms use the same backbone capture, raw adapter-response computation, per-input composition cardinality (at most 20; 12.2 on average), and uniform weights. Only the selection procedure differs. PAIR's selection improves the five-family macro by 2.43 points [2.03, 2.84]. The comparison therefore attributes the gain to the selection procedure, which includes cluster-conditioned ranking and stage-specific standardisation.

Updates. We checked four statements of the submission against the code and the run records. The updated statements follow; the individual responses give the evidence and refer to this list.

  1. Configuration selection. The configuration was developed on examples that overlap the evaluation suite, and scoring variants were compared on the full suite. This replaces the submission's statement that no evaluation examples informed tuning (Reviewer mSum, Q2). Index fitting uses adapter weights only, and no router is trained. After excluding the development data (all BBH tasks and a fixed development subset of up to 128 examples per task), a post-hoc analysis of the matched control gives +0.91 [0.76, 1.06] on the remaining four-family macro. This is not an independent holdout, and reported intervals are conditional on the selected configuration.
  2. Executed configuration. The submission states a fixed number of selected clusters, kc=4k_c=4. The reported runs select four or five clusters depending on the input. The rule and a fifth-cluster removal analysis are in the reply to Reviewer JYvK, point 2.
  3. Evaluation counts. Table 3 of the submission reports 92, which counted 80 clusters at Level 1 instead of 178 representatives. The medians are 190 executed evaluations and 179 distinct adapters. The implementation does not cache raw responses, so it can evaluate the same adapter twice. An instrumented replay confirms these counts and reproduces every routed set.
  4. Insertion cost. Complete insertion includes a refresh over the whole pool. It costs O(Cfp+MtKtd)O(C_{\mathrm{fp}}+M_tK_td), where CfpC_{\mathrm{fp}} is the fingerprint cost, MtM_t the pool size, KtK_t the number of components, and dd the fingerprint dimension. It takes 32–34 ms at 260 adapters on one CPU thread. The original 20–21 ms measurement omitted the refresh.

Updated manuscript. We have uploaded a new manuscript that implements these updates.

New experiments. The additional experiments test within-cluster composition (Reviewer JYvK, point 7), stage-specific standardisation (Reviewer mSum, W1), and index choice and maintenance under adapter arrival (Reviewer 6eBv, Q1 and Q2). The selection gain varies across backbones (Reviewer JYvK, point 4). The reduction in adapter evaluations is reported separately from serving latency (Reviewer 6eBv, Q3).

Protocol. Intervals are paired 95% bootstrap intervals over examples within tasks unless stated otherwise. Subset experiments use the first 250 examples (5,637 inputs) or the first 500 examples (10,137 inputs) of every task, in dataset order. Both subsets include all BBH examples. Re-runs of the stored index on other GPUs with other batch sizes reproduce the routed set on 98.3% of inputs, the generated text on 90.9%, and the score on 94.1%; their macro is 47.88 against 47.94.

We are grateful to the reviewers and the area chair for their time and consideration.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.