The Pulse
QwenGyre Cuts a 48-Step Agent Training Run to 75 Hours
Alibaba researchers introduce QwenGyre, a reinforcement-learning framework that shifts computing capacity between agent rollouts and training. On NL2RepoBench, the team reports a 75.42-hour run and a pass-rate increase from 52.48% to 58.54%
AI.info Team · Written with AI ·
QwenGyre’s efficiency gains come with a warning in the same paper: on the team’s largest test, most recorded queries ran for at least four hours, and more than a third of those ended in an overall timeout. The framework, described in a paper posted to arXiv on September 27, shifts computing capacity between agent responses and model training as workloads change. Its authors report faster training than two common scheduling approaches, but the results come from resource-intensive experiments and a task where long delays remain a defining problem.
Moving capacity as rollouts finish
Online reinforcement learning alternates between generating agent attempts, known as rollouts, and using their results to update a model. In long coding tasks, those attempts can take hours and vary widely in duration. A shared pool that waits for every attempt to finish can leave computing resources idle; a fixed split between rollout and training can strand capacity on one side while the other waits.
QwenGyre’s scheduler moves computing nodes between the two roles without interrupting active agent runs. As rollout demand falls, available nodes can join training already under way. The paper also describes a trajectory processor that reconstructs branching histories, scores partial work after some timeouts and limits how many paths from each execution become training examples.
“QwenGyre elastically reallocates GPUs between rollout and training without interrupting live executions,” write the authors of “QwenGyre: An Elastic Reinforcement Learning Framework for Training xLong-Horizon Agents”.
The 75-hour result—and the comparison behind it
For Qwen 3.8 2.4T on NL2RepoBench, the researchers report that QwenGyre completed 48 training steps in 75.42 hours. Async, which uses separate fixed pools for rollout and training, took 134.55 hours; Colocate, which switches a shared pool between the two jobs, took 91.47 hours. QwenGyre therefore ran 1.78 times faster than Async and 1.21 times faster than Colocate in that experiment.
Over the same 48 steps, the model’s reported NL2RepoBench evaluation pass rate rose from 52.48% to 58.54%. The comparison used four cells of 48 nodes each for the 2.4T model, or 192 nodes in total. That result is distinct from the paper’s maximum speedups across its broader evaluations: up to 1.78 times over Async and 1.85 times over Colocate.
Branching paths add another training cost
Long agent runs do not always produce a single sequence of actions. The harnesses used in the experiments can compact conversation histories, delegate work to sub-agents and retry failed paths, leaving shared prefixes and branches that would be redundant if each path were treated as a separate training sample.
QwenGyre records model calls in a tree, keeps each output’s original context and counts shared targets once. Its default limit is five training trajectories per rollout execution. The researchers evaluated the framework on NL2RepoBench, DeepSWE and TerminalBench; the 122-billion-parameter Qwen 3.6 experiments used 32 nodes for NL2RepoBench and 24 for the other two workloads.
Timeouts and deployment constraints remain
The strongest speedup on the 2.4T model came against Async, not Colocate. The authors link the smaller Colocate gain to the long-tail duration of the queries: when many runs approach the timeout limit, there are fewer opportunities for the scheduler to reclaim nodes early and grow the training pool. Among queries with complete duration records, 61.1% took at least four hours; in 38.2% of those, the longest rollout ended in an overall timeout.
The paper also identifies practical constraints. Elastic scheduling requires multiple independently switchable groups of nodes, each large enough to support the model and training setup, which the authors say can make the approach impractical on small budgets. Streaming training across multiple steps in a burst also prevents a global shuffle across all minibatches before the first update; the paper says the effect of that ordering on learning quality has not been isolated.
For now, QwenGyre’s clearest evidence is a 75.42-hour, 48-step NL2RepoBench run on 192 nodes, alongside a pass-rate increase to 58.54%. The paper’s largest-model experiment still records four-hour-plus queries as the norm, and overall timeouts among a substantial share of them.