Skip to page content
SAVRN
Search Plan a project

Open-weight model · Text generation

SkillForge_Alfworld_7B

by YuyaoGe YuyaoGe/SkillForge_Alfworld_7B

SkillForge_Alfworld_7B is an open-weight model for text generation from YuyaoGe, released under MIT License. It has 7.6B parameters and a 32,768-token context. At 16-bit it needs about 18.3 GB of GPU memory, which fits on 1x MI300X from $1.85 an hour, at the lowest prices in the SAVRN Index.

This is the final SkillForge policy for ALFWorld: a full fine-tune of Qwen2.5-7B-Instruct trained with GRPO while its skill library was simultaneously forged — retired, stabilized, demoted and mutated — under the fitness-driven lifecycle described in the…

Parameters7.6B
Context32,768
Weights15.2 GB
Licensemit
AccessOpen weights
Monthly Downloads—

Runs On

What it takes to serve SkillForge_Alfworld_7B (7.6B parameters): the memory its weights need at each precision, and the cheapest way to rent enough data-center GPUs to hold them.

PrecisionWeightsMemory neededCheapest setupPer hourAlso fits
16-bit 15.2 GB 18.3 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00
8-bit 7.6 GB 9.1 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00
4-bit 3.8 GB 4.6 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00

Memory is the weights at that precision plus 20% for the runtime and a short context; a long context needs more. Prices are the lowest on-demand hourly rates in the SAVRN Index, read Oct 22, 2026.

SkillForge_Alfworld_7B on every accelerator the SAVRN Index prices, at every precision

Model Card

By YuyaoGe, published under mit, revision 4b4c5356fc5b.

This is the final SkillForge policy for ALFWorld: a full fine-tune of Qwen2.5-7B-Instruct trained with GRPO while its skill library was simultaneously forged — retired, stabilized, demoted and mutated — under the fitness-driven lifecycle described in the paper. Most memory-augmented agents keep the library append-only. A skill that was correct at step 20 encodes a procedure the policy has outgrown by step 120, and it is still being retrieved into the context. SkillForge instead scores each skill against the policy's own rollouts and moves it between four states — trial, active, stable, retired — so the library and the model co-evolve. On ALFWorld this reaches 92.4% overall success against…

Read YuyaoGe's full model card

SkillForge: Co-Evolving Skills and Agents via Dynamic Skill Lifecycles


Introduction

This is the final SkillForge policy for ALFWorld: a full fine-tune of Qwen2.5-7B-Instruct trained with GRPO while its skill library was simultaneously forged — retired, stabilized, demoted and mutated — under the fitness-driven lifecycle described in the paper.

Most memory-augmented agents keep the library append-only. A skill that was correct at step 20 encodes a procedure the policy has outgrown by step 120, and it is still being retrieved into the context. SkillForge instead scores each skill against the policy's own rollouts and moves it between four states — trial, active, stable, retired — so the library and the model co-evolve.

On ALFWorld this reaches 92.4% overall success against 89.9% for SkillRL, the strongest memory-augmented RL baseline, and 14.8% for the untuned base model.

What is in this repository. The policy weights and tokenizer only. The evolved skill library is not shipped here: the agent is the policy plus the retrieved skills injected into its context. Skill contents, fitness trajectories and retirement events are documented in SkillFurnace (Appendix C of the paper) and in the paper's case studies.

Results

ALFWorld, per task type and overall (%).

Method Pick Look Clean Heat Cool Pick2 All
Vanilla (base model) 33.4 21.6 19.3 6.9 2.8 3.2 14.8
ReAct 48.5 35.4 34.3 13.2 18.2 17.6 31.2
Reflexion 62.0 41.6 44.9 30.9 36.3 23.8 42.7
GRPO (no library) 90.8 66.1 89.3 74.7 72.5 64.7 77.6
SkillRL 97.9 71.4 90.0 90.0 95.5 87.5 89.9
SkillForge 98.2 86.6 89.8 93.7 95.6 88.4 92.4

The gain over SkillRL is largest where the task is loosest: +15.2 on Look, +3.7 on Heat, +0.9 on Pick2. Those are the task types where a stale instruction hurts most, which is the failure mode the lifecycle exists to remove.

The library this model ended up with

Seed library Final library
Total skills 44 100
General 12 —
Task-specific 21 —
Common-mistake 11 —

The run saturates its skill cap (S_max = 100). For scale, the w/o retirement ablation — the same method with retirement switched off — grows to 132 skills and drops to 91.4%: a bigger library is not a better one.

How it was trained

  1. Pre-retirement. The seed library, inherited from the SkillRL release, is scored under 500 rollout episodes of the base model with skills injected. Anything whose proto-fitness falls below delta_pre = 0.3 is retired before training starts.
  2. Retirement-aware cold start. The base model is fine-tuned with cross-entropy on the rollouts that survived, with trajectories that leaned on a since-retired skill filtered out.
  3. Skill-policy co-evolution. GRPO takes over and, every 10 steps, the forging cycle reads each skill's runtime fitness and promotes, demotes, retires or mutates it. Mutation is LLM-guided (Kimi-K2.5 as teacher); at most 5 mutations and 3 retirements per cycle; retrieval is top-6 by task-type match.
