acceptodds
Under review as a conference paper at ICLR 2027

Internalized Skills Need Query-Adaptive Control

Abstract

Skill internalization enables LLM agents to reuse procedural knowledge through compact parameter updates, reducing the context overhead of skill use. However, internalizing a skill does not determine how strongly it should be applied to a given query: the same intervention can correct errors on some queries while disrupting answers the base model would otherwise get right. To this end, we propose Query-Adaptive Skill Gating (QASG), a lightweight framework that regulates skill contribution on a per-query basis. QASG couples two complementary signals: predictive uncertainty from self-reflection gauges the model's need for assistance, while adapter sensitivity quantifies the skill's response relative to the base computation. Together, these signals allow the same skill to provide different levels of support across queries, helping uncertain predictions while limiting unnecessary intervention. Extensive evaluations across five benchmarks show that QASG outperforms the best fixed-strength baseline by 8.1–8.4 points and achieves the highest average accuracy among the evaluated methods, including TextSkill, LatentSkill, and other adaptive gating methods. These results highlight the importance of query-adaptive strength control for effective use of internalized skills.

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM agents, Skill internalization, Hypernetwork

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_CKE8OpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces Query-Adaptive Skill Gating (QASG), a query-conditioned gating framework that can control the magnitude of the injected parametric skill adapters. This paper introduces two metrics, uncertainty and sensitivity, to determine whether the base model needs the skill adapter and how much the LoRA can help. They fine-tune Doc-to-LoRA's hypernet on skill-solution pairs, with solutions mostly generated by DeepSeek-V4-Flash. QASG demonstrates performance improvement over uniform, fixed scaler and latenskill and textskill baselines.

Critical strengths
  1. This paper investigates an interesting and timely topic: when and at what strength can we apply the parametric skill adapters.

  2. The experimental results are convincing, with supportive ablation and analysis.

Critical weaknesses
  1. The paper says, "we release the first large-scale public training corpus for skill-conditioned hypernetworks", but this doesn't appear in the supplementary materials, and there is no anonymous link.

  2. QASG introduces extra inference latency on uncertainty and sensitivity probes.

  3. Latentskill has an official checkpoint, this paper doesn't fully clarify why and from which checkpoint (or just randomly initialized) they fine-tuned Latentskill.

  4. QASG only tests on a Doc-to-LoRA-based hypernet, without testing its generalization ability over other hypernets like SHINE or Latentskill.

  5. The combination formulation of two signals needs more elaboration or ablation.

Questions for authors
  1. Can QASG be directly added to LatentSkill or SHINE without training?
5 comments

Thank you for reading our paper carefully and for providing detailed, concrete feedback. We appreciate your recognition of the importance of query-level skill strength control and of the evidence from our experiments and ablations.


W1. Release timing for the training corpus

Thank you for asking about data availability and reproducibility. As stated in the original manuscript’s Reproducibility Statement, we plan to release all code and training data upon acceptance.

We will publicly release all code and training data upon acceptance of the paper.

The phrase “we release” in the main text could suggest that the corpus is already public. We will revise the wording throughout the manuscript to clarify when the complete corpus will be available.

We have added QASG_training_trajectory_examples.zip to the supplementary materials for review. It contains 1,500 skill–solution trajectories, with 500 examples each from BigCodeBench, CHAMP, and TheoremQA. The appendix also describes the composition, construction, and verification of the corpus.

We will publicly release the complete set of resources upon acceptance to support reproducibility. Thank you for flagging the ambiguity in the original wording.


W2. Inference overhead and the accuracy–latency trade-off

Thank you for raising inference overhead, an important consideration for deployment. Computing reflection entropy and adapter sensitivity adds inference latency. Our experiments show that the reflection budget can be adjusted to trade off accuracy against latency while retaining some of the accuracy gains at lower overhead.

Using the same experimental setup as in the main paper, we obtain the following results on Qwen3-4B with the default 200-token reflection budget.

  • The uncertainty probe takes 3.5 s on average, and the adapter sensitivity probe takes 0.3 s. The reflection accounts for most of the probe overhead.
  • Mean end-to-end latency rises from 20.1 s for TextSkill to 22.9 s for QASG, an increase of about 14%, with a corresponding improvement of 2.3 percentage points in average accuracy. This is a practical accuracy–latency trade-off.

