Seeds: Why One Prompt Gives a Different Image Every Time

One prompt gives a different image every time because the seed changes between runs. The seed is the number that decides which patch of random static (the technical term is noise) a run starts from. Leave it unset and you get a new number, and so a new patch, every time. The model builds pictures by clearing static away, so a different patch of static means a different picture, even when your words are identical. (Models that work this way are called diffusion models.)

Most people meet seeds the hard way. Something good comes out. They tap generate again to see a variation, and the good one is gone for ever. This post covers what a seed is, why the same prompt drifts without one, and the working method that turns the seed into a control.

What a seed is

A seed is a starting number. The app hands it to the part that spits out random numbers (a random number generator), and those numbers become the static your image grows from. The same seed always builds the same static. Push that static through the same model, with the same prompt and settings, and you can often reproduce the result within the same deterministic pipeline. Software versions, hardware, and nondeterministic operations can still change it.

This sampling uses a pseudorandom generator: a fixed formula whose output is spread evenly enough to pass for random, and a seed says where in that stream to start. Seed 4172 hands back the same sequence it handed back last time. Those numbers fill a field of static the size of your image. The model then strips that static away one step at a time, following your prompt as it goes. We walk through that process in diffusion models, explained simply.

A seed is an address. Seed 8 is not warmer or better than seed 9. Each one points at one patch of starting static, and your prompt decides what gets built there.

Why identical prompts diverge

When you do not set a seed, the app picks a fresh one at random for every image. Your prompt stayed the same and the starting static did not. Two runs of the same words are two images that share a description.

Random by default is a sensible choice, because a prompt is a loose description. Millions of images match “a fox asleep on a stack of books”. It turns into a problem when your goal shifts from finding an image to refining one. Now the randomness gets in the way of the experiment. You change three words, the result looks nothing like the last one, and you cannot tell whether your words did that or the dice did.

The workflow: explore wide, then lock and vary

In tools that expose seed locking, the method has two phases. First you explore with random seeds until a layout turns up that you would be glad to improve. Then you lock that seed and change one thing at a time in the prompt. Locking takes the randomness out of the comparison, so every difference you see is one you caused.

1. Explore. Keep the prompt roughly fixed and let the seed run free. Generate ten or twenty. You are choosing layout and mood at this stage. Do not fuss over wording yet, because a new seed rearranges everything anyway.
2. Lock. Pick the promising result and pin its seed. You can now call that image back whenever you want, and that is what makes experimenting safe.
3. Vary one thing. Change a single element. Swap “evening” for “overcast”. Add “shallow depth of field”. Drop an unneeded adjective. Even with the seed fixed, a prompt change can alter the layout.
4. Re-roll last. Once the prompt is right, run a handful of fresh seeds with it. Nearby numbers do not give you similar images, so this is a new sample. The difference is that you now trust the prompt instead of guessing at it.
5. Write it down. Seed, exact prompt, model version, step count, resolution, scheduler, and pipeline version all matter to reproducibility.

A locked seed turns generating into editing. With the seed loose, every tap is a fresh sample, so progress comes down to luck.

A seed only reproduces within the same setup

A seed brings a result back only when everything else stays put: the model, the step count, the resolution, the guidance setting and the prompt. Change any one of them and the same seed hands you a different picture, often a completely different one.

A seed is an ID for the static you started from, and everything downstream has to match for that static to land in the same place. Changing the step count is the most common way to lose a result you thought you had saved. It changes the route the model takes through the same static. Our post on what denoising steps really change goes into that.

A seed picks the starting static and nothing else. The trained numbers inside the model that read that static (its weights) are a separate thing.

The image you cannot get back

Save the seed the moment you like an image, not later. You cannot pull a seed back out of a finished picture. Nothing in the pixels stores it, and re-running the prompt will not stumble onto the same number again. If you did not record it, it is gone. This is the most common frustration in image generation, and it is preventable.

Some apps keep the settings with each image, so reusing a seed is one tap. If yours does not, copy the seed and the prompt into a note before you change anything. Keep an eye on exports too, because sharing often strips the hidden settings (the metadata) out of the file, and the recipe goes with them.

Seeds in Onhand

Onhand stores generation settings, including the seed, with results in its local gallery. It does not expose a numeric seed field or a seed-lock control. Use Reuse settings to restore a saved recipe orMake variations to explore fresh results. Reuse can retain the saved seed when the original conditioning still matches; changing the prompt or model is not a manual seed-lock workflow.

Use Refine when you want to work from the finished image itself, then Keep or Revert the result. Reproducibility depends on the entire pipeline, including model version, resolution, quality, and numerical behavior. Keeping the exported image is the reliable way to preserve a result.

To keep working from a result instead of starting again, see image to image on iPhone, which covers Refine and the strength control. If manual control over settings like the seed matters more to you, Onhand vs Draw Things compares Onhand with an app built for that kind of depth.

Sources

Primary sources for the claims above, so you can check them rather than take our word for it.

• Ho et al., Denoising Diffusion Probabilistic Models (2020). Defines the sampling process that begins from a random noise field, which is what a seed selects.
• Rombach et al., High-Resolution Image Synthesis with Latent Diffusion Models (2022). Shows noise sampled in a compressed latent space, which is why seeds are tied to a model and resolution.
• Stability AI, SD Turbo model card. The low-step, guidance-free setup referenced above.