acceptodds
Under review as a conference paper at ICLR 2027

SoftSkill: Behavioral Compression for Contextual Adaptation

Abstract

Natural-language skills let agents reuse task knowledge, but long skill documents must be reinterpreted on every call. We introduce SOFTSKILL, which converts a skill document into a compact trainable context by initializing virtual-token embeddings from its text and optimizing an additive update with next-token prediction while freezing the language model. On Qwen3.5-4B, a 32-token soft skill improves over no skill by 7.6, 42.1, and 1.3 points on SearchQA, LiveMath, and DocVQA, respectively, and exceeds the optimized textual skill on SearchQA and LiveMath by 4.5 and 12.5 points while replacing artifacts containing hundreds to thousands of tokens. The same interface also improves multi-step execution: on Qwen3.6-35B-A3B, OfficeQA and ALFWorld improve over no skill, while in a controlled Qwen3.5-4B ALFWorld setting, training raises success from 44/134 to 91/134. Mechanistic interventions show that this gain is carried by a small, task-aligned continuous displacement: moving halfway along the learned direction recovers most of the improvement, an equal-norm random displacement does not, vocabulary projection removes the gain, and early-layer state replacement strongly suppresses it. These results show that task supervision can compile a readable skill artifact into a compact continuous control for both answers and actions without updating the backbone.

Primary area:
foundation or frontier models, including LLMs
Keywords:
soft prompt tuning, prefix tuning, parameter-efficient adaptation, language model agents, skill learning, context compression

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_qLFmOpenReview ↗
Rating
4
Confidence
3
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

The paper proposes SOFTSKILL, which initializes a short block of virtual-token embeddings from a natural-language skill and optimizes that block with next-token prediction while keeping the backbone frozen. Experiments show gains on several QA and agent benchmarks, and controlled ALFWorld interventions suggest that the learned continuous update—not merely a change in nearest vocabulary tokens—drives much of the measured improvement.

Critical strengths

SOFTSKILL is an interesting, simple, and effective approach: it turns an existing textual skill into a compact trainable context while keeping the backbone frozen. The experiments are unusually thorough, spanning QA and agentic tasks, initialization and placement ablations, robustness tests, and mechanistic interventions. Overall, this is a strong and carefully evaluated piece of work.

Critical weaknesses

The choice of a fixed 32-token skill is not sufficiently motivated. Although the paper compares several lengths, performance sometimes declines as the skill grows, but the authors do not explain why. More importantly, initialization uses the first mm tokens of the skill text; for a very long skill, those first 32 tokens may contain little task-relevant information. Would SOFTSKILL still work with a different 32-token segment—or even a randomly initialized vector block? The paper should test these alternatives and provide a more general, principled method for selecting the skill representation and its length.

Questions for authors

See weakness part.

1 comment

hank you for the positive assessment and for the precise questions on segment choice, random initialization, and block length. We ran new three-seed experiments for each question on all three QA tasks; the results also yield a principled rule for choosing the representation and its length. All rows below use the skill-slot insertion and report means over three seeds.

Q1. Would a different 32-token segment work?

Yes: on every task, the tested segments perform similarly.

InitializationSearchQALiveMathDocVQA
First 32 tokens (default)75.5 ± 1.566.7 ± 1.790.1 ± 0.5
32 tokens from the body74.5 ± 1.166.9 ± 1.488.9 ± 0.8
Random contiguous span75.0 ± 0.965.1 ± 2.088.2 ± 1.2
32 tokens sampled at random from the skill75.0 ± 1.866.4 ± 2.389.2 ± 1.3

The four segments stay within two points of each other on each task, so the opening segment is not uniquely important.

Q2. Would a random vector block work?

It depends on how much room the task leaves: on LiveMath a norm-matched Gaussian block fails, while on SearchQA and DocVQA every tested start trains to a similar score.