QASG omits the retrieved skill document from the final answer prompt. This reduces the average input length for final answer generation from 1,556 to 112 tokens. Processing the shorter input offsets part of the probe overhead.

To quantify how much of the accuracy gain is retained at different latency budgets, we added an ablation over reflection lengths.

Table 1. Accuracy and end-to-end latency at different reflection budgets (Qwen3-4B)

MethodMean latency (s)CHAMP (%)TheoremQA (%)MedCalc-Bench (%)LogicBench (%)BigCodeBench (%)Avg. (%)
TextSkill (baseline)20.157.154.250.275.829.353.3
QASG, 32 tokens19.958.357.047.876.830.254.0
QASG, 64 tokens20.559.157.848.477.531.254.8
QASG, 128 tokens21.559.858.149.077.931.355.2
QASG, 200 tokens22.960.158.849.478.331.455.6
  1. Accuracy gains at a low budget. At 32 tokens, QASG has slightly lower end-to-end latency than TextSkill (19.9 s) and still improves average accuracy by 0.7 percentage points.
  2. An adjustable accuracy–latency trade-off. Across the four configurations, both average accuracy and latency increase with the reflection budget. The budget can be chosen to meet the latency requirements of the application.

We agree that reducing the overhead further is an important direction. We will investigate lighter-weight uncertainty estimators and faster approximations for the sensitivity computation.

Thank you for suggesting this ablation. We will include these results and the associated trade-offs in the computational cost analysis of the final manuscript.

W3. LatentSkill checkpoint initialization and continued training

Thank you for pointing out the availability of the official checkpoint and asking which weights we used and why we continued training.

  • Qwen3-8B. We initialize the skill compiler from LatentSkill’s official pretrained weights. The archive is latentskill_pretrain_qwen3_8b/pretrain.tar.gz, and the extracted directory is checkpoints/latentskill_pretrain_qwen3_8b/pretrain/. Official LatentSkill checkpoint
  • Qwen3-4B. Since LatentSkill did not publicly release a pretrained skill compiler checkpoint for Qwen3-4B, we trained the Qwen3-4B skill compiler using LatentSkill’s publicly released skill pretraining data. LatentSkill skill pretraining data

For task adaptation, we continue training the LatentSkill compiler on the same corpus of skill–solution trajectories used in the QASG experiments. This adapts the compiler to the skills and queries in our evaluation and gives both methods the same task supervision. LatentSkill’s skill compiler is based on SHINE.

We will clarify the compiler’s architectural provenance and specify the initialization or pretraining resources used for each model size. Thank you for highlighting this detail, which matters for interpreting and reproducing the baseline comparison.


W4 / Q1. Compatibility with additional skill generators

Thank you for asking whether QASG can be applied beyond the Doc-to-LoRA hypernetwork used in our main experiments. We evaluate QASG with two additional skill-generation methods, LatentSkill and SHINE. Adding the QASG gate requires no additional gradient updates to either hypernetwork.

QASG controls the adapter at inference time, after skill generation and before answer generation. It can therefore be added to an existing skill-generation pipeline as long as the resulting adapters support injection-strength scaling.

For the SHINE experiment on Qwen3-8B, we initialize the hypernetwork from the official pretrained weights and continue training on the same skill–solution corpus used for QASG and LatentSkill. As with LatentSkill, this adapts the generator to the skills and queries in our evaluation and ensures that the methods receive the same task supervision. We then freeze the adapted SHINE generator and reuse the same adapters to compare its original inference procedure with QASG gating. SHINE-Pretrain

For each of LatentSkill and SHINE, we freeze the generator and hold the rest of the setup fixed. We vary only the strength-control strategy, comparing the generator’s native inference procedure with QASG’s dynamic scaling.

Table 2. QASG performance with different frozen skill generators (Qwen3-8B, accuracy in %)

Skill generatorInference strategyCHAMPTheoremQAMedCalc-BenchLogicBenchBigCodeBenchAvg.
LatentSkillNative inference54.053.541.076.033.051.5
LatentSkill+ QASG (ours)60.159.048.082.037.057.2
SHINENative inference52.152.040.574.032.050.1
SHINE+ QASG (ours)57.557.546.579.535.555.3

