An open source project on GitHub trained an AI agent (based on Qwen3.6-35B with LoRA) to write complete training configurations for smaller models, using reinforcement learning in both loops. The agent receives a task description (“teach a model to solve multi-hop queries about characters”), writes the environment, reward function, dataset and hyperparameters, and launches the job on Runpod GPU. The agent’s reward depends on how well the trained model performs on a held-out evaluation.

The total cost of training the agent was around $1300. The project opened everything up: the agent weights (LoRA adapter on Hugging Face), GPU orchestration code, task families, reward code, and detailed reports from every attempt, including failures. The agent went from reward ~0.0 to a peak of ~0.63 in 54 steps, and showed transfer capabilities on tasks never seen during training.

Why it matters to you: until a few months ago, this kind of meta-learning was the territory of research labs. Now the cost is within reach for anyone who wants to experiment seriously, and the infrastructure for agents that train models is democratizing. The project demonstrates that you can build a complete agentic training loop with accessible resources, and that transparency about the process (failures included) makes a difference for those learning.

In detail

How it works

Two separate RL loops, two different training stacks. In the outer loop, the trainer agent (Qwen3.6-35B with LoRA) is trained with Tinker and the importance-sampling GRPO cookbook. An episode consists of receiving a task specification, working on a workspace via file editing tools, and submitting a complete job. The episode reward is the trained model’s score on a held-out evaluation.

In the inner loop, the small model (Qwen3-0.6B or 1.7B) is trained on the task with prime-rl (GRPO) on Runpod GPU, using the configuration written by the agent: verification environment, evaluation rubric and TOML config.

What it learned

Reward climbed in two distinct steps. The agent learned to choose the best base model for the task and showed transfer capabilities across a family of tasks kept completely out of training. Not every run went well: the repo includes retrospectives of failed attempts, a rare level of transparency.

The infrastructure

GPU orchestration manages Runpod machine allocation, job submission and result retrieval. The inner training scripts (prime-rl) and evaluation materials are all in the repo. The project also includes an analysis system to understand what the agent learned to do well and where it still fails.

Costs and reproducibility

Around $1300 for the entire agent training. Everything needed to replicate the experiment is public: code, config, trained agent weights (on Hugging Face), and even the author’s personal notes on failed pilots. A strong signal that training agent infrastructure is shifting from research labs to a space accessible to those with a modest budget and desire to experiment.

Implications

Meta-learning with RL at accessible costs shows that the “AI trains AI” cycle is no longer exclusive territory of big labs. The project’s transparency (documented failures, honest retrospectives) offers an example of how to share complex experiments so others can truly learn, not just replicate success.