acceptodds
Under review as a conference paper at ICLR 2027

SkillFM: Generating Skills for LLM Agents via Latent Flow Matching

Abstract

Textual skills provide reusable guidance for large language model agents, but existing approaches often rely on manually curated skill banks or reinforcement learning with indirect and delayed feedback. We introduce **SkillFM (Skill Flow Matching)**, a generative framework that synthesizes task-conditioned textual skills directly without test-time skill retrieval. Our framework combines a codec for encoding and reconstructing textual skills in a continuous latent space with a conditional flow model trained using improved MeanFlow. At inference time, the learned velocity field enables single-step latent sampling, and an LLM-based decoder converts the sampled representation into textual guidance for a frozen downstream agent. We evaluate the framework on embodied tasks, question answering, and web shopping. On ALFWorld and Search-QA, our method achieves the best overall performance among the compared vector-based skill approaches. Our analyses further demonstrate that latent skill generation is an effective alternative to retrieval-based skill augmentation.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Large Language Model Agents, Latent Skill, Flow Matching

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_8MtkOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces SkillFM, a two-stage framework capable of generating task-relevant textual skills for frozen LLM agents without requiring skill retrieval at test time. First, a skill codec is trained to encode textual skills into a continuous, decodable latent space; subsequently, a conditional one-step flow matcher learns a velocity field that maps task descriptions to latent skill codes and decodes these codes back into readable instructions. SkillFM achieves superior performance compared to vectorized skill baselines on the ALFWorld, Search-QA, and WebShop datasets, demonstrates portability across model families, and exhibits robustness against retrieval issues in the presence of noisy skill libraries.

Critical strengths

The experiments are comprehensive, featuring multi-domain evaluations and employing consistent frozen-encoder settings and ablation studies to isolate the impact of the codec training and pipeline. The work demonstrates a viable alternative to retrieval-intensive pipelines, thereby simplifying deployment and reducing reliance on complex memory management (a point I particularly value).

Critical weaknesses

1: Baseline comparability: Much of the baseline data originates from prior studies where the actuators, prompting rules, or operational budgets may not have been identical. Retrieval baselines under noise conditions lack specific details (regarding retrieval models, re-ranking, or top-k strategies), potentially leading to an underestimation of robust retrieval pipelines (a point I particularly value).

2: Jointly learned latent language generators offer an alternative to the two-stage codec-plus-stream approach; however, the relevant discussion is confined to the appendix, and a more explicit comparison in the main text would have been beneficial.

Questions for authors

1: Previous studies have reported several baselines. Could key baselines (e.g., LatentSkill, SHINE, strong retrieval methods) be re-run using the same actuators, prompts, and operational budgets to ensure a fair comparison?

2: How robust is the decoding process to latent perturbations at inference time (e.g., small Gaussian noise or geodesic noise around z^\hat{z})? Does the decoding of skills degrade gracefully, and does this correlate with success?

3: For retrieval baselines with noise levels below 25%, what retrievers and settings were used (embedding models, kk values, re-ranking, hybrid sparse-dense approaches)? Could a stronger retrieval-plus-re-ranking baseline be added to facilitate a better comparison?

8 comments
AuthorsOpenReview ↗

Response to Reviewer 8Mtk (W1): Baseline Settings

