Building Multi-Panel Story Grids from a Reference Photo

There is a prompt pattern worth knowing: ask an image model for a grid of panels, each showing a later stage of the same situation, with the subject taken from a photo you supply. One generation, nine panels, one face throughout. It is the cheapest way to get a coherent visual sequence out of a model, and this covers how to write it, which models can do it, and where it falls apart.

Why one generation beats nine

The obvious approach to a nine-panel sequence is nine generations. It is also the approach that produces nine slightly different people. Identity, lighting, wardrobe and rendering style all drift between runs, and stitching them back together means fighting that drift with reference images, LoRAs or seed juggling.

Inside a single generation, none of that drift exists. The model composes the whole canvas at once, so consistency across panels comes for free — the same way a model keeps a person's two hands looking like they belong to one person. You trade resolution for coherence, which for storyboards, mood boards, and concept sequences is usually the right trade.

The prompt pattern

Four things have to be in the prompt, and the order below works well:

1. The grid. State the layout explicitly — "a 3x3 grid", "a four-panel strip". Vague words like "a series of images" produce a single blended scene.
2. The subject source. Point at the attached image: "the person in the attached photo". This only works on a model that accepts image conditioning; more on that below.
3. The progression. Say what changes from panel to panel, and in which direction. This is the load-bearing sentence.
4. The style anchor. One phrase that fixes the visual register for all panels at once.

Here is the pattern applied, using a party that gradually gets out of hand as the progression:

A 3x3 grid showing a house party going progressively off the rails, in the style of a gritty prestige-TV drama, featuring the person in the attached photo. Each panel is one step further into the evening than the last, reading left to right, top to bottom. Keep the same person, the same room and the same colour grading in every panel.

(Attach a clear, well-lit photo of the person alongside the prompt.)

The explicit reading order in the second sentence matters. Without it, models frequently arrange the progression as columns, or scatter it, and the sequence stops reading as a sequence. The final sentence is doing the other half of the work: naming what must stay constant is as important as naming what changes.

Picking a progression axis

The pattern generalises well beyond parties. What you are choosing is one variable to move monotonically across the panels.

One axis at a time. Two competing progressions in the same prompt usually produce panels that move on neither.

What the model has to support

Two capabilities are required, and not every image model has both: it must accept an input image as a subject reference, and it must parse a multi-clause instruction rather than a keyword list. That second requirement is why this pattern arrived with the generation of models that use large language models as their text encoder.

On the practical side, you have a hosted-versus-local choice. Hosted endpoints from the major image labs handle reference conditioning well and need no setup. On the open-weight side, Black Forest Labs released FLUX.2 in November 2025 with several variants including openly downloadable weights (bfl.ai, Hugging Face), which means grid work of this kind can run entirely on your own hardware if you have the VRAM for it.

The trade is the familiar one. Hosted gives you the strongest reference handling with no install and per-image cost; local gives you unlimited iteration, no content filtering surprises mid-project, and full control over the workflow, in exchange for setup and a serious GPU. For a technique that rewards heavy iteration — and this one does, since the progression rarely lands first try — local pays off faster than it does for one-off generations.

The resolution ceiling

A 3x3 grid gives each panel roughly one ninth of the canvas area. At a typical output size that leaves each face rendered at a size where fine detail simply is not there. Plan around it:

• Generate the grid at the largest resolution your model and hardware support.
• Keep the subject large within each panel. Wide establishing shots inside a grid cell produce unusable faces.
• Treat the grid as a layout pass. Once you have a sequence you like, re-generate individual panels full-size using the grid panel as a composition reference.
• Drop to a 2x2 grid when faces matter more than panel count. Four good panels beat nine mushy ones.

Where it breaks

• Identity drift in later panels. The panels furthest from the top-left often resemble the reference least. Restating "the same person in every panel" helps; so does a cleaner reference photo.
• Panel bleed. Elements leak across cell boundaries, especially without explicit gutters. Asking for "clear separation between panels" reduces it.
• Wrong panel count. Models miscount grids more often than you would expect. Check before you evaluate anything else.
• Unwanted captions. Sequences invite the model to add panel numbers or subtitles. If you do not want them, say so directly.
• Non-monotonic progression. Panels five and six swap places in the story. Easiest fix is fewer panels, not a longer prompt.

Practical takeaways

• Ask for the grid in one generation; do not stitch separate runs together.
• Name the layout, the reading order, the one variable that changes, and everything that must not.
• Pick a single progression axis and let it move in one direction.
• Budget resolution per panel, and re-render the keepers at full size afterwards.
• Fewer panels is the fix for most quality problems, long before a longer prompt is.

Related reading

• Prompting Magazine Cover Layouts with Readable Typography
• Running Qwen-Image in ComfyUI on Consumer Hardware
• Prompting Qwen-Image: Structure, Text, and Quantization