Suppose we want a model to perform better on a benchmark. What can we change?

The training recipe, hyperparameters, data, rewards, tool use, or the harness itself. These interventions sit at different layers, but they share a structure: explore possible systems and keep the changes that improve the objective.

The model, the harness, and the data pipeline are all search variables. Researchers have traditionally proposed hypotheses, designed experiments, interpreted results, and chosen the next attempt. Agents can now take on more of that work.

From this perspective, the practical question behind self-improvement is how to scale the search.

More tokens need somewhere to go

A longer answer is one way to spend more inference compute. Research offers another: more hypotheses, more experiments, and more opportunities to revise a decision using feedback.

That budget has to survive beyond one conversation. A new session might repeat an old failure. Parallel attempts might all wait on the same dependency. More output might produce more answers without a shared way to judge them.

The engineering challenge is to scale token use continuously and reliably across a research process. The useful unit is an attempt that produces evidence and informs what comes next. Four aspects of search determine how much of the extra budget reaches that point.

Search space: expand the possibilities

An open-ended goal needs a space of possible interventions and a clear evaluation rule. What can change? What must stay fixed? Which observations would justify another experiment?

Consider a hypothetical code-repair task. With the model and data fixed, we could compare retrying a failed tool call immediately with diagnosing the failure first. Each attempt should specify the intervention, the expected effect, and the possible cost. A test that never launches tells us something different from a valid test that shows no improvement.

Recording these distinctions makes exploration cumulative. Later attempts can see which regions have been visited, which hypotheses failed, and where uncertainty remains. The space can expand as new ideas appear, while results remain comparable under the same evaluation conditions.

Search speed: explore more in parallel

Once attempts are comparable, independent ones can proceed in parallel. Each needs its own working environment, so changes do not collide and results can be traced back to a particular intervention.

The important scheduling choice is to let evidence return as soon as it is ready. One experiment should not wait for an unrelated one to finish before it can be evaluated or revised. Dynamic workflows can keep this pipeline moving as dependencies resolve.

Lower-cost models make wider exploration more affordable. But useful throughput depends on the actual bottleneck: shared hardware, API limits, slow evaluation, and repeated repairs can absorb the extra capacity. Speed matters because it shortens the wait for the next informative observation.

Search space

Explore different regions. Keep the trail.

An abstract terrain with distinct regions and branching blue exploration traces.

Search speed

Independent attempts keep moving.

Several blue exploration ribbons advance independently through an open field.
A meaningful space gives parallel exploration a direction. Conceptual illustrations generated with Seedream, not measured trajectories.

Search efficiency: spend the budget where it matters

Faster search also produces mistakes faster. Several attempts can share the same false assumption, or fail because of the same broken tool. Increasing their number adds little information until that common cause is understood.

This is where stronger reasoning can be especially useful. An advisor can challenge a hypothesis, compare observations with expectations, and suggest a more informative next experiment. That judgment should guide the search without turning every action into a request for approval.

The feedback needs to affect subsequent choices. Which direction deserves more budget? Which should stop? What observation would distinguish competing explanations? A recommendation earns its place when it changes the next attempt, not simply when it sounds convincing.

Search continuity: sustain the search over time

Useful findings need to outlive the conversation that produced them. Goals, experiments, results, failed approaches, and reusable lessons should remain available to the next session.

Continuity also requires stable execution. Background supervision, recovery, and explicit completion checks help long tasks continue despite session boundaries. A returning agent needs to know both what was learned and what is still running, so it can resume rather than repeat work.

These records should influence behavior: a known failure changes the next proposal; an existing job is not submitted again; a useful observation becomes the starting point for another experiment. Saving a transcript is only the beginning. The next session has to use it.

Search efficiency

Let evidence guide the next direction.

Blue paths move through partly obscured terrain, guided by scattered gold evidence markers.

Search continuity

Continue from the last useful point.

A blue exploration trace continues across layered work periods and resumes after an interruption.
Evidence helps choose a direction; retained context lets exploration continue. Generated concept illustrations, not performance results.

Scale a process that can accumulate

More tokens are an input. What matters is whether the search turns them into new evidence and better decisions. That requires evaluating the full cost of attempts, retries, advice, and external experiments, while checking that improvements transfer beyond familiar development tasks.

The four aspects reinforce one another. A broader space creates room for ideas; faster execution tests them; better judgment allocates effort; continuity carries the useful work forward. Together, they make sustained exploration possible. Letting the searcher itself become a search variable is a further extension of the same idea.

Based on this perspective, I put together RSearch, a simple framework built largely from Claude Code’s existing capabilities. It is a small implementation of the idea: keep the search running, keep it grounded, and let the next attempt build on the last.