The best image is already in the noise

Type the same prompt into an image model nine times and you get nine different pictures. One is blurry. One crops the bottle in half. One has a label that reads "OLIVE OJL". And one, if you are lucky, is the picture you actually wanted.

Most people keep whatever comes out first. A growing body of research says that is leaving most of the quality on the table. The model did not fail. You just stopped looking too early.

This idea has a name: inference-time search. It is one of the most exciting shifts in generative media right now, and the core of it is simple enough to explain over coffee.

First, how these models actually paint

Almost every modern image and video model (FLUX, Qwen-Image, Wan, and friends) is a diffusion model. They all work the same basic way: they start from pure static, like an old TV with no signal, and remove a little bit of that static at a time until a picture appears.

Think of a sculptor and a block of marble. The prompt is the instruction ("a bottle on a counter"), the model is the sculptor, and the static is the block. Here is the part that matters: every block of marble is different. The grain, the cracks and the soft spots all push the sculptor in slightly different directions. That block is what people call the seed.

Video works the same way, except the block of marble is three-dimensional: it stretches through time as well as across the frame. That makes it even more sensitive to where you start. A bad start in video does not just give you a worse picture. It gives you a dog with five legs, or a frisbee that teleports between frames.

The old knob: more steps

For years, the main way to "spend more" on quality was to take more cleanup steps. Instead of removing the static in 20 passes, remove it in 50. Smaller, more careful chisel strokes.

This helps, up to a point. After a few dozen steps, the gains flatten out. Going from 50 steps to 500 costs ten times the GPU time and you will struggle to see a difference. A careful sculptor working a cracked block of marble still ends up with a cracked statue.

The new knob: search

In early 2025, a team from Google DeepMind, NYU and MIT published a paper with a simple reframing. Instead of only making each attempt more careful, treat generation as a search problem: try several starting points, judge them, and spend your effort on the promising ones.

Their finding was that this second kind of spending keeps paying off long after extra steps stop helping. Search let smaller models compete with bigger ones on the same prompts. Language models went through the same shift recently, when "thinking longer" at answer time turned out to matter as much as training a bigger model. Search is the image-and-video version of thinking longer.

Every search setup has two parts. Once you understand these two, you understand the whole field.

1. A judge (researchers say "verifier") that looks at a result and gives it a score.
2. A strategy (the "search algorithm") that decides which starting points to try next.

Part one: the judge

A judge is just another, smaller AI model that is good at looking at pictures. It does not need to make anything. It only needs to tell better from worse, which is a much easier job. (You can tell a great meal from a bad one without being a chef.)

There are a few common kinds of judge, and each one notices different things:

• Prompt match. Does the picture show what was asked for? Models like CLIP score how well an image and a sentence agree.
• Looks. Is it pleasing? Aesthetic scorers are trained on millions of human ratings of photos.
• Human preference. Which of two images would a person pick? Models like ImageReward learn this from side-by-side votes.
• Ask a question. A vision-language model (an AI that can read images) is asked specific yes-or-no questions: "Is the label readable?" "Does the dog have four legs?"

The last kind is the most flexible, because you can write the questions yourself. It turns "make it good" into a checklist that a machine can grade.

Part two: the strategy

Once you have a judge, you need a plan for what to try. The research describes three, from simplest to smartest.

1. Random search: take lots of shots, keep the best

Generate 8, 16 or 32 versions from different seeds, score them all and keep the winner. This is exactly what a professional photographer does: shoot a whole roll and pick one frame. It is simple and surprisingly strong.

2. Neighborhood search: start from good, nudge nearby

Take your best starting point and make small changes to it, keeping any change the judge likes more. It is like finding a good fishing spot and then trying a few meters to the left and right instead of driving to a new lake. Small changes to the static mean small changes to the picture, so you are refining rather than starting over.

3. Path search: check the drafts early

This is the clever one. Remember the denoising figure: the overall layout of the picture is settled surprisingly early, and the last steps mostly add fine detail. So you do not have to finish a bad attempt to know it is bad.

Path search starts many attempts, pauses them partway through, lets the judge glance at the rough drafts, and only keeps working on the promising ones. The rest are dropped before they cost you the full price. It is the way a gardener thins seedlings: plant many, keep the strongest, give them the room.

Two worked examples

These are illustrative walkthroughs to show the thinking, not benchmark results.

The catch: judges can be fooled

Any time you optimize for a score, you risk getting the score instead of the thing you wanted. Researchers call this verifier hacking. A looks-only judge, pushed hard, starts rewarding oversaturated colors and dreamy glow whether or not the picture matches the prompt. Push a prompt-match judge alone and you can get images that technically contain every word but look strange.

The fix is the same one people use for human panels: do not rely on a single judge. Combine a prompt-match score with a looks score, add a few specific checklist questions, and keep the search budget sensible. The research also found that no single judge is best for every job, so it is worth trying a couple.

What it costs

Search is not free. Sixteen attempts use roughly sixteen times the GPU work of one, plus a small cost for the judge. Path search cuts that a lot by dropping weak attempts early.

The good news is that attempts do not depend on each other, so they run side by side. On a GPU with enough memory, or across a few GPUs, sixteen attempts can finish in about the time one used to. That is why we think about this so much at ClockingCloud: search turns GPU time directly into quality, in a way that more steps no longer does.

A recipe you can try today

1. Pick your prompt and keep your usual model and step count.
2. Write three to five yes-or-no questions that describe "right" for this job (text spelled correctly, hands look normal, product fully in frame).
3. Generate 8 to 16 versions with different seeds, in parallel.
4. Score each with a prompt-match model plus your questions, asked to a vision-language model. Throw out anything that fails a question.
5. Keep the top one or two. For video, check at about 25 percent of the way through and only finish the leaders.
6. Save the winning seed. A good seed for one prompt is often a good starting point for close variations of it.

The model already knows how to make the picture you want. Search is just the discipline of looking for it.

We will go deeper in future posts on choosing judges, picking a search budget, and how to run all of this on GPUs without paying for attempts you throw away.