Tong Zheng, Xidong Wu, Zheng Zhang, Zhankui He, Chaoyi Zhang, Benjamin Coleman, Ruoqiao Wei, Di Bai, Haolin Liu, Rui Liu, Xue Wang, Yue Zhuan, Wang-Cheng Kang, Renkai Xiang, Heng Huang, Xinwu Cheng, Yunsong Guo
4 min
Autonomous AI agents for scientific discovery often struggle with the meta-level problem of exploration: how to efficiently allocate computational resources across vast search spaces. Existing approaches typically rely on fixed exploration strategies or expensive online policy optimization, which suffers from delayed feedback and high costs. Dream-RSI addresses this by asking: can we turn past discovery history into a reusable simulator to optimize exploration policies offline?
Dream-RSI introduces a recursive self-improvement loop consisting of three stages:
This framework uses a lightweight orchestration layer to make exploration explicit and programmable, enabling the agent to adjust branching, parallelization, and stopping criteria without modifying the underlying coding agent.
Dream-RSI demonstrates significant improvements in both discovery quality and computational efficiency across three domains: algorithm engineering (Lasso path solver), mathematical optimization, and GPU kernel engineering. In Lasso path discovery, it achieved superior downstream performance while reducing discovery-agent calls by up to 162x compared to baseline methods. In GPU kernel engineering, it reached target performance levels with up to 2.43x fewer generations. The results suggest that treating history as a replay simulator provides a powerful inductive bias that outperforms simple semantic guidance, as it allows the agent to learn from the actual structure of the search space rather than just abstract insights.
By transforming discovery history from static data into an active, replayable environment, Dream-RSI effectively solves the bottleneck of delayed feedback in meta-exploration. This enables autonomous systems to scale their discovery capabilities recursively, making long-horizon exploration feasible and cost-effective for complex scientific and engineering tasks.
Recursive self-improvement is becoming increasingly vital for autonomous AI agents, where progress hinges on discovering high-value solutions across complex domains. The driver of this process is effective exploration, however, managing and improving exploration strategies remains a major bottleneck. Current systems face a fundamental dilemma: fixed strategies fail to adapt as search spaces scale, while online policy optimization requires navigating vast meta-search spaces under delayed and expensive feedback over long-horizon rollouts. We introduce \textsc{Dream-RSI}, a framework for scalable and recursively self-improving exploration. A lightweight orchestration layer makes exploration explicit and programmable while leaving the underlying coding agent unchanged. Our key insight is that accumulated discovery history can serve as a replay simulator over the realized search space. By performing dreaming in the replay simulator constructed from historical discovery trees, \textsc{Dream-RSI} secures immediate, low-cost off-policy feedback to evaluate and refine exploration policies without invoking repetitive, expensive online evaluations. The improved policy is subsequently redeployed online to drive further discovery, continuously expanding the simulator pool in a self-improving loop. Across algorithm engineering, mathematical optimization, and GPU kernel engineering, \textsc{Dream-RSI} achieves competitive or improved discovery quality while substantially reducing discovery cost in several settings.
Sam: [steady, teaching mode] It's closer to planning. The policy development agent analyzes the replay data and tunes a parameter the authors call beta — effectively a patience knob. A high beta keeps the agent exploring branches that haven't paid off yet; a low beta triggers more aggressive pruning toward what's already working. Critically, this tuning happens entirely inside the dreaming phase — the agent sweeps different beta values against the frozen discovery tree, measures which setting gets the best performance for the least compute, and adopts that setting without ever running a new rollout.
Alex: [deliberate, checking understanding] That's a clean way to get the budget savings — you're optimizing the search strategy itself against free, already-collected data rather than paying for more trials. [[RP_SECTION:impact-of-semantic-hints|Impact of semantic hints]]
Sam: [grounded, precise] Exactly, and it explains one of the more counterintuitive results in the paper. The authors tried injecting semantic hints — explicit guidance nudging the agent toward a particular kind of solution — and it hurt performance. Forcing the search in a specific direction overrides the diversity the exploration policy depends on to work well. Letting the strategy emerge from the replay simulator, rather than steering it by hand, turned out to be the more productive approach. [[RP_SECTION:core-contribution-and-conclusion|Core contribution and conclusion]]
Alex: [reflective, slower] So the indexing of past attempts into a searchable tree is really the core contribution here — without that structure, the history is just a static log, but with it, it becomes something the agent can actually reason over.
Sam: [quiet confidence, nodding] That's the core insight of the paper. Making exploration programmable turns past failures into a map of the search space, rather than a discarded record of dead ends.
Alex: [reflective, wrapping up] If you want the figures and the method choices we skipped, you can generate a deep dive of this paper. The paper has the rest either way.
Sam: [warm, professional] Thanks for listening.