We are grateful for your thorough review and helpful questions, which have helped us improve the paper. Our responses to each point are provided below.
We would like to add that our ALFWorld protocol strictly follows that of LatentSkill and related work: the same executor (Qwen3-8B in thinking mode, frozen), nearly identical prompts (the only difference being that our skills are injected via the prompt, whereas their methods use LoRA), the same interaction budget (ALFWorld's default maximum of 50 steps), and a shared evaluation pipeline. Moreover, our vanilla baseline results closely match their published numbers which means our pipeline are idetical. When we reproduced the key baselines in our own environment, they fell short of the results reported in the original papers; to keep the comparison conservative, we therefore report their (higher) published numbers. The results are as follows:

MethodSourceSeenUnseenTotal
VanillaReported in LatentSkill43.6%47.0%45.3%
VanillaOur environment43.6%50.0%46.7%
LatentSkillReported in LatentSkill74.3%69.4%71.9%
LatentSkillOur reproduction68.6%67.2%67.9%

In addition, our WebShop and Search-QA experiments follow the same settings as the baselines; please refer to Appendix B.1 (Table 14) of the revised paper for details.

Reference

[1] Aofan Yu, Chenyu Zhou, Tianyi Xu, Zihan Guo, Rong Shan, Zhihui Fu, Jun Wang, Weiwen Liu, Yong Yu, Weinan Zhang, and Jianghao Lin. LatentSkill: From In-Context Textual Skills to In-Weight Latent Skills for LLM Agents. arXiv preprint arXiv:2606.06087, 2026.

AuthorsOpenReview ↗

Response to Reviewer 8Mtk (W1, Q1, Q3): Retrieval Details and Additional Experiments under Noise

Retriever and settings. All retrieval baselines in the noisy-bank experiments use one dense retriever, fixed before any test rollout: Qwen3-Embedding-0.6B, with last-token pooling, L2-normalised vectors and cosine similarity. The query is the task text. Each skill is embedded as it is. We retrieve once per episode and execute the top-1 skill. We use no re-ranking and no sparse component.

Stronger retrieval. Following the suggestion, we ran every domain with re-ranking. The top-5 distinct skills from the same index are re-scored by the cross-encoder Qwen3-Reranker-4B, and the highest-scoring skill is executed. Executor, prompts and budgets are unchanged.

Domain (metric)Dense top-1Dense top-5 + rerankerOurs
ALFWorld (SR)34.6734.3175.91
WebShop (SR)15.2017.2018.40
Single-hop QA (EM)42.2040.7345.73
Multi-hop QA (EM)27.4529.4231.82

Scaling the encoder to 4B helps, but the retriever still stays far below our method.

ALFWorld retrieverSeen SR (%)Unseen SR (%)Overall SR (%)
0.6B encoder, top-138.630.634.7
0.6B encoder, top-5 + reranker36.432.134.3
4B encoder, top-145.739.642.7
4B encoder, top-5 + reranker47.939.643.8
Ours74.377.675.9
AuthorsOpenReview ↗

Response to Reviewer 8Mtk (W2, Q2): Clarifying the Model Architecture and Robustness to Noise

As for W2, the jointly learned latent language generators mentioned in Weakness 2 are not the approach we adopt. We train the codec and the flow in separate stages, so that the codec first establishes a stable latent space and the flow is then learned on top of it. Following your suggestion, we added Section 5.4 ("Two-stage versus joint latent generation") to the main text. It compares SkillFM with jointly learned latent language generators (text VAEs and embedding diffusion) and with two-stage approaches that fit a generator to frozen autoencoder latents, and explains why we adopt the two-stage design: the flow target stays fixed, which avoids latent collapse; the frozen latent space lets generated codes be checked against the decoder's training range; and flow training does not back-propagate through the codec. Our ablations, together with the additional direct-mapping and retrieval baselines, support the necessity of flow matching.

Robustness to Noise

The codec decoder is trained with spherical perturbations of up to 0.35 rad (Section 3.2 and Appendix B.1). Following your suggestion, we tested whether this robustness holds at inference time. Details are provided in Appendix I.

Setup. For each of the 274 ALFWorld test tasks, we took the generated skill latent z^\hat z from the main run and perturbed it in two ways:

  • Geodesic noise on the unit hypersphere: z^′=cos⁡θ z^+sin⁡θ u\hat z' = \cos\theta\,\hat z + \sin\theta\,u, where uu is a random unit vector orthogonal to z^\hat z.
  • Gaussian noise with scale σ=tan⁡θ\sigma = \tan\theta relative to ∥z^∥\|\hat z\|, so that the realized angle approximately matches θ\theta.

We swept θ\theta from 0.05 to π/2\pi/2 and decoded every perturbed latent with the frozen decoder, greedily and one latent at a time (6,028 decodes in total). A decode is task-consistent if it names the correct task type, object, receptacle, and tool, and its route acts on them. We also record whether its text is identical to the decode of the unperturbed z^\hat z. Decoding the unperturbed z^\hat z twice gives identical text in 274/274 tasks.

Degrades gracefully. Geodesic and Gaussian noise give nearly identical results:

θ (rad)Task-consistent (geodesic)Identical (geodesic)Task-consistent (Gaussian)Identical (Gaussian)
099.6%100%99.6%100%
0.0599.8%76.7%99.6%78.8%
0.1100%73.4%100%74.0%
0.299.3%58.2%99.6%61.2%
0.396.9%38.6%96.7%41.8%
0.573.4%4.4%73.4%2.9%
0.80%0%0%0%
π/20%0%0%0%

Up to θ=0.3\theta = 0.3 rad, within the codec's training perturbation range, at least 96.7% of decoded skills remain task-consistent. This range covers the generated endpoints: on the flow-stage holdout, the 95th-percentile angle from generated endpoints to their nearest reference codes is 0.28 rad (Appendix F.4). Exact text identity falls smoothly as θ\theta grows, so small perturbations change only surface details, such as object instance indices, the order in which locations are searched, and wording, while the skill still describes the same task. Consistency reaches zero at about 0.8 rad, the median angle between two training skills, where the decoder switches to a different skill.

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

LLM agents can use textual skills to guide task execution, but existing approaches often require retrieving and maintaining a skill bank. This paper proposes SkillFM, a method that learns from a skill bank offline and generates task-specific skills without retrieving bank entries at test time. The authors first train an encoder–decoder to represent textual skills as latent vectors and reconstruct the original text. They then train a task-conditioned flow model using improved MeanFlow to generate skill vectors from noise in a single flow step. These vectors are decoded into textual guidance for a frozen agent. The authors evaluate the method on ALFWorld, Search-QA, and WebShop, and report improvements over several baselines. They also test whether the generated skills can guide different frozen agents.

Critical strengths

SkillFM allows the same skill generator to support different executor models without updating their parameters. The cross-model experiments provide evidence that the generated guidance can transfer across model families.

Critical weaknesses
  1. The necessity of the latent flow (and the claim that generation outperforms retrieval) are not adequately supported. The self-run controls (w/o flow, w/o codec training, decoder-only SFT) all fall below the no-skill baseline in overall success. They show that degraded skills hurt the actor, not that the flow is essential. Without comparisons to simple alternatives trained on the same task–skill pairs, “replacing retrieval with generation” is not an established advantage.
  2. Limited cross-domain validation. SkillFM is trained separately for ALFWorld, WebShop, and QA. Although the paper demonstrates transfer across executors, it does not evaluate whether a generator trained in one task domain can produce useful skills in another without retraining.
Questions for authors
  1. Does generation add value beyond retrieval? How does SkillFM compare with simple baselines that use the same task–skill pairs? For example, using the same frozen query encoder to find the nearest training condition and passing its paired bank skill verbatim to the actor.
  2. Technical novelty. What technical challenges are specific to skill generation, and which design choices address them? In particular, what motivates using latent flow matching over skill generators?
  3. Controlled baseline comparisons. Section 4.1 states that the main-result baseline scores from WebShop are taken from prior papers rather than rerun under matched settings. Could you rerun key WebShop baselines with the same Qwen3-8B executor?
  4. Test-set information during development. Appendix G states that multi-hop evaluation-policy development used test-set information. What information was used, and why was it used?
  5. Skill-bank construction. For QA and WebShop, how were the additional authored or revised skills produced and validated? What proportion of the training bank comes from these skills versus summaries of successful trajectories?
  6. Cross-domain transfer. Could you evaluate whether a SkillFM generator trained in one task domain can generate useful skills for a different domain without retraining?
6 comments
AuthorsOpenReview ↗

Response to Reviewer 6nqa (W1, Q1, Q2): Necessity of Latent Flow

Thank you for your careful reading of our paper and your constructive feedback. We address each of your comments below.
To sufficiently isolate the contribution of latent flow matching, we ran additional experiments with nearest retrieval, reranking, and a simple latent-skill predictor on the clean skill bank (the same one used by our main method). All experimental settings are identical to those of the main method(the same training pairs, codec, executor, prompts, and execution budgets). The results are shown below.

MethodSeenUnseenTotalΔ
SkillFM(ours)115 (82.1%)113 (84.3%)228 (83.2%)—
Embedding top-1110 (78.6%)102 (76.1%)212 (77.4%)−5.84
Embedding top-5 + Qwen3-Reranker-4B110 (78.6%)107 (79.9%)217 (79.2%)−4.01
BM25 top-1112 (80.0%)105 (78.4%)217 (79.2%)−4.01
Task2Latent predictor101 (72.1%)103 (76.9%)204 (74.5%)−8.76

Even without noise, retrieval still underperforms our main method, which demonstrates the advantage of our generative approach; this advantage becomes even more pronounced when the skill bank contains noisy or out-of-domain skills (Table10). We also trained a model that directly regresses the latent skill from the condition, as an additional ablation that highlights the importance of latent flow matching. Together with the Decoder-only SFT results, these experiments demonstrate the necessity of the full system.

Technical novelty:

Challenges: Skill generation needs to turn a brief task condition into a much longer text skill that is reusable across similar scenarios; Generated skills must transfer across different executor models.

Design: We decouple the generation of global strategy information in latent space from autoregressive text generation. LatentSkill generates LoRA weights tied to a specific backbone. In contrast, our skills are plain text, and all trained components are separate from the frozen executor.

Why latent flow matching: As detailed in our response to Q1 above, our method outperforms both retrieval and direct latent mapping, and it is also more robust to noise(Table10) and transfers better across executors(Figure3).

AuthorsOpenReview ↗

Response to Reviewer 6nqa (Q3): Baseline Comparisons

On WebShop, we evaluate with Qwen2.5-7B, the same executor used by the other methods. The results are as follows:

MethodSR (%) ↑Score ↑
Mem02.0023.90
ExpeL11.2030.90
MemP6.4025.30
SimpleMem8.5933.20
MemRL9.2029.50
EvolveR17.6042.50
Ours18.6038.14

We additionally include several methods built on Qwen3-8B for comparison, under a strictly identical evaluation protocol. The results are as follows:

MethodSR (%)Score
AWM–30.7
No Memory9.833.3
Memento-Skills–34.3
ReasoningBank11.435.4
MemP12.035.7
SkillOS-gemini13.238.1
SkillOS-base13.638.6
SkillOS16.540.6
EASE–42.8
SkillFM (Ours)20.055.4
AuthorsOpenReview ↗

Response to Reviewer 6nqa (W2, Q6): Cross-Domain Results

We have examined this question. On Search-QA, we train separately on single-hop NQ and multi-hop HotpotQA, and evaluate on both in-domain datasets (NQ and HotpotQA) and out-of-domain datasets (TriviaQA, PopQA, 2WikiMultiHopQA, MuSiQue, and Bamboogle). The results show that our method generalizes across domains on related question types and outperforms comparable baselines on average (Table 2). We further show that this ability holds across executor model families and scales (Table 4).

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

SkillFM generates task-conditioned textual skills for frozen LLM agents using a learned skill codec and conditional latent flow matching. A generated latent code is decoded into reusable guidance without test-time skill-bank retrieval. The paper evaluates downstream performance on ALFWorld, Search-QA, and WebShop, alongside cross-actor transfer and skill-bank robustness analyses.

Critical strengths
  • The architecture combines latent skill generation with a readable textual interface, allowing the same generator to support different frozen executors. The cross-family ALFWorld results provide promising evidence that generated guidance can transfer without adapting actor parameters.

  • The ALFWorld results are encouraging, with reported success rates of 82.14% on seen tasks and 84.33% on unseen tasks. Component ablations and experiments varying skill-bank size and quality provide useful evidence about the system’s dependence on its learned components and training data.

Critical weaknesses
  • The Search-QA generalization evidence is compromised by evaluation-policy development using test-set information, explicitly acknowledged in Appendix G. Consequently, the multi-hop results and the aggregate Search-QA improvement cannot be interpreted as an independent held-out comparison. The disclosure is appreciated, but a fixed-policy evaluation on fresh questions is necessary to substantiate this central empirical claim.

  • The comparisons do not sufficiently isolate the contribution of latent flow matching. Main baselines use published results rather than a shared evaluation pipeline; WebShop additionally uses different executor backbones. The no-flow ablation bypasses learned latent generation, but does not compare against a simpler trained task-to-latent predictor. Decoder-only SFT is informative, yet these experiments leave the specific advantage of flow matching over simpler generation or matched retrieval approaches unresolved.

Questions for authors

What test-set information was used during multi-hop evaluation-policy development, and which components were affected? Can you evaluate the frozen system and matched baselines on fresh held-out questions?

How does SkillFM compare with clean-bank retrieval and a deterministic task-to-latent predictor using the same training pairs, codec, executor, prompts, and execution budgets?

The main results specify NFE=1, whereas Appendix D describes an NFE=2 evaluation with the same ALFWorld success/failure counts. Which sampler produced the headline results, and are these separate runs?

7 comments
AuthorsOpenReview ↗

Response to Reviewer 2Dob (W1, Q1, Q3): Clarifying Ambiguities in the Appendix

Thank you for your thoughtful review of our paper and for raising these important points. We would like to address the weaknesses and questions you highlighted as follows.

Thank you for raising this point. Our description in Appendix was unclear, and we did not correct it before submission. To clarify: test results were used only as auxiliary evidence when we were deciding how to select flow-matching checkpoints, and the test set was never used for training. In the reported experiments, as described in Appendix B, 10% of the training pairs are held out, and checkpoints are selected on this holdout. The test set is therefore not used for training.

To verify this further, we sampled the same number of fresh questions from each multi-hop dataset and evaluated the same model as paper on them. The fresh questions are completely disjoint from the original evaluation questions, except for Bamboogle: its official test set contains only 125 questions, so the same questions are re-evaluated.

QuestionsHotp2WKMuSBamMulti-hop Avg
Original questions38.443.211.044.831.94
Fresh held-out questions36.445.013.045.632.55

The overall results on the fresh questions are nearly identical to those in the main table, and the score on the re-evaluated Bamboogle questions is also comparable. Since the results on the fully independent questions are consistent with those reported in the original paper, we keep the main-table results unchanged so that our method is evaluated on the same test questions as the baselines

The headline results are produced with NFE=1. The failure analysis in Appendix D is based on the same NFE=1 run. The “NFE=2” label there is a labeling error on our part, a leftover from an outdated internal run identifier. We apologize for the confusion and will correct it in the revision. In our earlier internal experiments, we conducted a comparison between NFE=1 and NFE=2 in a separate run. NFE=2 was not used in our subsequent main experiments.

The sampled latent endpoints differ in all 274/274 tasks. After decoding, 209/274 (76%) of the generated skill texts are still identical, which suggests that small differences in the latent are largely absorbed by the decoder. Of the remaining 65 tasks whose skill texts differ, only 8 change outcome: 4 go from failure to success and 4 from success to failure, so they cancel out exactly.

We will correct this typo in the revision and use a consistent name throughout, instead of the outdated internal identifier.

AuthorsOpenReview ↗

Response to Reviewer 2Dob (W2, Q2): Necessity of Latent Flow

To sufficiently isolate the contribution of latent flow matching, we ran additional experiments with retrieval, reranking, and a simple latent-skill predictor on the clean skill bank (the same one used by our main method). All experimental settings are identical to those of the main method(the same training pairs, codec, executor, prompts, and execution budgets). The results are shown below.

MethodSeenUnseenTotalΔ
SkillFM(ours)115 (82.1%)113 (84.3%)228 (83.2%)—
Embedding top-1110 (78.6%)102 (76.1%)212 (77.4%)−5.84
Embedding top-5 + Qwen3-Reranker-4B110 (78.6%)107 (79.9%)217 (79.2%)−4.01
BM25 top-1112 (80.0%)105 (78.4%)217 (79.2%)−4.01
Task2Latent predictor101 (72.1%)103 (76.9%)204 (74.5%)−8.76

Even without noise, retrieval still underperforms our main method, which demonstrates the advantage of our generative approach; this advantage becomes even more pronounced when the skill bank contains noisy or out-of-domain skills (Table 10). We also trained a model that directly regresses the latent skill from the condition, as an additional ablation that highlights the importance of latent flow matching. Together with the Decoder-only SFT results, these experiments demonstrate the necessity of the full system.

AuthorsOpenReview ↗

Response to Reviewer 2Dob (W2): Baseline settings

We would like to add that our ALFWorld protocol strictly follows that of LatentSkill and related work: the same executor (Qwen3-8B in thinking mode, frozen), nearly identical prompts (the only difference being that our skills are injected via the prompt, whereas their methods use LoRA), the same interaction budget (ALFWorld's default maximum of 50 steps), and a shared evaluation pipeline. Moreover, our vanilla baseline results closely match their published numbers. When we reproduced the key baselines in our own environment, they fell short of the results reported in the original papers; to keep the comparison conservative, we therefore report their (higher) published numbers. The results are as follows:

MethodSourceSeenUnseenTotal
VanillaReported in LatentSkill43.6%47.0%45.3%
VanillaOur environment43.6%50.0%46.7%
LatentSkillReported in LatentSkill74.3%69.4%71.9%
LatentSkillOur reproduction68.6%67.2%67.9%

On WebShop, we use the same experimental settings as the baselines, including the same Qwen2.5-7B-Instruct executor and the same interaction budget. The results are as follows:

MethodSR (%) ↑Score ↑
Mem02.0023.90
ExpeL11.2030.90
MemP6.4025.30
SimpleMem8.5933.20
MemRL9.2029.50
EvolveR17.6042.50
Ours18.6038.14

We additionally include several methods built on Qwen3-8B for comparison, under a strictly identical evaluation protocol. The results are as follows:

MethodSR (%)Score
AWM–30.7
No Memory9.833.3
Memento-Skills–34.3
ReasoningBank11.435.4
MemP12.035.7
SkillOS-gemini13.238.1
SkillOS-base13.638.6
SkillOS16.540.6
EASE–42.8
SkillFM (Ours)20.055.4

Comments on the paper

3 comments
AuthorsOpenReview ↗

General Response: Summary of Clarifications, New Experiments, and Revisions

We sincerely thank all reviewers for their valuable suggestions on our paper. We have released the model weights anonymously on Hugging Face. https://huggingface.co/SkillFM/SkillFM

Necessity of Latent Flow Matching

Several reviewers noted that the evidence for the necessity of latent flow matching may be insufficient. To address this, we ran two additional experiments.

First, we replaced the SkillFM with retrieval under exactly the same conditions (same skill bank, executor, prompts, and budgets).

Second, we trained a simple task-to-latent model on the same training data with the same DiT, but without path interpolation: it regresses the latent skill directly from the task condition. The results are shown below(ALFWorld success rate, clean skill bank).

MethodSeenUnseenTotalΔ
SkillFM(ours)115 (82.1%)113 (84.3%)228 (83.2%)—
Embedding top-1110 (78.6%)102 (76.1%)212 (77.4%)−5.84
Embedding top-5 + Qwen3-Reranker-4B110 (78.6%)107 (79.9%)217 (79.2%)−4.01
BM25 top-1112 (80.0%)105 (78.4%)217 (79.2%)−4.01
Task2Latent predictor101 (72.1%)103 (76.9%)204 (74.5%)−8.76

These experiments justify our choice of latent flow matching. More importantly, with a noisy skill bank, our method outperforms retrieval by a large margin (Table 10). This setting better reflects real-world use, where a perfectly clean skill bank cannot be guaranteed. The comparison with direct regression further isolates the contribution of latent flow matching. Together, these results show that our method addresses the problems raised in the Introduction: ambiguous retrieval and imperfect, growing skill banks.

Additional Baselines and Clarifications on Evaluation Protocols

For ALFWorld, the baselines we compare against share our evaluation protocol and execution budget: the same frozen Qwen3-8B executor, ALFWorld’s default maximum number of interaction steps, the same prompt template, the same information available to the agent, and the same test set. The comparison is therefore reliable. When we reproduced key baselines, our results were slightly lower than those reported in the original paper; to keep the comparison conservative, we report the (higher) published numbers in paper. For WebShop, we additionally report baselines with the same Qwen3-8B executor, as well as our method with Qwen2.5-7B as the executor(see our responses to Reviewers 2Dob and 6nqa or the revised paper .

Robustness under Noisy Skill Banks

To further demonstrate our core advantage over retrieval on noisy skill banks, we compare against stronger retrieval variants. The results are shown below.

Domain (metric)Dense top-1Dense top-5 + rerankerOurs
ALFWorld (SR)34.6734.3175.91
WebShop (SR)15.2017.2018.40
Single-hop QA (EM,)42.2040.7345.73
Multi-hop QA (EM)27.4529.4231.82
ALFWorld retrieverSeen SR (%)Unseen SR (%)Overall SR (%)
0.6B encoder, top-138.630.634.7
0.6B encoder, top-5 + reranker36.432.134.3
4B encoder, top-145.739.642.7
4B encoder, top-5 + reranker47.939.643.8
Ours74.377.675.9

Clarifications of Unclear Statements in the Paper

We have revised the paper according to the reviewers’ comments and highlight all changes in a different color. The additional experiments will also be added to the paper, while the data of all existing experiments will remain unchanged. We will also improve the descriptions of the experimental settings and the method to reduce potential misunderstandings and make the paper more complete.

In Section 5.1, we added a paragraph on the necessity of latent flow, together with Table 7. It compares SkillFM with clean-bank retrieval (Cosine Retrieval, Rerank Retrieval, and BM25) and with a deterministic task-to-latent predictor (Latent Predictor), using the same training pairs, codec, executor, prompts, and execution budgets as the main method. The new Appendix G describes these baselines and analyzes their results. In Section 5.4, we added a main-text discussion that compares our two-stage codec-plus-flow design with jointly learned latent language generators and explains why we adopt the two-stage design.

In Table 3 (Section 4.2), we added WebShop results with a Qwen3-8B executor, comparing SkillFM with methods built on the same executor. Finally, the new Appendix H specifies the retrieval settings for the noisy-bank comparison in Section 6.1 (Table 10) and reports results with a larger Qwen3-Embedding-4B encoder (Table 21). In Section 3.2, we added a pointer to the new Appendix I, which reports decoding robustness under latent perturbations at inference time (Table 22 and Figure 9).

Dear Reviewers, The authors have now submitted their responses to the reviews. There is only a limited amount of time left for you to review their replies and provide any further comments.

Your feedback is crucial to ensure that the review process proceeds smoothly. We would greatly appreciate it if you could share your reactions before the discussion period closes if you have not done so.

Thank you very much for your work. Best regards.

AuthorsOpenReview ↗

Summary of Reviewer-Author Discussions and Key Updates

Dear PCs, SACs, ACs, and Reviewers,

We sincerely thank all reviewers for their time and constructive feedback, which has substantially improved our paper.

Our contributions. SkillFM generates task-conditioned textual skills instead of retrieving them at test time. On ALFWorld and Search-QA, it achieves the best overall performance among the compared vector-based skill approaches. A reconstructable codec maps skills into a continuous latent space, and a conditional flow model trained with improved MeanFlow generates a skill latent in a single step, which is decoded into readable guidance for a frozen executor. This removes test-time retrieval, remains robust to noisy skill banks, and transfers across executor families without changing their parameters.

The reviewers’ questions mostly asked for additional experiments and clarifications that further support our conclusions. We addressed each of them, and the reviewers confirmed that their main concerns were resolved.

Main Concerns and How We Addressed Them

  1. Contribution of flow matching. We added retrieval baselines and a direct task-to-latent mapping baseline under the same settings (Section 5.1, Appendix G). SkillFM outperforms both, while direct mapping falls below retrieval. The gains therefore do not come from task-to-skill representation learning alone: flow matching is what makes this formulation effective.
  2. Baseline settings. We clarified that SkillFM uses the same executor and interaction budget as the main baselines, now listed in Appendix B.1. We also added WebShop comparisons under two executors, each shared with the corresponding baselines (Section 4.2, Appendix C.1).
  3. Clarity and evaluation. We clarified that Search-QA checkpoints are selected on a held-out split of the training data. We also evaluated SkillFM and key baselines on fresh held-out questions, where SkillFM still outperforms all baselines. Unclear wording in the paper has been corrected.
  4. Stronger retrieval under noisy skill banks. With 25% irrelevant skills injected into the bank, we compared SkillFM with stronger retrieval systems that use different embedding models and add a reranker (Section 6.1, Appendix H). SkillFM still outperforms every retrieval variant, further confirming the advantage of generation over retrieval.

Summary. We have addressed the reviewers’ concerns, and all three reviewers now give positive ratings. We have revised the paper and added the necessary experiments. By replacing test-time retrieval with latent flow matching, SkillFM avoids ambiguous retrieval, stays robust when the skill bank is noisy, and produces readable skills that transfer across frozen executors.

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.