Adding QASG improves macro-average accuracy by 5.7 percentage points for LatentSkill and 5.2 percentage points for SHINE compared with their respective native inference procedures. These results show that QASG can improve average accuracy with either generator frozen. We will include the full experiments in the final manuscript. Thank you for suggesting this test of QASG across skill generators.

W5. Rationale and ablation evidence for combining the two signals

Thank you for raising this question. The original manuscript gave limited detail on the motivation and ablation evidence for the gate. We provide the rationale and results for the conditional coupling and tanh mapping below.

1. Rationale for conditionally coupling the two signals

Base-model uncertainty sets the baseline injection strength, and adapter sensitivity adjusts the gain relative to that baseline. The gate takes the form

z=uE[1+λ(1−uL)],s=tanh⁡(z)z = u_E\bigl[1 + \lambda(1-u_L)\bigr], \qquad s = \tanh(z)

Sensitivity’s marginal effect on the combined score is ∂z/∂uL=−λuE\partial z/\partial u_L = -\lambda u_E. The derivative captures how the sensitivity contribution depends on uncertainty.

  • When the base model is highly confident (uE→0u_E \to 0), the additional gain tends to zero at every sensitivity level. This limits the risk of excessive skill intervention on easy queries.
  • Higher base-model uncertainty allows a wider range of sensitivity-based adjustments, giving the skill more room to correct errors.

An additive combination contributes λ′(1−uL)\lambda'(1-u_L) independently of uEu_E and therefore lacks this constraint. When λ′>0\lambda'>0, low sensitivity can yield a relatively high injection strength even on a query with low uncertainty.

In Figure 3(c), the negative association between sensitivity and the oracle scale is strongest in the high-uncertainty group (∣ρ∣=0.35|\rho| = 0.35, compared with 0.19 and 0.17 in the medium- and low-uncertainty groups, respectively). In Figure 4(a), higher oracle scales also concentrate in the high-uncertainty, low-sensitivity region. Both patterns are consistent with the direction of the gate’s adjustments.

2. Rationale for the tanh mapping

The tanh mapping has two properties that motivate its use.

  • Smooth, bounded output. Tanh smoothly maps nonnegative inputs into [0,1)[0,1), which is consistent with the interpretation of the injection coefficient. Its slope varies smoothly. Clipping also yields a continuous output, with abrupt changes in slope at the clipping points.
  • Saturation. The derivative ds/dz=1−s2\mathrm{d}s/\mathrm{d}z = 1-s^2 decreases as the scale rises. This compresses increments at high injection strengths and limits the risk of excessive interference from the skill.

3. Ablation results

