---
title: Iterative editing — GPT-Image-2.5 Flare | Runware Docs
url: https://runware.ai/docs/models/openai-gpt-image-2-5-flare/guides/iterative-editing
description: "How to run a chain of edits with GPT-Image-2.5 Flare: feeding each result back as the next source, what accumulates across passes, and when to restate instead of chain."
---
### [Introduction](https://runware.ai/docs/models/openai-gpt-image-2-5-flare/guides/iterative-editing#introduction)

Art direction does not arrive as one instruction. A shot gets a colour change, then a prop, then a different wall, then a note about the light, and each round is judged before the next one is asked for. Every round is a separate call to the model, and each one has to start from **the version that was approved**, not from the original.

Flare is built for that loop. OpenAI's stated improvement here is that **earlier edits stay put** as later ones are applied, and that quality holds instead of softening a little more on each pass. The four passes below were run in order, each one taking the previous result as its source.

**Source**:

![A floor lamp with a natural linen shade standing in the corner of a living room beside a small walnut side table, against a plain white wall](https://runware.ai/docs/assets/source-lamp.CIHeYYe3_kE9aw.jpg)

**Pass 1**:

![The same floor lamp in the same corner with its shade changed from natural linen to matte black](https://runware.ai/docs/assets/output-pass-1.Dx2Y9eA4_Z133kcA.jpg)

> **Prompt**: Change only the natural linen lampshade to a matte black one. Preserve its shape, its proportions and the way it sits on the stand. Keep the lamp base, the side table, the wall, the floor, the framing and the lighting unchanged.

**Pass 2**:

![The same corner with the matte black lampshade and the wall repainted deep forest green](https://runware.ai/docs/assets/output-pass-2.Cx2jUXKE_1GEaTW.jpg)

> **Prompt**: Change only the wall colour to a deep forest green. Preserve the lamp, its matte black shade, the side table, the floor, the framing and the lighting unchanged.

**Pass 3**:

![The same corner with the matte black shade and green wall, now with a stack of three hardback books lying on the side table](https://runware.ai/docs/assets/output-pass-3.CnV0jZHi_Z8AjVx.jpg)

> **Prompt**: Add a stack of three hardback books lying flat on the side table, next to the lamp base. Keep the lamp, its matte black shade, the green wall, the table, the floor, the framing and the lighting unchanged.

**Pass 4**:

![The same corner with the lamp switched on, warm light falling down the green wall and across the side table and the stack of books](https://runware.ai/docs/assets/output-pass-4.DLDLEQIi_KwJT0.jpg)

> **Prompt**: Switch the lamp on so it casts a warm pool of light down the green wall and across the side table and the books. Keep the lamp, its matte black shade, the wall colour, the table, the books, the floor and the framing unchanged.

Step through them. The black shade from pass 1 is still black in pass 4, and the books added in pass 3 are the ones the lamp lights up.

This guide covers the loop itself, what holds across passes and what accumulates, chaining against restating, and when to throw the chain away.

### [The loop](https://runware.ai/docs/models/openai-gpt-image-2-5-flare/guides/iterative-editing#the-loop)

Each turn is an ordinary edit. The only thing that makes it a chain is **where the source comes from**: the image the previous turn returned.

**TypeScript**:

```typescript
import { createClient } from '@runware/sdk'

const client = await createClient({ apiKey: process.env.RUNWARE_API_KEY })
await client.connect()

const [result] = await client.run({
  model: 'openai:gpt-image@2.5-flare',
  positivePrompt: 'Change only the wall colour to a deep forest green. Preserve the lamp, its matte black shade, the side table, the floor, the framing and the lighting unchanged.',
  inputs: {
    referenceImages: [
      '8f3d1a5c-7b20-4e69-a4d1-0c6e2f8a3b57'
    ]
  },
  width: 1536,
  height: 1024
})
```

**Python**:

```python
import asyncio
import os

from runware import Runware

async def main():
    async with Runware(api_key=os.environ["RUNWARE_API_KEY"]) as client:
        results = await client.run({
            "model": "openai:gpt-image@2.5-flare",
            "positivePrompt": "Change only the wall colour to a deep forest green. Preserve the lamp, its matte black shade, the side table, the floor, the framing and the lighting unchanged.",
            "inputs": {
                "referenceImages": [
                    "8f3d1a5c-7b20-4e69-a4d1-0c6e2f8a3b57"
                ]
            },
            "width": 1536,
            "height": 1024
        })

asyncio.run(main())
```

**cURL**:

```bash
curl https://api.runware.ai/v1 \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "taskType": "imageInference",
      "taskUUID": "e2a7c4b1-9d38-4506-8f1a-3b7c2d5e9068",
      "model": "openai:gpt-image@2.5-flare",
      "positivePrompt": "Change only the wall colour to a deep forest green. Preserve the lamp, its matte black shade, the side table, the floor, the framing and the lighting unchanged.",
      "inputs": {
        "referenceImages": [
          "8f3d1a5c-7b20-4e69-a4d1-0c6e2f8a3b57"
        ]
      },
      "width": 1536,
      "height": 1024
    }
  ]'
```

**CLI**:

```bash
runware run openai:gpt-image@2.5-flare \
  positivePrompt="Change only the wall colour to a deep forest green. Preserve the lamp, its matte black shade, the side table, the floor, the framing and the lighting unchanged." \
  inputs.referenceImages.0=8f3d1a5c-7b20-4e69-a4d1-0c6e2f8a3b57 \
  width=1536 \
  height=1024
```

**JSON**:

```json
{
  "taskType": "imageInference",
  "taskUUID": "e2a7c4b1-9d38-4506-8f1a-3b7c2d5e9068",
  "model": "openai:gpt-image@2.5-flare",
  "positivePrompt": "Change only the wall colour to a deep forest green. Preserve the lamp, its matte black shade, the side table, the floor, the framing and the lighting unchanged.",
  "inputs": {
    "referenceImages": [
      "8f3d1a5c-7b20-4e69-a4d1-0c6e2f8a3b57"
    ]
  },
  "width": 1536,
  "height": 1024
}
```

The reference is a bare UUID rather than a URL. Image inputs accept **a UUID, a URL, a data URI or base64**, and the `imageUUID` that came back from the previous turn is the cheapest of the four to pass along: no download, no re-upload, no storage of your own between rounds.

```typescript
let current = firstResult.imageUUID

for (const instruction of rounds) {
  const [result] = await client.run({
    model: 'openai:gpt-image@2.5-flare',
    positivePrompt: instruction,
    inputs: { referenceImages: [current] },
    width: 1536,
    height: 1024,
  })

  current = result.imageUUID
}
```

Keep `width` and `height` fixed for the whole chain. Changing them mid-run makes the model recompose rather than edit, and the passes stop lining up against each other.

### [What holds and what accumulates](https://runware.ai/docs/models/openai-gpt-image-2-5-flare/guides/iterative-editing#what-holds-and-what-accumulates)

Two different things travel down a chain, and only one of them is wanted.

**Your changes hold.** Each instruction names what it is changing and what it is preserving, and the preserved half comes through the next pass intact. That is the property the whole workflow rests on, and it is what the four passes above demonstrate.

**Small drift accumulates.** Every pass is a fresh render, not a patch applied to pixels, so the parts of the frame nobody mentioned are reproduced rather than copied. Reproduced is close, and close compounds. Fine texture is where it shows first, so check grain, fabric weave and small type against the original rather than against the previous pass.

![A floor lamp with a natural linen shade beside a walnut side table against a white wall, the wood grain and the weave of the shade sharply detailed](https://runware.ai/docs/assets/source-lamp.CIHeYYe3_kE9aw.jpg)

*Source*

![The same corner after four edits, the walnut table grain and the floor texture still legible under the warm lamp light](https://runware.ai/docs/assets/output-pass-4.DLDLEQIi_KwJT0.jpg)

*After four passes*

> **Prompt**: Switch the lamp on so it casts a warm pool of light down the green wall and across the side table and the books. Keep the lamp, its matte black shade, the wall colour, the table, the books, the floor and the framing unchanged.

The side table was never mentioned in any of the four instructions, which makes it the honest place to look. Compare its grain across the two, not the parts that were deliberately changed.

> [!NOTE]
> **Keep every intermediate.** Each pass returns its own `imageUUID`, and holding on to them means a bad fourth pass costs you one call from the third rather than a rebuild from the original. Storing the chain is also what lets you show a client the round they approved.

### [Chaining or restating](https://runware.ai/docs/models/openai-gpt-image-2-5-flare/guides/iterative-editing#chaining-or-restating)

There are two ways to reach the same finished image, and they are not interchangeable.

**Chaining** runs one change per call, each on the previous result. **Restating** goes back to the original source and asks for every change in a single instruction. The image below is the second route: one call on the untouched source, carrying all four changes at once.

![The lamp corner reached through four separate edits, with a black shade, a green wall, a stack of books on the table and the lamp lit](https://runware.ai/docs/assets/output-pass-4.DLDLEQIi_KwJT0.jpg)

*Four chained passes*

> **Prompt**: Switch the lamp on so it casts a warm pool of light down the green wall and across the side table and the books. Keep the lamp, its matte black shade, the wall colour, the table, the books, the floor and the framing unchanged.

![The same corner reached in a single edit, with a black shade, a green wall, books on the table and the lamp lit](https://runware.ai/docs/assets/output-cumulative.BqZgFzP7_1f8eem.jpg)

*One instruction on the original*

> **Prompt**: Change the lampshade to matte black, change the wall colour to a deep forest green, add a stack of three hardback books lying flat on the side table next to the lamp base, and switch the lamp on so it casts a warm pool of light down the wall and across the table. Keep the lamp base, the table, the floor, the framing and the camera unchanged.

Restating is **one call instead of four** and it starts from an image that has been through nothing, so it carries no accumulated drift. What it costs you is the checkpoints: one result to accept or reject, with no way to keep the wall colour and re-ask for the books.

The rule that falls out of it: **chain while a human is still judging each round**, and restate once the full list of changes is settled. A chain is for the art-direction conversation, a restatement is for the final render, and rebuilding a settled chain as one instruction is worth doing before you generate the asset you actually ship.

### [When to start over](https://runware.ai/docs/models/openai-gpt-image-2-5-flare/guides/iterative-editing#when-to-start-over)

A chain has a point past which it stops paying, and it is easier to see than to define. Three signs, and any one of them is enough.

An instruction **stops landing**. You ask for the same change twice and get the same wrong result, which usually means the model is reconciling your new instruction against something it inferred several passes ago.

Detail **has gone soft** somewhere nobody asked about. Once texture has drifted, no later instruction restores it, because each pass only knows the image it was handed.

The list of things to preserve **has grown longer than the change**. When an instruction spends four clauses protecting earlier passes to make one small change, restating from the original is both shorter and safer.

### [Tips](https://runware.ai/docs/models/openai-gpt-image-2-5-flare/guides/iterative-editing#tips)

1. **Pass the `imageUUID`, not the URL.** The previous response already contains everything the next call needs.
    
2. **Hold `width` and `height` constant.** A size change mid-chain turns an edit into a recomposition.
    
3. **Keep every intermediate.** A rejected pass should cost one call, not the whole chain.
    
4. **Name the earlier changes in later instructions.** "Keep the matte black shade" in pass 3 is cheap insurance and costs you nothing when it was going to hold anyway.
    
5. **Audit texture against the original.** Drift is invisible pass to pass and obvious end to end, so compare the current result with where you started.
    
6. **Restate the settled chain before you ship.** Once the changes are agreed, one instruction on the untouched source gives you the same image without the accumulated passes.