SoftwareGym: Scaling Computer-Use Agent Training with Diverse Synthesized Software Environments
Tian Jin, Wenhao Wang, Jing Kang, Haoting Shi, Rui Ye, Yijun Lu, Siheng Chen
Shanghai Jiaotong University · Zhejiang University
Published October 8, 2026 · on the feed October 12, 2026 · ▲ 107 · arXiv 2610.12611
The abstract
Computer-use agents (CUAs) are rapidly improving, yet synthesizing diverse and reliable software environments at scale remains challenging. Native application environments require substantial construction and integration effort, which limits application coverage and increases the risk of application-specific overfitting. Browser-hosted environments provide limited interaction depth and workflow complexity. These limitations motivate SoftwareGym, an automated pipeline for synthesizing GUI software environments with diverse interfaces, executable functionality, and runtime-verified behavior. It generates structurally diverse designs, realizes them as runnable applications, and uses GUI evaluation with iterative repair to ensure functional reliability. Using SoftwareGym, we synthesize 182 applications across twelve categories and achieve a mean GUI task pass rate of 91.5%. We construct SoftwareGym-Bench, a 120-task evaluation suite spanning the same twelve categories, and use trajectories collected from these environments for CUA training. The resulting model improves Pass@3 from 41.39% to 56.97% on the strictly out-of-domain OSWorld benchmark and achieves 40.0% on SoftwareGym-Bench. These results demonstrate the potential of synthesized software environments as scalable and transferable supervision for CUA training.
The Brief
2:13A short podcast summary of the paper. Written and voiced by AI.
Transcript
SoftwareGym. Scaling Computer-Use Agent Training with Diverse Synthesized Software Environments. By Tian Jin and six others, from Shanghai Jiao Tong University and Zhejiang University. Published on the eighth of October. Its code repository is worked out: about forty source files, with a readme.
Computer-use agents are getting better quickly, but training them needs software to practise in, and producing that software in quantity, with variety and reliability, is still hard. The two usual sources each fall short. Native application environments take substantial effort to construct and integrate, which keeps the number of applications small and raises the risk that an agent overfits to the particular ones it saw. Browser-hosted environments are easier to come by, but they offer limited interaction depth and only modest workflow complexity.
SoftwareGym answers with automation. It is a pipeline that synthesizes GUI software environments: applications with diverse interfaces, functionality that actually executes, and behaviour that is verified at runtime. Instead of building each environment by hand, the environments themselves become something generated at scale.
The pipeline runs in three movements. It first generates designs that differ in structure. It then realizes those designs as runnable applications. Finally it evaluates each application through its GUI and repairs it iteratively, so that what comes out is functionally reliable rather than merely plausible on the screen. Trajectories collected inside these environments then become training data for a computer-use agent.
With the pipeline, the authors synthesize one hundred eighty-two applications across twelve categories, and the mean GUI task pass rate is ninety-one point five percent. They also build SoftwareGym-Bench, an evaluation suite of one hundred twenty tasks spanning the same twelve categories.
The trained model is then tested on OSWorld, which is strictly out of domain. Its pass at three rises from forty-one point three nine percent to fifty-six point nine seven percent. On SoftwareGym-Bench it reaches forty percent.
The gain on OSWorld is the telling result, because none of those tasks came from the synthesized applications. Generated software, built and repaired until it works, is offered as supervision that scales and that transfers beyond the environments it was made in.
Paper Quest · 7 chapters · about 40 min
Play this paper
Learn it by doing: make the calls the authors made, guess the result before you see it, and defend it in a viva graded on your own words. Chapter 1 is right here.
Chapter 1 🧩 · The problem
Agents need software to practise in. Building it by hand does not scale.
You train agents that operate desktop applications by clicking and typing. They need many different programs to practise in, and those programs must actually work.
The road ahead
- 1 · The problem ~6 min Agents that use computers need many different, working programs to practise in, and neither real native apps nor browser pages supply that well.
- 2 · What came before ~3 min
- 3 · The key idea ~9 min Generate the training software itself: diverse designs, built into runnable apps, tested and repaired through their interfaces, then used to collect agent trajectories.
- 4 · Choose your own research ~3 min
- 5 · Build the method ~8 min The pipeline designs varied apps, builds them, tests and repairs them through the GUI, then collects trajectories in them to train the agent.
- 6 · The experiment ~6 min You’ll guess: After training on trajectories from SoftwareGym's applications, what did the model's Pass@3 on the out-of-domain OSWorld benchmark rise to, from 41.39%?
- 7 · The viva ~5 min Three questions from the examiners, answered in your own words. Win it for the paper’s trophy.
Free, with Google or an email address. Your stars and progress are kept.