What Happens When RSI-Opt's Agents Improve How Models Train?
RSI-Opt points self-improving agents at model training itself. Here is the three-step trend behind it and the one thing that decides whether it works.
What happens when the agent tuning your model’s training run is allowed to improve itself? That is the question a new arXiv paper, RSI-Opt, puts on the table.
The title is the only part of the paper I can vouch for: “RSI-Opt: Recursive Self-Improvement Optimizer Agents For Model Training.” I did not have the abstract, so there are no benchmark numbers here and I won’t imply any.
The mechanism is still readable from the name. Agents propose changes to how a model is trained. Training runs score those changes. The agent then improves its own way of proposing the next ones. The loop is no longer around a prompt. It is around the training process.
That is a change in tempo, and it did not arrive in one jump.
October 2023. The Self-Taught Optimizer (STOP) paper has a language model rewrite the scaffolding program that calls it. The loop sits around code that wraps a model.
May 2025. Google DeepMind announces AlphaEvolve, a coding agent that evolves algorithms against automated evaluators. DeepMind also describes using it on parts of its own infrastructure.
October 2026. RSI-Opt appears under arXiv identifier 2610.32026. The self-improving agent now targets model training directly.
The through-line is that the loop keeps moving down the stack. First it improved the wrapper. Then it improved algorithms and infrastructure. Now it is aimed at the recipe that produces the weights. Each step sits closer to the thing that determines capability, and each step leaves less for a human to do between iterations.
Here is the practitioner read. The scarce asset in these loops is not the agent. It is the evaluation. An optimizer agent climbs whatever metric you hand it, including the flaws in that metric. If your eval can be gamed, a recursive loop will find the gap faster than you will.
So if you fine-tune or run training jobs, build the eval first and the agent second. Hold out data the agent never sees. Treat every agent-proposed change as untrusted until it passes a check the agent cannot touch. The same logic shows up in how guardrails lift a small model on agentic tasks: the constraints around the model do more work than most people assume. And if you are wiring agents into a wider build pipeline, the full agentic SDLC covers where those checkpoints belong.
My prediction: by December 2027, at least one frontier lab’s published technical report will credit agent-proposed changes with altering its own training recipe. If that happens, the story will not be the agent. It will be which evals the lab trusted enough to let the loop run unattended.
If you want the next one of these in your inbox, subscribe here.