Agent skills are short documents that teach a language model how to handle a class of tasks. To save context, these documents are increasingly compiled into low-rank adapters (LoRA), which keep the behaviour but lose the text: an adapter is hard to read, edit, audit or move to another model. We ask whether the skill document can be written back from the adapter and its frozen base model, and we score each recovered document by the share of the original's key instructions it states and by the tasks it solves. Reading the weights alone recovered little with the methods we tried; a learned map from weights to text passed on about one bit of the document. Running the adapter worked much better. The Executing Writer, a small writer trained on top of the adapted model, recovers 39-44% of the key instructions of held-out skills, against 1.3-1.5% with another skill's adapter, and on adapters fitted to 41 external skills its documents restore 85-91% of the original's task gain. These strongest results are on adapters whose training stored the document; adapters trained on behaviour alone are much harder for trained writers (1-2% of instructions). For these adapters we test an agent that runs the base and adapted models and writes a skill from where they differ. On ALFWorld its skills recover 58-71% of a LoRA's gain and carry over to models that cannot load the LoRA, lifting Llama-3.1-8B from 5% to 55%. Whether such a skill comes from the adapter depends on what the adapter learned: when its behaviour cannot be guessed, the adapter is the source; when it can, a reward loop without the adapter does as well.
Figures & tables
Figure 1: The pipeline. A skill document s is compiled into an adapter Δs . The Executing Writer attaches Δs (frozen) and a trainable writer ϕ to the frozen base model θ and generates a document s^ . Recovery is scored by the share of the original’s key instructions that s^ states and by whether s^ still works when given to a model.
Family
How it is made
Document in a training target?
Document-bearing
A hypernetwork [ 9 ] compiles the document into an adapter. One checkpoint is trained to store its document ( document-fitted ); a further-trained one is tuned for agent behaviour ( task-tuned ).
yes for document-fitted, no for task-tuned
Recitation
We fit a LoRA by gradient descent to print the document after a trigger (ranks 16 , 32 , 64 ).
yes, as the output
Behavioural
The model answers requests with the document in its prompt; a LoRA is fitted to give the same answers without it (context distillation).
no
Table 1: The three adapter families used in this paper.
Figure 2: Three ways to read an adapter. R1 and R2 never run the adapter; R3 runs it inside its base model and trains only a small writer. Grey: given and frozen; blue: trained; green: fixed computation. Recovery figures are from Table 3 .
Figure 3: The Executing Writer. (a) At test time the adapter is attached to its frozen base model and a small writer ϕ makes the adapted model write the document; EW-T also receives the text read by R2 (dashed). (b) Training updates only ϕ .
Experiment
Base model
Adapters
Skills / tasks
Metric
Three readers (§ 6.1 )
Qwen3-8B
document-bearing, rank 8
37 skills
coverage
Transfer and rank (§ 6.3 )
Qwen3-8B
recitation, rank 16 – 64
37 + 41 skills
coverage
Behavioural adapters (§ 6.4 )
Qwen3-8B
behavioural, rank 16 , 64
41 skills, 323 tasks
coverage, task score
Agent with documents (§ 6.5 )
Claude Haiku 5.5 agent
recitation, rank 64
4 benchmark tasks
verifier tests
Executing agent (§ 7 )
Qwen2.5-7B, Qwen3.5-4B
behavioural, rank 16 – 32
ALFWorld, 6 other tasks
task success
Table 2: Experiments, models and metrics. Numbers from different rows are comparable only where the setting matches.
Method
Judge 1
Judge 2
Wrong adapter
30 skills
Unsupported
Retrieval of a similar document
26.9
35.2
—
15.3
66
Keyword writer (weights only)
16.1
23.5
3.3
14.6
—
Instruction writer (weights only)
22.3
33.3
1.6
20.4
54
Soft-prompt writer, 4B (weights only)
22.7
33.2
22.5
18.2
55
Soft-prompt writer, 8B (weights only)
20.9
31.3
23.1
18.2
55
EW-T † (adapter and text)
43.7
61.5
1.3
39.9
39
Table 3: Recovery on the 37 test skills (percent). Coverage by two judges, coverage with a wrong adapter, coverage on the 30 skills without near-copies, and the unsupported share (lower is better). † : runs the adapter. EW-T reads document-fitted and EW-A task-tuned adapters; the other rows use document-fitted adapters.
Reader
Loss, correct
Loss, wrong
Gap G
Bits per 1k tokens
R1 soft prompt, complete adapter
1.220
1.221
0.001
≈1
R2 keywords
1.292
1.375
0.083
≈120
R2 keywords and instruction lines
1.271
1.398
0.127
≈180
R3 Executing Writer, EW-T
0.289
3.934
3.645
≈5,260
R3 Executing Writer, EW-A
0.323
3.936
3.613
≈5,210
Table 4: Adapter gap on 100 validation skills (nats per token): how much the correct adapter lowers the document’s loss against a wrong one.
Figure 4: Recitation adapters are read back more accurately at higher rank. Both writers have rank 16 ; only the adapter being read changes. With a wrong adapter coverage is about 2% (left) and 9 – 13% (right). Full tables in Appendix B .
Coverage of original
Precision
Whole doc.
Method
Rank
Prose
Struct.
Ident.
Prose
Struct.
Same
Recitation adapters
EW-T
16
84.1
85.1
85.1
85.8
65.5
83
EW-T
64
93.3
94.0
94.1
94.9
72.0
90
EW-A
16
79.7
80.1
78.0
84.5
63.2
73
EW-A
64
90.2
90.2
91.2
94.2
70.0
86
Table 5: Document fidelity on the 41 external skills (percent). “Same” is a second judge comparing whole documents.
Condition
Rank
All tasks
Hardest 91 tasks
Gain recovered (%)
No skill
–
55.5
23.2
0
Original skill in prompt
–
77.0
65.9
100
Recovered document in prompt, from recitation adapters
EW-T
16
73.6
59.2
84
EW-T
64
75.1
60.8
91
EW-A
16
71.5
56.0
74
Table 6: What documents and adapters do on 323 skill-dependent tasks (base-model score, percent). Gain recovered is relative to the original.
Skill in prompt
Intrusion det.
3D parser
Finance QA
PDDL plan
All runs
Tests (%)
None
0/8
0/8
0/8
3/8
3/32
59.7
Original
5/8
8/8
2/8
2/8
17/32
85.0
EW-T reconstruction
5/8
8/8
1/8
1/8
15/32
82.5
EW-A reconstruction
0/8
8/8
1/8
4/8
13/32
83.1
Table 7: Claude Haiku 5.5 as an agent on four SkillsBench tasks: runs passing all verifier tests (of 8 ) and the mean share of tests passed.
Arm
Sessions
Success
Range
R
References
LoRA
–
0.813
1.00
Base model (one session / loop protocol) a
–
0.254 / 0.261
0.00
Three in-context expert games a
–
0.709 / 0.679
0.81 / 0.76
One session, Haiku writer, no reward
Agent reads the adapter
6
0.581
0.42–0.72
0.58
Table 8: ALFWorld, 134 unseen games, Qwen2.5-7B-Instruct as actor. Each skill is given to the base model. R : share of the LoRA’s gain recovered.
Task (control)
What the adapter learned
Real
Control
Difference [ 95% CI]
Docker run → compose (wrong)
arbitrary output conventions
0.212
0.000
+0.212 [ +0.127 , +0.315 ] ✓
S4 ticket triage (wrong)
arbitrary rule
0.873
0.645
+0.228 [ +0.148 , +0.323 ] ✓
S2 fee calculation (wrong)
arithmetic rule
0.467
0.394
+0.072 [ −0.034 , +0.176 ]
S1 house format (wrong)
learnable from inputs
0.908
0.893
+0.015 [ −0.028 , +0.063 ]
ALFWorld, one session (wrong)
expert household play
0.581
0.521
+0.060 [ −0.061 , +0.184 ]
ALFWorld, loop (no adapter)
expert household play
0.653
0.673
−0.020 [ −0.076 , +0.038 ]
Table 9: Skills written from the real adapter versus a control, across tasks. Intervals resample items and sessions; ✓: excludes 0 .
Actor
Base
One-session skill
Loop, adapter
Loop, no adapter
Three games
Qwen2.5-7B (the LoRA’s base)
0.254
0.612
0.676
0.658
0.709
Llama-3.1-8B-Instruct
0.052
0.545
0.454
0.405
0.269
Qwen3.5-4B
0.022
0.664
0.385
0.564
0.396
Claude Haiku 5.5 (18 games)
0.944
1.000
n.r.
n.r.
n.r.
Table 10: The same skill documents, unchanged, on other actors (ALFWorld, 134 unseen games). The LoRA cannot be attached to any of them.
Pick (24)
Examine (18)
Clean (31)
Heat (23)
Cool (21)
Pick two (17)
Base model
0.50
0.06
0.16
0.39
0.19
0.24
LoRA
1.00
0.56
1.00
1.00
1.00
0.00
Loop skill, adapter
0.84
0.64
0.69
0.75
0.54
0.35
Loop skill, no adapter
0.83
0.61
0.70
0.73
0.65
0.43
Table 11: Success by ALFWorld task type on the home actor (reward-loop skills, mean of 12 sessions). Games per type in parentheses.
Appendix figures & tables7 assets
Supplementary material from the paper’s appendix.
Appendix
Coverage
Wrong adapter
Whole-doc. match
Writer
r=16
r=32
r=64
r=16
r=32
r=64
r=16
r=32
r=64
EW-T (no text)
72.4
86.8
92.0
2.3
1.9
1.7
60.7
79.3
82.7
EW-A
79.8
87.4
92.0
1.9
1.9
2.0
52.2
69.3
76.1
Appendix
Table 12: Executing Writers on adapters fitted to recite each of the 37 test skills (coverage, percent; whole-document match probability).
Writer
Rank
Prose cov.
Structure cov.
Identifier recall
Match prob.
EW-T (no text)
16
84.1
85.1
85.1
74.3
EW-T (no text)
32
92.1
93.4
94.4
79.1
EW-T (no text)
64
93.3
94.0
94.1
81.2
EW-A
16
79.7
80.1
78.0
52.1
EW-A
32
86.8
86.9
87.7
64.8
EW-A
64
90.2
90.2
91.2
73.1
Appendix
Table 13: Executing Writers on 41 SkillsBench skills with recitation adapters (percent). Identifier recall is counted by rule, with no judge.
Set
Method
n
M1, own
M1, wrong
Cov. own
Cov. wrong
Held-out skills
Generic probes
8
−0.14
−0.05
0.0
0.0
Vocabulary lens
8
−0.04
−0.09
6.6
0.0
Amplified answers
7
0.19
−0.07
4.5
0.0
Plain request
8
0.13
0.02
0.7
0.0
Best of n
7
0.11
0.00
5.6
0.1
Retrieval
8
0.03
−0.07
1.9
0.7
Appendix
Table 14: Judge-free recovery on held-out behavioural adapters (Qwen3-4B). Paper recipe: adapters made as in Section 6.4 .
Arm
S1
S2
S3
S4
R1
R3
Base model
0.000
0.194
0.000
0.225
0.735
0.140
LoRA ( 2,000 examples)
0.891
0.698
1.000
1.000
0.770
0.895
True skill
0.898
0.447
0.998
0.902
–
–
Skill P (task text)
0.909
0.404
0.000
0.860
0.730
0.190
Skill D ( 400 examples)
0.955
0.472
1.000
0.993
0.665
0.245
Skill A (adapter only)
0.927
0.454
0.970
0.935
–
0.200
Appendix
Table 15: Test score ( 200 items) per task. Skills are applied to the frozen base model unless stated. “–”: not defined or not run.
Arm
Exact
Soft
Base model (Qwen2.5-7B-Instruct)
0.000
0.186
LoRA docker_compose_gen
0.595
0.885
Wrong adapter ( dockerfile_gen )
0.000
0.079
Skill P (task text)
0.000
0.340
Skill D (training data), 2 sessions
0.313
0.819
Skill A (adapter only), 3 sessions
0.263
0.771
Appendix
Table 16: Docker-to-compose, 200 test items: exact match and soft score. Rows with several sessions give the session mean.
Added to the LoRA
Success
Change
Nothing
0.813
–
Short skill ( 148 words), system prompt
0.858
+0.045
Short skill, after the task text
0.843
+0.030
Three in-context games
0.836
+0.023
Three games + full skill, system prompt
0.821
+0.008
Reward-loop skills, system prompt (mean of 12 )
0.744–0.767
−0.05 to −0.07
Appendix
Table 17: The ALFWorld LoRA with text added to its prompt ( 134 unseen games, step cap 52 ).
Arm
Sessions
Win
Rule A
Rule B
Skill states its rule
Base model
–
0.261
0.000
0.000
–
LoRA-A
–
0.896
0.866
0.000
–
LoRA-B
–
0.851
0.000
0.851
–
Agent reading LoRA-A
6
0.604
0.005
0.000
5/6 (never rule B)
Agent reading LoRA-B
6
0.565
0.000
0.053
5/6 (never rule A)
Agent reading LoRA-A with a divergence list
6
0.636
0.001
0.000
6/6
Appendix
Table 18: Hidden-rule LoRAs on ALFWorld ( 134 unseen games). Rule columns give rule success: won and the rule followed.
Low-rank adapters (LoRA) make it cheap to fine-tune a large language model once per task, but combining several independently trained adapters into one model remains difficult: merging the updates in weight space causes interference, retraining on all task data is expensive, and routing between separate adapters gives up the goal of a single combined model. We trace the difficulty to two choices that every composition method makes implicitly. A LoRA update admits infinitely many equivalent factorizations; the choice among them is invisible while an adapter serves alone, but it determines what a learned interaction between adapters can see. A coupling between an old skill and a new one can likewise point in either direction, and the direction decides whether the old skills keep computing what they computed before. We introduce READ (Read-only Expansion of Adapter Deltas), which fixes both choices: each adapter is rewritten into a balanced canonical form that preserves its update exactly, and the coupling grows in one direction only, so a new skill can read the input subspaces of old skills but cannot write into their output subspaces. The only trainable object at each append is the new skill's row of the coupling matrix, and the composed update folds into the base weights with no inference cost, routing, or task-specific rules. We evaluate READ across four benchmark suites and two model families, adding skills one at a time. Across several families, READ improves every suite average over the strongest published baselines built from the same adapters---by more than twenty points on SuperGLUE and more than seven points on the domain suite---and nearly all complete addition sequences end above every direct baseline. Factor coordinates and coupling direction, which a lone adapter never exposes, are what decide whether composed skills survive.
Zeyan Li, Panqi Yang, Qirong Guo +5
Shanghai Jiao Tong University · Xi’an Jiaotong University · The Hong Kong University of Science and Technology (Guangzhou) +1
Agent skills are commonly distributed as SKILL.md files: human-readable procedural documents that describe workflows, tools, resources, and domain conventions. While convenient for inspection and reuse, this design requires the same reusable procedure to be repeatedly injected into the runtime context. We propose Skill-to-LoRA(S2L), a behavior-centric skill representation that replaces runtime skill text with skill-specific LoRA adapters. Rather than compressing the skill document itself, S2L models the behavioral change induced by the skill text: offline, the complete SKILL.md is used to synthesize skill-guided demonstrations; online, the full document is omitted and the corresponding LoRA adapter is dynamically loaded to activate the learned skill behavior. We evaluate S2L with Qwen3.6-27B on a 21-skill subset of SWE-Skills-Bench. Compared with the no-skill and Full Skill Text baselines, S2L improves pass rate by 2.9 and 5.2 percentage points, respectively, while reducing per-step token cost by 6.6% relative to Full Skill Text prompting. S2L matches or improves Full Skill Text on 18/21 skills and the no-skill baseline on 15/21 skills. Control experiments further show that the gains depend on skill-specific adapter alignment: Wrong-LoRA and Shared-LoRA both reduce performance. These results suggest that many procedural agent skills can be converted from runtime instructions into trainable, dynamically loadable behavioral modules. Code will be released upon acceptance.
Agent systems increasingly use textual skills to encode reusable task procedures, but injecting these skills into the prompt at every step incurs substantial context overhead and exposes skill content as plaintext. We present LatentSkill, a framework that converts textual skills into plug-and-play LoRA adapters through a pretrained hypernetwork. LatentSkill stores skill knowledge in weight space rather than context space, removing per-step skill tokens while preserving modular loading, scaling, and composition. On ALFWorld and Search-QA, LatentSkill outperforms the corresponding in-context skill baseline while using substantially fewer prefill tokens: it improves ALFWorld success by 21.4 and 13.4 points on the seen and unseen splits with 64.1% fewer prefill tokens, and improves Search-QA exact match by 3.0 points with 72.2% lower skill-token overhead. Further analysis shows that generated skill LoRAs form a structured semantic geometry, can be precisely controlled via the LoRA scaling coefficient, and can be composed through parameter-space arithmetic when skill components are aligned. These findings suggest that weight-space skills provide an efficient, modular, and less exposed substrate for extending LLM agents.
Aofan Yu, Chenyu Zhou, Tianyi Xu +8
Shanghai Jiao Tong University · Sun Yat-Sen University · Shanghai Innovation Institute +1