We compare three gates using the same adapters and signals to assess the contribution of conditional coupling and compare two mappings within the additive structure. Full QASG retains the parameters fixed in advance in the original paper. Following the same ablation protocol, we independently select λ′\lambda' for each additive baseline to maximize accuracy on the 100-question validation set used to calibrate the signals.

  • Additive combination with tanh uses s=tanh⁡(uE+λ′(1−uL))s = \tanh\bigl(u_E + \lambda'(1-u_L)\bigr), the “w/o coupling” ablation in the original manuscript.
  • Additive combination with clipping uses s=clip⁡(uE+λ′(1−uL), 0, 1)s = \operatorname{clip}\bigl(u_E + \lambda'(1-u_L),\, 0,\, 1\bigr).

Table 3. Comparison of gates using the same signals (Qwen3-4B, accuracy in %)

GateCHAMPTheoremQAMedCalc-BenchLogicBenchBigCodeBenchAvg.
Additive combination + tanh55.254.044.876.530.052.1
Additive combination + clipping54.253.145.775.230.651.8
Full QASG (ours)60.158.849.478.331.455.6
  1. Conditional coupling. Full QASG exceeds the additive gate with clipping by 3.8 percentage points. With tanh held constant, it exceeds the additive gate by 3.5 percentage points, supporting the contribution of the conditional coupling.
  2. Mapping within the additive structure. The additive gate with clipping achieves 0.3 percentage points lower macro-average accuracy than the additive gate with tanh.

We will add the derivation and ablation results to the methods discussion in the final manuscript.

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

This paper proposes Query-Adaptive Skill Gating (QASG), a method that adjusts the injection strength of skill LoRA adapters for each query. It integrates the predictive entropy obtained from the base model's self-reflection and the relative activation magnitude of the adapters. The computed scaling value is shared across all adaptation layers and remains fixed during answer generation. Experiments conducted on five benchmark datasets based on Qwen3-4B and Qwen3-8B show that this method outperforms fixed-strength injection and textual skill prompting schemes. The paper also constructs a skill-conditioned training corpus.

Critical strengths

This paper investigates a query-adaptive strength control method for internalized skills of large language models, and conducts evaluations across multiple benchmarks and different model scales. Experimental results show that this method can steadily improve accuracy compared with the fixed-strength baseline method using the same skill adapter.

Critical weaknesses

W1. Insufficient robustness evaluation against skill retrieval errors.

When the retrieved skill does not match the current question, a high level of base model uncertainty may still lead to a strong adapter injection, while adapter sensitivity cannot directly distinguish between beneficial and detrimental skill interventions. The paper lacks a separate evaluation for such failure scenarios. The authors should conduct control experiments using irrelevant or mismatched skills, comparing the QASG scheme against both the adapter-free baseline and the fixed-intensity scheme.

W2. The reliability of self-reflection entropy requires further validation.

Section 5.3 shows that queries answered incorrectly by the base model tend to exhibit higher reflection entropy, demonstrating the reference value of this signal. However, this overall correlation is insufficient to establish its reliability on individual queries. The authors should examine cases where the base model with LoRA adapters disabled generates low-entropy reflections yet provides incorrect answers, and evaluate whether a lower injection intensity under such conditions would constrain the gains brought by skill assistance.

Questions for authors

It remains unclear whether the authors have considered alternative metrics, and whether self-reflection entropy possesses independent advantages over other uncertainty estimation metrics. It is recommended to substitute different uncertainty metrics within the same QASG gating structure to further justify the design choice of self-reflection entropy.

4 comments

Thank you for reviewing our work carefully, and we address the raised points below.


W1. Robustness to skill retrieval errors

Retrieval errors are an important failure mode in practice and provide a useful stress test for the gate. We added controlled experiments under three skill-mismatch conditions. QASG achieves higher macro-average accuracy than fixed-strength injection in all three conditions and remains above the no-adapter baseline under 50% random replacement.

1. How the coupling limits amplification under skill mismatch

We agree that sensitivity measures only the magnitude of the adapter’s response to the query and cannot by itself tell whether the corresponding skill is helpful or harmful. Hierarchical coupling can limit excessive amplification of mismatched skills, but it cannot independently determine whether a skill is relevant to the current query. QASG mitigates this risk in two ways. It keeps injection strength low for queries with low uncertainty and assigns less additional gain to more sensitive adapters at the same uncertainty level. These constraints can reduce interference from mismatched skills and help explain why QASG outperformed fixed-strength injection in all three mismatch experiments.

  • Base-model uncertainty scales and bounds the gain from adapter sensitivity. Even when a mismatched adapter strongly perturbs the model’s outputs, uncertainty still caps the additional gain, helping prevent excessive injection.
  • The coupling allows a wider range of gains when base-model uncertainty is higher. At a given uncertainty level, more sensitive adapters receive less additional gain. Thus, when a mismatched adapter already responds strongly, the gate limits further amplification.

The two-signal coupling provides a degree of resilience to retrieval errors. Mismatched skills can still hurt performance, so accurate skill retrieval remains important.

2. Experimental setup for the three mismatch conditions

We keep the experimental setup consistent across three conditions, ranging from partial retrieval noise to complete retrieval failure.

  1. 50% random replacement introduces partial replacement of the original retrieval results.
  2. 100% random replacement randomly replaces every originally retrieved skill.
  3. 100% semantically similar but inapplicable replacements simulates a harder case in which every retrieved skill appears relevant but does not apply to the query.

Within each condition, fixed-strength injection and QASG use the same replacement skills and retain the same configurations. The injection-strength strategy is the sole variable in each comparison.

3. Results

Table 1. Accuracy under skill mismatch (Qwen3-4B, %)

Skill conditionMethodCHAMPTheoremQAMedCalc-BenchLogicBenchBigCodeBenchAvg.
No skillNo adapter41.442.421.667.323.339.2
Original retrievalBest fixed scale50.649.737.272.627.447.5
Original retrievalQASG (ours)60.158.849.478.331.455.6
50% random replacementFixed strength43.240.227.162.924.439.6
50% random replacementQASG50.747.234.471.826.146.0
100% random replacementFixed strength34.534.418.855.419.532.5
100% random replacementQASG38.139.020.067.123.037.4
100% semantically similar but inapplicableFixed strength33.032.516.055.018.531.0
100% semantically similar but inapplicableQASG36.337.018.868.122.436.5
  1. Partial retrieval noise (50% random replacement). QASG reaches 46.0% macro-average accuracy, 6.4 percentage points above fixed-strength injection and 6.8 points above the no-adapter baseline. Dynamic strength control therefore retains a net benefit from using skills under this simulated partial mismatch.
  2. Complete random replacement (100%). Both methods fall below the no-adapter baseline when all originally retrieved skills are replaced. Fixed-strength injection drops to 32.5%, while QASG reaches 37.4%. QASG is 4.9 percentage points ahead of fixed-strength injection and 1.8 points below the no-adapter baseline, preserving more of the base model’s accuracy under this condition.
  3. Semantically similar but inapplicable replacements. QASG reaches 36.5% macro-average accuracy, 5.5 percentage points above fixed-strength injection and 2.7 points below the no-adapter baseline. QASG’s advantage over fixed-strength injection is present in all three mismatch conditions.

QASG improves accuracy under original retrieval, and the controlled comparisons show that its accuracy also remains higher than that of fixed-strength injection under skill mismatch. Thank you for suggesting this evaluation. We will include these experiments and their analysis in the robustness section of the final manuscript.

W2. Reliability and trade-offs when the base model is wrong at low entropy

Thank you for pointing out that a model can give an incorrect answer even at low entropy. We analyzed this failure mode query by query. On the low-entropy subset, QASG corrected slightly fewer base-model errors than fixed-strength injection, but it also disrupted far fewer originally correct answers and achieved higher overall accuracy.

We used the lower quartile of reflection entropy on the validation set as the threshold and selected evaluation queries that met this low-entropy criterion. We randomly sampled 40 such queries from each benchmark for a total of 200 and grouped them by whether the base model answered correctly.

Table 2. Corrections and regressions on low-entropy queries (Qwen3-4B)

MetricCHAMPTheoremQAMedCalc-BenchLogicBenchBigCodeBenchTotal / Avg.
Sampled low-entropy queries4040404040200
Originally correct with the base model192011301292
Originally incorrect with the base model2120291028108
Base-model errors corrected by fixed-strength injection8783430
Base-model errors corrected by QASG7683327
Originally correct answers made incorrect by fixed-strength injection3433316
Originally correct answers made incorrect by QASG111115
No-adapter accuracy (%)47.550.027.575.030.046.0
Fixed-strength accuracy (%)60.057.540.075.032.553.0
QASG accuracy (%)62.562.545.080.035.057.0

(1) The gate retains some ability to correct errors at low entropy

Of the 108 low-entropy queries answered incorrectly by the base model, QASG corrected 27 (25.0%), compared with 30 (27.8%) for fixed-strength injection. This is consistent with the design of the continuous gate. Low entropy sets a low baseline strength, while the gate can still assign a moderate scale that gives the skill a chance to correct an error even when the base model underestimates its need for assistance.

(2) A small reduction in corrections accompanies a larger reduction in regressions

QASG corrected three fewer errors, while reducing the number of originally correct answers that became incorrect from 16/92 (17.4%) to 5/92 (5.4%), a reduction of nearly 70%.

Overall, QASG corrected three fewer errors but preserved 11 more correct answers, yielding a net gain of eight correct answers and a 4.0-percentage-point accuracy improvement over fixed-strength injection. On this subset, the protection of originally correct answers outweighed the reduction in corrections.

We will add this analysis to the reliability evaluation in the final manuscript. Thank you for raising this case, which helped us clarify the rationale and reliability of the gate.

Q1. Isolating the contribution of self-reflection entropy

Thank you for suggesting a comparison that varies the uncertainty measure within the same gating architecture. This isolates the effect of the uncertainty input.

1. Measures and experimental setup

Reflection entropy aggregates predictive uncertainty over the entire reflection trajectory. The structured reflection asks the model to identify the necessary knowledge, assess the difficulty, and locate likely error-prone steps. Pooling entropy across that trajectory captures predictive uncertainty at these different positions.

We compare against three uncertainty measures.

  • Base-model binary self-assessment uncertainty. We use 1−P(Yes)1-P(\mathrm{Yes}), where P(Yes)P(\mathrm{Yes}) is normalized over the “Yes” and “No” responses to the binary self-assessment.
  • Query-final predictive entropy. We use the entropy of the full-vocabulary next-token distribution at the last position of the input query.
  • Internal Confidence (IC). We use 1−IC1-\mathrm{IC}, where IC is the model’s internal confidence aggregated across layers and positions with weights.

We keep the sensitivity signal, hierarchical coupling, and all gating hyperparameters fixed and replace only the uncertainty input. We fit a separate percentile mapping for each measure on the same validation set so that each input is on the [0,1][0,1] scale.

2. Results and interpretation

Table 3. Replacing the uncertainty input within the full QASG architecture (Qwen3-4B, accuracy in %)

Uncertainty inputCHAMPTheoremQAMedCalc-BenchLogicBenchBigCodeBenchAvg.
Internal Confidence54.853.644.074.129.051.1
Base-model binary self-assessment uncertainty56.555.244.874.928.652.0
Query-final predictive entropy57.355.846.075.829.252.8
Mean reflection entropy (ours)60.158.849.478.331.455.6

Mean reflection entropy outperforms all three alternatives on all 5 benchmarks and leads the next-best measure, query-final predictive entropy, by 2.8 percentage points in macro-average accuracy. Query-final entropy reflects the next-token distribution at one input position. Binary self-assessment and Internal Confidence estimate the model’s confidence in whether it can answer correctly. Reflection entropy pools local uncertainty while the model assesses difficulty, considers the steps needed to solve the query, and identifies likely mistakes. This information can help estimate whether a query needs skill assistance. The controlled comparison supports using reflection entropy as the baseline signal for strength control.

We will add this comparison and analysis to the ablation section of the final manuscript. Thank you for helping us clarify the rationale for our choice of signal.

AuthorsOpenReview ↗

Looking forward to discussion

Dear Reviewer AkgR,

We appreciate your time and effort in reviewing the paper.

As we near the end of the discussion period, we would like to remind you of the upcoming deadline kindly. We are happy to discuss any aspects of the paper that may require further clarification.

Thank you once again for your valuable feedback.

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

This paper proposes a method that adjusts the strength of learned skills for each query. The method uses model uncertainty and LoRA adapter activations to control skill strength without extra training. The experimental results show that the proposed method outperforms several baseline methods.

Critical strengths
  • The paper is easy to follow and has clear motivation.
  • The design of the proposed method is streamlined.
  • The ablation study and cost analysis for the components of proposed method are comprehensive.
Critical weaknesses
  • The design of the gating function (Eq.7) is hand-designed. While the ablation study shows the benefits of this design, the paper lacks comparisons with other simple gating functions, such as linear combinations of the same signals.
  • The proposed directly combine the existing uncertainty estimation and adapter activation measurements, the methodological novelty is limited.
Questions for authors
  • Could the authors provide the result for a simple linear combination as the gating function?
  • Have the authors tried to use the sum instead of the mean for uncertainty calculation? If so, how does it affect performance?
4 comments

Thank you for reading our paper carefully and for recognizing the motivation and simplicity of the design. We also appreciate your two concrete experimental suggestions, which help us explain the rationale and clarify the evidence behind our choices.


W1 / Q1. Rationale for the gating function and comparison with simpler gates

Thank you for raising two important points. Equation (7) needs a clearer motivation, and simpler gates that use the same signals, such as a linear combination, provide a useful comparison for testing the design. We explain our rationale below and report results for two additive gates.

1. Designing the gate for conditional coupling

We designed the gate so that base-model uncertainty sets the baseline injection strength and constrains how much sensitivity can increase it. This gives the two signals distinct roles and motivates the multiplicative coupling:

z=uE[1+λ(1−uL)],s=tanh⁡(z)z = u_E\bigl[1 + \lambda(1-u_L)\bigr], \qquad s = \tanh(z)

The two parts of the gate serve different purposes.

  • Multiplicative coupling. Base-model uncertainty uEu_E determines the baseline and the upper bound on injection strength. Adapter sensitivity contributes an additional gain through 1−uL1-u_L, scaled by uEu_E, as shown by ∂z/∂(1−uL)=λuE\partial z/\partial (1-u_L) = \lambda u_E. When the base model is highly confident (uE→0u_E \to 0), this gain tends to zero at every sensitivity level, reducing the risk of excessive intervention on easier queries. In a simple additive combination, the gain term λ′(1−uL)\lambda'(1-u_L) is independent of uEu_E. If λ′>0\lambda'>0, a query with low uncertainty can still receive a relatively high injection strength when the adapter sensitivity is low.
  • tanh mapping. The tanh function smoothly bounds the output in [0,1)[0,1), consistent with its role as an injection coefficient. Its derivative, ds/dz=1−s2\mathrm{d}s/\mathrm{d}z = 1-s^2, also shrinks as the scale increases. This saturation compresses increments in the high-strength regime and limits the risk of over-injection at extreme inputs, consistent with our conservative approach to allocating skill assistance.

Figure 3(c) shows that the negative association between sensitivity and the oracle scale is strongest in the high-uncertainty group. This pattern is consistent with the design choice to scale sensitivity-based gain by the estimated need for assistance.

2. Comparison with simple additive gates

Following your suggestion, we compare full QASG with two simple additive gates using the same adapters and signals.

  • Additive combination with tanh uses s=tanh⁡(uE+λ′(1−uL))s = \tanh\bigl(u_E + \lambda'(1-u_L)\bigr), the existing “w/o coupling” ablation.
  • Additive combination with clipping uses s=clip⁡(uE+λ′(1−uL), 0, 1)s = \operatorname{clip}\bigl(u_E + \lambda'(1-u_L),\, 0,\, 1\bigr), the simple linear-combination gate you suggested.

Full QASG retains the parameters fixed in advance in the original paper. Following the ablation protocol, we select λ′\lambda' separately for each additive baseline to maximize accuracy on the same 100-question validation set used for signal calibration.

Table 1. Comparison of gates using the same signals (Qwen3-4B, accuracy in %)

GateCHAMPTheoremQAMedCalc-BenchLogicBenchBigCodeBenchAvg.
Additive combination + tanh55.254.044.876.530.052.1
Additive combination + clipping54.253.145.775.230.651.8
Full QASG (ours)60.158.849.478.331.455.6
  1. Full QASG exceeds the two additive gates by 3.5 and 3.8 percentage points in macro-average accuracy, respectively.
  2. The additive gate with clipping trails the additive gate with tanh by 0.3 percentage points. Both additive gates trail the multiplicatively coupled gate. With tanh held constant, multiplicative coupling improves macro-average accuracy by 3.5 percentage points, supporting the contribution of the coupling structure.

The gate is designed to allocate skill strength according to each query’s estimated need for assistance, and it outperforms both simpler additive gates using the same signals. We will add the design rationale and these comparisons to the final manuscript.

W2. Novelty and methodological contributions

Thank you for your assessment. Most existing hypernetwork-based approaches to skill generation and internalization focus on generating and selecting skills and apply them with a uniform scale or a binary on/off decision. Because queries vary in how much they depend on a skill, a fixed scale can disrupt answers to easier queries while providing insufficient assistance on harder ones. QASG addresses this problem through its formulation, gate design, and deployment.

1. A continuous, per-query inference-time decision

The appropriate injection strength for the same skill adapter can vary across queries. In our experiments, fixed-strength injection changed some correct base-model answers to incorrect ones on easier queries and failed to correct some errors on harder queries. QASG replaces a globally preset scale with a continuous coefficient estimated for each query at inference time, addressing both insufficient assistance and excessive interference.

2. Distinct signal roles and hierarchical coupling

We adapt and combine existing components by giving the two signals distinct roles and coupling them hierarchically.

  • Distinct roles. Base-model uncertainty defines the baseline and the bounds of the allowed injection scale, reflecting how confident the base model is and how much intervention it may need. Adapter sensitivity determines the additional gain above that baseline, reflecting how strongly the current adapter already responds to the query and how much amplification to add.
  • Hierarchical coupling. Low uncertainty confines injection to a narrow range of low strengths, limiting interference. High uncertainty allows a wider range of additional gains so that the skill can make a larger contribution.
  • Ablation evidence. A simple additive combination lacks this uncertainty-dependent constraint on the gain. With the same tanh mapping, the additive combination achieves 3.5 percentage points lower macro-average accuracy than our coupled design, supporting the contribution of the coupling mechanism.

3. Integration with existing pipelines without additional training

QASG operates entirely at inference time and can be applied to existing adapters that support strength scaling. It requires no trained controller or retraining of the skill generator. This makes it possible to add QASG to existing skill-internalization pipelines and to study when and how strongly skills should intervene as a decision that can be modeled and evaluated independently.


Q2. What happens if reflection entropy is summed instead of averaged?

We use the mean to normalize for reflection length and make predictive uncertainty comparable across queries.

Reflection generation stops at EOS or after 200 generated tokens, so the number of valid reflection positions TxT_x varies across queries. The sum and mean are related by

Esum(x)=Tx⋅Emean(x)E_{\mathrm{sum}}(x) = T_x \cdot E_{\mathrm{mean}}(x)

A query with lower average entropy per token can therefore have higher total entropy if its reflection is sufficiently long. The sum combines per-token predictive uncertainty with reflection length. Taking the mean removes the length multiplier and measures per-token uncertainty more directly.

Following your suggestion, we compared the two aggregation methods. We fitted separate percentile mappings on the same validation set so that both signals enter the gate on the same [0,1][0,1] scale.

Table 2. Reflection entropy aggregation (Qwen3-4B, accuracy in %)

AggregationCHAMPTheoremQAMedCalc-BenchLogicBenchBigCodeBenchAvg.
Sum of entropies59.957.849.177.030.954.9
Mean entropy (ours)60.158.849.478.331.455.6

Mean aggregation performs better on all 5 benchmarks and improves macro-average accuracy by 0.7 percentage points over sum aggregation.

Thank you for suggesting this comparison. The results support our choice to normalize for reflection length. We will add the experiment and its motivation to the final manuscript.

AuthorsOpenReview ↗

Looking forward to discussion

Dear Reviewer g8P7,

Thank you again for your review. We have addressed your main concerns in our response above with additional results. We would appreciate any feedback on whether these address your concerns, and would be happy to clarify any remaining issues.

Thank you for the clarification and additional results. My concerns are addressed. I will keep my score.

Comments on the paper

1 comment

We sincerely thank the AC and reviewers for their time, thoughtful feedback, and insightful suggestions throughout the review process, which have greatly helped us clarify and improve our work.

Our paper addresses an important underexplored gap in LLM skill internalization: existing parametric skill adapters are universally deployed with a fixed global injection strength, which inevitably causes excessive interference on easy queries and insufficient assistance on difficult ones. To tackle this problem, we propose Query-Adaptive Skill Gating (QASG), a training-free, inference-only framework for query-specific strength control. Our key insight is that reflection uncertainty and adapter activation sensitivity serve complementary roles: uncertainty sets the injection baseline and upper bound, while sensitivity modulates the gain above the baseline. This hierarchical, multiplicative design enables adaptive skill support without retraining base models or hypernetworks. The effectiveness of our framework is supported by extensive experiments across different backbones and benchmarks.

All reviewers have recognized the significance of our research topic and the rigor of our experimental evidence. During the rebuttal, we carefully addressed all the reviewers’ concerns through technical clarifications and additional experiments, including comparisons with alternative gating designs and uncertainty metrics, robustness evaluations under skill mismatch, and analyses of inference efficiency. We believe these efforts strengthen the evidence supporting our design choices and clarify the practical applicability of QASG.

We have also noted areas for further refinement in the final version, which primarily focus on enhancing presentation clarity and expanding ablation discussions, while the core ideas and conclusions of our work remain intact. We will integrate all clarified presentations and expanded experiments into the final manuscript to further strengthen the paper.

Overall, we believe the clarifications and additional analyses have improved the presentation and reinforced the validity of our contributions. We greatly appreciate the opportunity for this constructive discussion and look forward to the AC’s assessment in light of our responses and updates.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.