InitializationSearchQALiveMathDocVQA
No skill (reference)68.122.486.9
Right skill (default)75.566.790.1
Generic instruction76.862.988.8
Wrong task's skill76.460.288.9
Random vocabulary tokens74.764.088.2
Norm-matched Gaussian72.926.188.0

LiveMath is the most informative task here: its no-skill baseline is 22.4, and its seed skill is a real 208-token document. There, a Gaussian block reaches only 26.1, whereas random vocabulary tokens reach 64.0; across 12 initializations, real-token starts land at 60–69 and averaged or Gaussian starts at 26–52. DocVQA leaves little room (the no-skill baseline is already 86.9), so all 12 initializations land within 88.0–90.1. Skill content adds to the effect of geometry where the skill carries task knowledge: on LiveMath, and by a smaller margin on DocVQA, the right skill beats a generic instruction and the wrong task's skill. On SearchQA the seed skill is a 22-token placeholder ("No learned rules yet"), so it carries no content, and all 12 initializations land within 72.9–76.8.

Why does performance sometimes drop as the block grows?

With three seeds there is no systematic decline beyond 32 tokens on any task; the drop in the original single-seed results does not reproduce.

Length8163264128256
SearchQA74.775.175.277.476.575.9
LiveMath53.266.168.069.166.469.1
DocVQA89.888.689.887.687.988.8