Hyperparameter Value
Base model Qwen2.5-7B-Instruct
Optimizer GRPO, via verl
Learning rate 1e-6
Batch size / group size 16 / 8
Clip epsilon / KL beta 0.2 / 0.001
Training steps 200
Sampling temperature (train and eval) 1.0
Hardware 64 x NVIDIA H200

Quick Start

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "YuyaoGe/SkillForge_Alfworld_7B"
tok = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, dtype="bfloat16", device_map="auto")

# Skills are retrieved (top-6, by task-type match) and injected into the context.
# The exact prompt template and the action space are in the paper.
messages = [
    {"role": "system", "content": "<retrieved skills for this task type>"},
    {"role": "user", "content": "<observation>\n\n> "},
]
ids = tok.apply_chat_template(messages, add_generation_prompt=True,
                              return_tensors="pt").to(model.device)
out = model.generate(ids, max_new_tokens=256, do_sample=False)
print(tok.decode(out[0][ids.shape[-1]:], skip_special_tokens=True))

This is a research artifact: a 7B text policy for a text environment. It exposes no tool interface of its own and will emit ALFWorld-style actions for anything that resembles an ALFWorld prompt.

Citation

@misc{ge2026skillforgecoevolvingskillsagents,
      title={SkillForge: Co-Evolving Skills and Agents via Dynamic Skill Lifecycles},
      author={Yuyao Ge and Yiwei Wang and Yuchen He and Baolong Bi and Lingrui Mei and Jiayu Yao and Lizhe Chen and Shenghua Liu},
      year={2026},
      eprint={2610.09832},
      archivePrefix={arXiv},
      primaryClass={cs.AI},
      url={https://arxiv.org/abs/2610.09832},
}

Acknowledgments

Training runs on verl for the GRPO loop, with seed skill libraries inherited from the SkillRL release.

Configuration

Architecture
Qwen2ForCausalLM
Context length (tokens)
32,768
Layers
28
Hidden size
3,584
Feed-forward size
18,944
Attention heads
28
Key/value heads
4
Vocabulary size
152,064
RoPE base
1e+06
Stored precision
float32
Model type
qwen2

Identity and Version

Repository
YuyaoGe/SkillForge_Alfworld_7B
Publisher
YuyaoGe
Task
Text generation
Modality
Text
Library
transformers
Parameters
7.6B parameters
Languages
llm-agent
Revision
4b4c5356fc5b2a6145e6772f7c6d46cbf467eb95
First published
2026-04-23
Last updated
2026-10-08

Files and Weights

16 files, 15.2 GB in total. The weights are 4 files totalling 15.2 GB in safetensors.

Weights4 files · 15.2 GB
Configuration5 files · 30.6 KB
Tokenizer4 files · 15.9 MB
Documentation1 file · 6.2 KB
Other1 file · 1.6 MB
Repository1 file · 1.6 KB
Every file
FileTypeSizeSHA-256
model-00001-of-00004.safetensorsWeights5.0 GB 32494cfbdd07
model-00002-of-00004.safetensorsWeights4.9 GB d20573f83fe9
model-00003-of-00004.safetensorsWeights5.0 GB 5d270b2cf0b5
model-00004-of-00004.safetensorsWeights330.3 MB 602e8afc6565
added_tokens.jsonConfiguration605 B —
config.jsonConfiguration1.4 KB —
generation_config.jsonConfiguration243 B —
model.safetensors.index.jsonConfiguration27.8 KB —
special_tokens_map.jsonConfiguration613 B —
README.mdDocumentation6.2 KB —
assets/overview.pngOther1.6 MB d9791217df4b
.gitattributesRepository1.6 KB —
merges.txtTokenizer1.7 MB —
tokenizer.jsonTokenizer11.4 MB 9c5ae00e602b
tokenizer_config.jsonTokenizer7.4 KB —
vocab.jsonTokenizer2.8 MB —

License and Download

License
mit
Access
Open weights, no gate
Download size
15.2 GB
Download from YuyaoGe

Released by YuyaoGe through its official repository on Hugging Face. Read the license.

Built From

Memory Requirements

PrecisionWeights in memory
As published15.2 GB
16-bit15.2 GB
8-bit7.6 GB
4-bit3.8 GB

Weights only, from the published parameter count; the key-value cache and runtime add to this.

Questions About SkillForge_Alfworld_7B

How much GPU memory does SkillForge_Alfworld_7B need?

About 18.3 GB at 16-bit and 4.6 GB at 4-bit: the weights (7.6B parameters) plus a working margin. A long context needs more.

What is the cheapest GPU to run SkillForge_Alfworld_7B on?

At 16-bit, 1x MI300X from $1.85 an hour; at 4-bit, 1x MI300X from $1.85 an hour, at the lowest on-demand prices the SAVRN Index lists.

Can I use SkillForge_Alfworld_7B commercially?

Yes. SkillForge_Alfworld_7B is released under MIT License. The MIT License is a short permissive license. It permits commercial use, modification and redistribution, provided the copyright notice and permission notice are included.

What is SkillForge_Alfworld_7B's context length?

32,768 tokens, from the maximum position embeddings in its published configuration.

Similar Models

Model · Text generation

Qwen2.5-7B-Instruct

Qwen

Qwen2.5 is the latest series of Qwen large language models. For Qwen2.5, we release a number of base language models and instruction-tuned language models ranging from 0.5 to 72 billion parameters. Qwen2.5 brings the following improvements upon Qwen2: - Significantly more knowledge and has greatly improved capabilities in coding and mathematics, thanks to our specialized expert models in these domains. - Significant improvements in instruction following, generating long texts (over 8K tokens), understanding structured data (e.g, tables), and generating structured outputs especially JSON. More resilient to the diversity of system prompts, enhancing role-play implementation and…

Open weights apache-2.0 7.6B parameters 32,768 tokens transformers

Model · Text generation

Qwen2.5-7B-Instruct-AWQ

Qwen

Qwen2.5 is the latest series of Qwen large language models. For Qwen2.5, we release a number of base language models and instruction-tuned language models ranging from 0.5 to 72 billion parameters. Qwen2.5 brings the following improvements upon Qwen2: - Significantly more knowledge and has greatly improved capabilities in coding and mathematics, thanks to our specialized expert models in these domains. - Significant improvements in instruction following, generating long texts (over 8K tokens), understanding structured data (e.g, tables), and generating structured outputs especially JSON. More resilient to the diversity of system prompts, enhancing role-play implementation and…

Open weights apache-2.0 7.6B parameters 32,768 tokens transformers

Model · Text generation

Qwen2.5-Coder-7B-Instruct

Qwen

Qwen2.5-Coder is the latest series of Code-Specific Qwen large language models (formerly known as CodeQwen). As of now, Qwen2.5-Coder has covered six mainstream model sizes, 0.5, 1.5, 3, 7, 14, 32 billion parameters, to meet the needs of different developers. Qwen2.5-Coder brings the following improvements upon CodeQwen1.5: - Significantly improvements in code generation, code reasoning and code fixing. Base on the strong Qwen2.5, we scale up the training tokens into 5.5 trillion including source code, text-code grounding, Synthetic data, etc. Qwen2.5-Coder-32B has become the current state-of-the-art open-source codeLLM, with its coding abilities matching those of GPT-4o. - A more…

Open weights apache-2.0 7.6B parameters 32,768 tokens transformers

Model · Text generation

Qwen2.5-Coder-7B-Instruct-AWQ

Qwen

Qwen2.5-Coder is the latest series of Code-Specific Qwen large language models (formerly known as CodeQwen). As of now, Qwen2.5-Coder has covered six mainstream model sizes, 0.5, 1.5, 3, 7, 14, 32 billion parameters, to meet the needs of different developers. Qwen2.5-Coder brings the following improvements upon CodeQwen1.5: - Significantly improvements in code generation, code reasoning and code fixing. Base on the strong Qwen2.5, we scale up the training tokens into 5.5 trillion including source code, text-code grounding, Synthetic data, etc. Qwen2.5-Coder-32B has become the current state-of-the-art open-source codeLLM, with its coding abilities matching those of GPT-4o. - A more…

Open weights apache-2.0 7.6B parameters 32,768 tokens transformers

Model · Text generation

Qwen2.5-Coder-7B

Qwen

Qwen2.5-Coder is the latest series of Code-Specific Qwen large language models (formerly known as CodeQwen). As of now, Qwen2.5-Coder has covered six mainstream model sizes, 0.5, 1.5, 3, 7, 14, 32 billion parameters, to meet the needs of different developers. Qwen2.5-Coder brings the following improvements upon CodeQwen1.5: - Significantly improvements in code generation, code reasoning and code fixing. Base on the strong Qwen2.5, we scale up the training tokens into 5.5 trillion including source code, text-code grounding, Synthetic data, etc. Qwen2.5-Coder-32B has become the current state-of-the-art open-source codeLLM, with its coding abilities matching those of GPT-4o. - A more…

Open weights apache-2.0 7.6B parameters 32,768 tokens transformers

Model · Text generation

Qwen2.5-7B

Qwen

Qwen2.5 is the latest series of Qwen large language models. For Qwen2.5, we release a number of base language models and instruction-tuned language models ranging from 0.5 to 72 billion parameters. Qwen2.5 brings the following improvements upon Qwen2: - Significantly more knowledge and has greatly improved capabilities in coding and mathematics, thanks to our specialized expert models in these domains. - Significant improvements in instruction following, generating long texts (over 8K tokens), understanding structured data (e.g, tables), and generating structured outputs especially JSON. More resilient to the diversity of system prompts, enhancing role-play implementation and…

Open weights apache-2.0 7.6B parameters 131,072 tokens transformers