Google Researchers Introduce Dream-RSI, Reporting 162x Fewer Agent Calls

The research framework treats an agent’s prior search tree as a reusable simulator, shifting policy experiments away from costly candidate evaluations. Its strongest reported savings come from benchmark comparisons with different underlying setups.

By 3 min read
Google Researchers Introduce Dream-RSI, Reporting 162x Fewer Agent Calls
Google Researchers Introduce Dream-RSI, Reporting 162x Fewer Agent Calls

Listen to this story

The audio brief

About 1:30
0:001:30
Read transcript
Google researchers have introduced Dream-RSI, a framework that reportedly matched a Lasso path-discovery result with SimpleTES while using about 162 times fewer discovery-agent calls. The catch is important: that headline compares call counts, not identical runtime or model setups. Dream-RSI’s core idea is to make past agent searches reusable. An agent first builds a search tree, recording the decisions it made and the outcomes it got. Dream-RSI then replays that tree as a simulator, so researchers can test different exploration policies without repeatedly rerunning candidate code and its evaluator. The coding agent itself stays the same. What changes is a separate policy that decides when to branch, what to run in parallel, and when to stop. In tests, the framework reached comparable VGG16 GPU-kernel performance with 2.43 times fewer generations, and reported 2.09 times higher performance on ConvDiv under comparable budgets. More directly matched Gemini 3.7 Flash tests reduced average calls from 3,200 to 1,879, while runtime fell from roughly 2,517 milliseconds to 2,351. The researchers have also released code covering Lasso and GPU-kernel tasks including LayerNorm and ConvMax. The real question is whether policies improved inside these replayed histories keep their efficiency advantage when they return to live search, build new trees, and face other kinds of agent work.

Story brief

3 key points

Google researchers’ Dream-RSI uses recorded agent search traces as a replayable simulator for improving exploration policies, rather than repeatedly rerunning code and evaluation. In reported benchmarks, it matched SimpleTES on Lasso path discovery with 162x fewer discovery-agent calls, though that headline compares calls rather than identical runtime or model setups. Other results were smaller but practical: up to...

  1. 01

    Dream-RSI separates the task-solving coding agent from the policy that decides branching, parallelism, and stopping.

  2. 02

    The 162x Lasso comparison used SimpleTES, gpt-oss-120b, and 51,200 generations; it is not a like-for-like runtime comparison.

  3. 03

    With Gemini 3.7 Flash, calls fell from 3,200 to 1,879 and average runtime from 2,516.7 to 2,350.6 milliseconds.

A Google-led research team has introduced Dream-RSI, a framework that reuses an AI agent’s recorded search history to test better ways of exploring a problem. The researchers report that it matched a SimpleTES result on a Lasso path-discovery task with about 162 times fewer discovery-agent calls.

The central idea is to stop treating completed agent runs as disposable logs. Dream-RSI records decisions and outcomes in a historical discovery tree, then replays that tree as a simulator for alternative search strategies. Instead of rerunning candidate code and its evaluator for every proposed strategy, the system reads outcomes that already exist.

First, the agent builds a record of its search

Dream-RSI separates the task-solving agent from the policy that directs its exploration. The underlying coding agent stays the same; a separate policy decides when to branch, which attempts to run in parallel, and when to stop. The team describes the process as a way to improve orchestration rather than retrain the model doing the work.

Dream-RSI’s three-stage loop

  1. Online exploration creates a discovery tree and records the agent’s traces.
  2. A replay simulator stores that tree as a reusable environment for policy testing.
  3. Dreaming-based policy improvement tests alternatives against the saved outcomes before the strongest policy returns online.

The largest headline number is not a like-for-like runtime comparison

The 162x figure is a measure of discovery-agent calls against SimpleTES, not a direct comparison of identical model configurations. SimpleTES used gpt-oss-120b and 51,200 generations in that baseline. Other reported Lasso tests used Gemini 3.1 Pro or Gemini 3.7 Flash and showed smaller call reductions alongside shorter average runtimes.

With Gemini 3.7 Flash, Dream-RSI reduced average discovery-agent calls from 3,200 to 1,879 and average runtime from 2,516.7 to 2,350.6 milliseconds in the reported Lasso tests. With Gemini 3.1 Pro, calls fell from 550 to 317 across six datasets, while average runtime declined from 3,587.1 to 2,931.0 milliseconds.

The next move returns replayed lessons to live search

Dream-RSI is not intended to remain entirely inside its stored trees. After policy improvement, the selected policy goes back into online exploration, where it can build another discovery tree for later replay. The researchers also say the code is publicly available, making the framework available for others to inspect and run.

The reported results span Lasso discovery and GPU-kernel engineering benchmarks, including VGG16, LayerNorm, ConvDiv, and ConvMax. The practical question is whether replay-selected policies keep their efficiency advantage as they move through successive live discovery rounds and into other kinds of agent work.

Sources

  1. venturebeat.comGoogle's Dream-RSI cuts discovery-agent calls up to 162x by replaying searches it already ran

Loading discussion...

Google Researchers Introduce Dream-RSI, Reporting 162x Fewer Agent Calls | Superpower Daily