LiveMath rises up to 16–32 tokens and then plateaus; SearchQA and DocVQA are flat across the whole range. This points to a useful distinction: textual skill length determines how much content can be expressed, whereas soft-skill length mainly sets trainable capacity. A block longer than its source text is initialized by repeating the text (SearchQA's 22-token skill becomes about 12 copies at 256 tokens), yet it trains to the same accuracy, so the training signal supplies task-specific behavior beyond the initialization text. Soft-skill length is therefore best viewed as a capacity hyperparameter, like adapter rank, and about 16–32 tokens suffice in the evaluated settings.

A principled selection method

Two rules follow from these results. Representation: initialize from actual token embeddings (any tested skill segment works), not from averaged embeddings or random dense vectors. Length: treat it as a capacity hyperparameter and choose the shortest length within one standard deviation of the best validation score. On our validation results this rule selects 32 tokens for both LiveMath and SearchQA. The revision replaces the single-number justification with the length curve and these two rules.

We hope the new results address the reviewer's concerns and have convinced them to recommend acceptance with confidence.

Reviewer_9Z5bOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
1
Soundness
1
Read review
Paper summary

This paper discusses that natural-language skills let agents reuse task knowledge, but they need to be reinterpreted by the model every time they are loaded. By introducing SoftSkill, the authors aim to provide a frozen backbone interface, creating a trainable continuous skill block from skill text. They also show that they have some benefits in their experiments. SoftSkill converts a natural-language skill into initial virtual-token embeddings p0p_0 and learns an additive update Δp\Delta p.

Critical strengths

The paper provide some intuition on why this problem is an important one and discusses the reasoning behind how SoftSkill was designed.

Critical weaknesses

The writing of the paper is very poor. There isn't a clear related work in the main paper, showing the distinction of this works compared to the previous ones in details. The experimental results do not suggest a superior performance of SoftSkill against other baselines and it was only done on one family of models. Given that the backbone is frozen, other model families as well as larger models can have a different performance. (although some experiments have been done in appendix page 20), I don't think that it does fully address this matter.

Questions for authors

Please address the weaknesses.

2 comments

Thank you for recognizing why the problem matters and the reasoning behind SoftSkill's design. Your three concerns led to a full related-work section, a second model family in the main text, and a sharper statement of where SoftSkill wins. We address them in turn below.

W1. Related work

The revision adds a full related-work section and a positioning table to the main text. It covers four threads: textual skill optimization (SkillOpt, TextGrad, GEPA, Trace2Skill); continuous conditioning (prompt/prefix tuning, skill neologisms, KV-Skill); context compression (gist tokens, ICAE, AutoCompressor, context distillation, Cartridges); and weight adaptation (LoRA). The table lists, for each method, what is optimized, what signal trains it, and where it enters the model. The key distinction is that the compression methods aim to reproduce document-conditioned behavior, whereas SoftSkill uses NTP on successful task trajectories and selects by task performance, so the learned block is free to improve on the original document.

W2. Another model family

The pattern replicates on Llama-3.1-8B-Instruct under the same protocol, with no retuning.

Llama LiveMathLlama SearchQAQwen LiveMathQwen SearchQA
SoftSkill58.6 ± 4.677.9 ± 1.566.7 ± 1.775.5 ± 1.5
LoRA (all linear layers)57.5 ± 4.780.6 ± 0.669.4 ± 9.380.5 ± 1.3

On both families SoftSkill is close to LoRA on LiveMath and behind it on SearchQA. These results move into the main text.

W3. Comparison with baselines

SoftSkill beats every evaluated textual skill on SearchQA and LiveMath, and approaches a tuned LoRA while keeping the backbone frozen.

LiveMathSearchQADocVQA
Rollout-optimized textual skill (SkillOpt)52.071.289.0
SoftSkill (32 vectors)66.775.588.2

On LiveMath, SoftSkill also exceeds the no-skill baseline (22.4) by a wide margin, and paired McNemar tests on identical test items give p < 1e-4 for every seed. DocVQA is the exception: the no-skill baseline already scores 86.9 there, and SoftSkill does not surpass the optimized text skill; the paper now states this explicitly. A properly tuned LoRA is ahead on SearchQA and DocVQA and comparable on LiveMath within seed variability, but trains 186–372× more parameters and modifies backbone weights. SoftSkill therefore sits between the two: it is better than the evaluated textual skills on two of three tasks, and it approaches weight adaptation with a frozen backbone. Paired statistics and seed dispersion now accompany all main comparisons.

In summary, the revision adds a dedicated related-work section with a positioning table, replicates the results on Llama-3.1-8B-Instruct, and states the comparison precisely: SoftSkill outperforms the evaluated textual skills on SearchQA and LiveMath (p < 1e-4 on LiveMath) and approaches LoRA with 186–372× fewer parameters. We would be grateful if the reviewer reconsidered the score in light of these results, and are happy to clarify anything further.

Thank you for the efforts which mostly addressed my questions. At this point, I keep my score but will discuss this further with other reviewers with higher confidence to decide on increasing the score.

Reviewer_GHQzOpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

The paper proposes to learn soft-skills for task solving, by initializing the soft-skill tokens from text-skills themselves and training the soft skills using next token prediction loss on successful task rollouts (which were conditioned on the original text version of the skill).

Critical strengths

The paper evaluates on multiple tasks and multiple models (within the same model family).

Critical weaknesses
  1. Poor writing clarity leading to lots of followup questions for the authors: How were the train-val-test sets constructed ? What does LLM skill mean ? What is the score of the base skill that serves as init for the soft initialization ? What are the differences between LLM-Skill and NL skill ?
  2. Initialization schemes explored do not really make sense. (1) Mean pooling of embeddings can put the initialization out of the embedding distribution which is likely the cause of the 0.8% live math score in table 4 (2) initializing from the first 32 tokens does not make much sense since with standardized skill files, those are most likely to be just front-matter for the skill file.
  3. The work is subsumed by past work like https://arxiv.org/pdf/2506.06266 which explores compressing long documents (skills) into prefix parameters and https://arxiv.org/pdf/2607.27497 which explores initializing soft-skills from text tokens as a baseline.
  4. Limited practicality of the approach. Text skills are useful because they are transferrable across model families (the soft skills the authors present are not) , they can be dynamically loaded at any point in the inference trajectory (the soft-skills as they stand cannot be used in the middle of a rollout).
Questions for authors
  1. For training LoRA -- what data was used ? Was it also the successful trajectories as with SoftSkill ?
  2. Did you explore using 32 random text tokens from the original text as init instead of the default and mean pooling ?
3 comments

Thank you for the detailed review, and in particular for probing the initialization ablation and the LoRA baseline: checking them led us to correct two points in the submission. Below we report the new initialization ablation, the corrected LoRA, the positioning against Cartridges and SkillSmith, and answers to each clarity question.

W2, Q2. Initialization

Yes: 32 tokens sampled at random from the skill work as well as the first 32 (66.4 ± 2.3 vs 66.7 ± 1.7). The low score in Table 4 came from an off-distribution mean initialization. We agree that mean pooling can move the initialization outside the embedding distribution, and our description was imprecise: the submission's "mean-pooled" init is the mean of the whole vocabulary table, tiled over 32 rows. Its row norm is 0.249, compared with 0.656 for vocabulary rows.

Initialization (LiveMath, 3 seeds)Accuracy
First 32 tokens (default)66.7 ± 1.7
32 tokens from the body66.9 ± 1.4
Random contiguous span65.1 ± 2.0
32 random tokens from the skill66.4 ± 2.3
Random vocabulary tokens64.0 ± 2.5
Vocabulary mean52.2 ± 5.4
Skill-token mean44.6 ± 1.7
Norm-matched Gaussian26.1 ± 1.7

The real-token starts in this table reach 64.0–66.9, and no averaged or Gaussian start exceeds 52.2. The reported 0.8% untrained score comes from the weak vocabulary-mean initialization. The revision replaces the mean-pooling ablation with this table and states the design rule: initialize from actual token embeddings. LiveMath is where the choice matters most, because it has the most headroom (22.4 without a skill); on SearchQA and DocVQA all 12 initializations land within 72.9–76.8 and 88.0–90.1 (see our response to qLFm, Q2).

W2. "The first 32 tokens are front matter"

In our files they are task instructions. Our skills follow the academic setting (SkillOpt, GEPA, Trace2Skill), where a skill is a Markdown body with no YAML header. The LiveMath file starts with # Live Mathematical MCQ Heuristics, followed by ## Option Comparison and an instruction to compare all options before committing. In agent-skill formats with a YAML header for selection, the header can stay as textual metadata while the body is compiled. The table above also shows that the segment choice has little effect on the result.

Q1. LoRA data and configuration

LoRA used the same training split, answer-only target, and number of epochs as SoftSkill. This check also revealed that the submitted LoRA was under-configured: it targeted q/k/v/o_proj, which exist in only 8 of Qwen3.5-4B's 32 layers. We re-ran it on all linear layers with a small rank/learning-rate sweep:

SearchQALiveMath
LoRA, all linear layers (tuned)80.5 ± 1.369.4 ± 9.3
SoftSkill75.5 ± 1.566.7 ± 1.7

LoRA leads clearly on SearchQA; on LiveMath the 2.7-point gap is small relative to LoRA's across-seed standard deviation (9.3 vs 1.7). SoftSkill reaches this range with 186–372× fewer trainable parameters (validation selects all-linear r=16 on SearchQA and r=8 on LiveMath and DocVQA), a smaller across-seed standard deviation on LiveMath, and no change to backbone weights. We have corrected Table 1 and no longer claim that SoftSkill outperforms weight adaptation.

W3. Prior work

Both papers are now cited and placed in a positioning table in the main text; the key difference is the training objective. Context-compression methods commonly train representations to reproduce the model's behavior with the document present. SoftSkill applies NTP to successful task trajectories and selects checkpoints by downstream validation performance, so it can improve on its source document: on LiveMath the trained block scores 66.7, against 28.2 for the skill text it is initialized from, 52.0 for the rollout-optimized textual skill, and 22.4 for no skill. (A distilled representation can also exceed its teacher, but that is not what behavior matching optimizes.)

  • Cartridges trains a KV cache to reproduce the model's behavior with a long document in context (self-study / context distillation), which suits settings where preserving the document's information is the goal. We instead target task instructions whose value lies in the behavior they induce; skill optimizers improve such instructions through task feedback.
  • SkillSmith (arXiv:2607.27497) learns a model that composes a library of trained parametric skills with text, with a text-initialized prefix as one baseline. We study a single skill and what it takes from its text. The two fit together: a SoftSkill block is the kind of primitive SkillSmith composes.

We also agree that p = p₀ + Δp is equivalent to optimizing p from p₀, and we have removed it from the contributions.

W4. Practicality

Transfer across families: the Markdown skill remains the portable source, and the block is compiled per model, just as LoRA weights are trained per model. Compiling a block takes roughly 5–30 minutes on one GPU (including evaluation) in our LiveMath and SearchQA settings, and the procedure also works on a second model family without retuning. On Llama-3.1-8B, SoftSkill reaches 58.6 ± 4.6 (LiveMath) and 77.9 ± 1.5 (SearchQA), against an all-linear LoRA's 57.5 ± 4.7 and 80.6 ± 0.6. As on Qwen, SoftSkill is close to LoRA on LiveMath and behind it on SearchQA.

We also correct the diagnosis of 4B↔35B transfer in the submission. The two models share a 248,320-token vocabulary, so vocabulary mismatch cannot explain the failures. They differ in hidden size (2560 vs 2048) and have independently trained embedding spaces, so the block must be projected rather than copied. A more likely cause is that this projection does not preserve the learned displacement. Consistent with this, mapping the trained ALFWorld block to nearest vocabulary tokens restores the initialization outcomes. Transfer is task-dependent: DocVQA reaches 93.0 versus 93.3 for target-trained SoftSkill, whereas LiveMath falls to 15.3. The revision presents this explanation as a hypothesis and leaves learned cross-model mappings to future work.

Loading: the block keeps its gains across prompt positions and perturbed contexts. With 32 tokens on LiveMath, the skill slot outperforms the prompt start in both the length sweep (68.0 vs 66.4) and the placement study (64.5 vs 50.0), and both positions stay far above no skill (22.4). Without retraining, the ALFWorld block keeps its advantage under instruction paraphrase, formatting changes, and injected irrelevant context (gains of 26.9–40.3 points, p < 1e-8). We have not yet evaluated insertion partway through an ongoing agent trajectory, and the paper states this.

W1. Writing

  • Splits: the released SkillOpt splits (e.g. LiveMath 35/18/124), now stated in Section 4 together with a single selection rule.
  • "LLM skill" vs "NL skill": the terminology was inconsistent. The "LLM-written skill" is written by a strong LLM from the task description, with no rollout feedback. The "NL skill" is the starting document that SkillOpt optimizes and that we initialize from. The revision uses one name per object and adds a terminology table.
  • Score of the init skill (untrained, full length): SearchQA 67.7, LiveMath 28.2, DocVQA 91.2.

We hope the experiments in our two-part rebuttal were useful. We want to offer a clearer framing of the contribution, as the replies covered considerable ground.

The question we study. Agent systems increasingly maintain task knowledge as Markdown skill documents that are re-read on every inference call. We ask: can such a document be compiled, once per model, into a short block of continuous vectors that fits the same named prompt slot, requires no backbone changes, and runs on the same serving stack? The answer is yes. The compiled block (32 × d, ~160 KB in bf16) is inserted via vLLM's prompt-embeds interface; the serving stack and the backbone are unchanged. Practitioners keep the Markdown skill as the auditable, portable artifact.

Three things the paper establishes that were not established before. (i) Initialization geometry dominates segment choice. Any real-token start (first 32 tokens, 32 random tokens from the skill, 32 random vocabulary tokens) lands within a 3-point band on LiveMath; every averaged or Gaussian start is 12–40 points lower. Which 32 tokens you pick barely matters; that they are actual token embeddings matters enormously. This design rule is not stated or tested in Cartridges or SkillSmith. (ii) Task-outcome training exceeds the source document. SoftSkill (66.7) beats the rollout-optimized textual skill from which it was initialized (52.0 on LiveMath). Behavior-matching objectives are bounded by the teacher's task performance in a way that task-outcome supervision is not. (iii) Data efficiency at the low-data end, on reasoning tasks. At 10% of available training data, SoftSkill leads LoRA on LiveMath (37.1 vs 33.1); on DocVQA it matches or exceeds LoRA at every data fraction tested. On SearchQA, LoRA leads throughout.

Why frozen backbones matter here. Both prefix blocks and LoRA adapters can be served efficiently in modern inference stacks. The specific difference is what gets modified and how much gets stored. A SoftSkill block is ~81K parameters (~160 KB in bf16) versus 15–30M for a LoRA adapter; with many skills per model, the storage gap is meaningful. More importantly, backbone weights stay genuinely unchanged, which is useful in self-improving agent loops where accumulated weight modifications across sequential skill updates can be hard to predict or reverse.

On the two practicality concerns.

  • Transferability: Text skills are more portable, and we agree. The relevant question is whether portability matters when model weights are accessible. Access to weights is what enables compilation, and compilation is what yields the performance gain over the text skill (LiveMath 66.7 vs 52.0 for the rollout-optimized source). If weights are not accessible, compilation is unavailable regardless and text skills remain the right tool. The Markdown document stays portable and auditable; the compiled block is a per-model artifact, analogous to a LoRA checkpoint.
  • Mid-rollout insertion: The standard setup in SkillOpt and related work places skills in the system prompt before the trajectory begins, and we follow that convention. There is no technical obstacle to mid-rollout insertion — our marker mechanism already supports any prompt position — but doing so requires the model to identify autonomously which skill to retrieve and when, a scheduling problem separate from skill compilation. We state this limitation in the paper.

We recognize that a reviewer with direct research experience may still see this as a solid empirical study rather than a theoretical contribution. We believe the deployment path, the design principles, and the comprehensive analysis (12 initialization conditions, placement, data scaling, model scale, transfer, mechanistic interventions) are useful to anyone building agent skill systems. We would be grateful if you reconsidered the score in that light, and are happy to clarify anything further.

Comments on the paper

2 comments
AuthorsOpenReview ↗

General Response and Summary of Updates

We thank all reviewers for their constructive feedback. Reviewers find SoftSkill a simple and effective way to turn an existing textual skill into a compact trainable context while keeping the backbone frozen (qLFm), and note the motivation of the problem and the reasoning behind the design (9Z5b). They also highlight the evaluation across multiple tasks and models (GHQz), including QA and agentic tasks, initialization and placement ablations, robustness tests, and mechanistic interventions (qLFm).

Agents increasingly carry task knowledge as natural-language skill documents, and those documents improve by rewriting, which makes them longer: the rollout-optimized SearchQA skill we compare against runs to 2,035 tokens and is re-read on every call. A skill document also does two jobs: its words carry knowledge, and its presence puts the model into a behavioral mode (compare all options before committing, check the retrieved passage). SoftSkill treats the Markdown skill as source code and compiles it, for a given model, into a short block of continuous vectors in the skill's own prompt slot. The backbone stays frozen. The block starts from the skill's token embeddings, is trained by next-token prediction (NTP) on successful task trajectories, and is selected by downstream validation performance. It is never trained to reconstruct the document or to match a document-conditioned teacher. Authors still write and audit the Markdown skill, while the model is served a 32 × d block (≈160 KB in bf16). Text-initialized soft prompts are an existing technique; our contribution is to study how much of a textual skill's behavioral benefit a compact, task-trained block of 32 input vectors can capture, and why. Layerwise interventions further locate an important early-layer effect of the learned displacement.

Our response addresses the raised concerns with additional experiments. Unless noted otherwise, they use Qwen3.5-4B, three seeds, and the same evaluation harness. Details are in the individual responses. The main updates are:

  1. 32 vectors beat every evaluated textual skill on SearchQA and LiveMath (9Z5b, GHQz). The evaluated skills include rollout-optimized skills up to 64× longer (LiveMath 66.7 vs 52.0, SearchQA 75.5 vs 71.2). Paired bootstrap CIs and McNemar tests now accompany the main comparisons. On DocVQA, where the no-skill baseline already scores 86.9, the optimized SkillOpt text skill stays ahead (89.0 vs 88.2).

  2. A properly tuned LoRA replaces the under-configured one; SoftSkill approaches it with a frozen backbone (GHQz, 9Z5b). With all linear layers and a rank/learning-rate sweep, LoRA leads on SearchQA (80.5 ± 1.3 vs 75.5 ± 1.5); on LiveMath its 69.4 ± 9.3 is within seed variability of SoftSkill's 66.7 ± 1.7. LoRA trains 186–372× more parameters (15.2–30.5M against 81,920) and modifies backbone weights.

  3. The same pattern holds on a second model family, Llama-3.1-8B-Instruct (9Z5b, GHQz). With no retuning, SoftSkill is close to LoRA on LiveMath and behind on SearchQA, as on Qwen.

  4. The initialization must use actual token embeddings, while the choice of skill segment has little effect (GHQz, qLFm). Across 12 initializations (different 32-token segments, random spans, random skill tokens, random vocabulary, generic instruction, the wrong task's skill, skill-token mean, vocabulary mean, norm-matched Gaussian), every block built from real token embeddings lands at 60–69 on LiveMath and every averaged or Gaussian block at 26–52. Skill content adds to this effect: the right skill beats a generic instruction and the wrong task's skill.

  5. Block length acts as a capacity hyperparameter, and about 32 tokens suffice (qLFm). A sweep over 8–256 tokens × 2 insertion slots shows gains up to about 32 tokens and no systematic gains beyond that.

  6. Clearer writing and positioning (9Z5b, GHQz). The revision adds a full related-work section and positioning table, one name per skill artifact, the experimental protocol in the main text, and the baseline corrections detailed in our reviewer-specific replies. Changes that respond to reviewer comments are highlighted in blue in the revised PDF.

In summary, SoftSkill outperforms all evaluated textual skills on two of three tasks, approaches a tuned LoRA with 186–372× fewer parameters on two model families, and the new ablations give a rule for choosing initialization and length. We hope these updates address the reviewers' concerns and are happy to clarify anything further.

Dear Reviewers and Area Chair,

Thank you again for your time and thoughtful feedback. We hope our individual replies were useful. We would very much appreciate hearing from each reviewer before the discussion period closes, and are happy to address any remaining questions.

What we study. Agent systems increasingly maintain task knowledge as Markdown skill documents that are re-read on every inference call. We ask whether such a document can be compiled once per model into a short prefix block that occupies the same prompt slot, runs on the same inference stack, and matches or exceeds the source document on task performance.

What the paper establishes. (i) Initialization geometry determines whether the method works. Any real-token start works; averaged or Gaussian starts fail significantly. Which tokens you pick barely matters; that they come from actual token embeddings determines success — a design rule not established in prior context-compression work. (ii) Task-outcome training can exceed the source document. Training on task outcomes rather than document fidelity lets the block surpass the textual skill it was initialized from, including the rollout-optimized version. (iii) On reasoning tasks under limited data, the method is competitive with LoRA, while using far fewer parameters and leaving backbone weights unchanged. (iv) The compiled block is a direct replacement for the text skill, occupying the same prompt slot with the same serving stack; the Markdown document remains the portable, auditable artifact.

Best regards, The Authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.