live
MODEL IDideogram:4.5@precise-edit

Ideogram 4.5 Precise Edit

Ideogram
by

Ideogram 4.5 Precise Edit is the precision editing variant of Ideogram 4.5. It applies a natural-language instruction to a source image, optionally limited by a mask and guided by up to four reference images, and restores unchanged pixels from the source so framing, color, and surrounding detail stay intact across many rounds of edits. It keeps the source dimensions and suits retouching, product and color changes, and multi-step design revisions.

Ideogram 4.5 Precise Edit

Iterative editing

How to run a chain of edits with Ideogram 4.5 Precise Edit, one change per round, while every pixel the instruction leaves alone is restored from the source.

Introduction

Most image models redraw the whole frame on every edit. Ask for a new sign and the brickwork next to it shifts by a few pixels and comes back in slightly different colors. One round of that is invisible. Ten rounds later the image has drifted away from the version the client approved, and nobody can say which edit did it.

Ideogram 4.5 Precise Edit is built for that loop. It applies one instruction to a source image and then restores every pixel the edit left untouched from that source, so the parts of the frame nobody asked about come back as they went in. The shop front below went through ten rounds, each one taking the previous result as its source.

Step through the rounds, and go back to Original to compare. The brick buildings on either side were never mentioned in any instruction, and they are still the same bricks at round nine.

This guide covers the loop itself, what restoration protects, how to write each instruction, the order that keeps restoration working, branching and choosing a quality tier per round.

The loop

Each round is an ordinary edit. The source goes in inputs.seedImage, the instruction goes in positivePrompt, and the result comes back at the source's own dimensions, up to 2048 pixels on the longer side, so there is no width or height to set. What makes it a chain is where the source comes from: the image the previous round returned.

Try in Playground
import { createClient } from '@runware/sdk'

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

const [result] = await client.run({
  model: 'ideogram:4.5@precise-edit',
  positivePrompt: 'Place two of the white ceramic planters with olive trees from the reference image on the sidewalk, one on each side of the door. Keep everything else in the image exactly the same.',
  inputs: {
    seedImage: 'a3f07d2e-5b1c-4e8f-9a64-0c7d2b9e1f58',
    referenceImages: [
      'e91b4c6d-7a20-4f35-8d1e-2b5c9f0a7e46'
    ]
  }
})
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": "ideogram:4.5@precise-edit",
            "positivePrompt": "Place two of the white ceramic planters with olive trees from the reference image on the sidewalk, one on each side of the door. Keep everything else in the image exactly the same.",
            "inputs": {
                "seedImage": "a3f07d2e-5b1c-4e8f-9a64-0c7d2b9e1f58",
                "referenceImages": [
                    "e91b4c6d-7a20-4f35-8d1e-2b5c9f0a7e46"
                ]
            }
        })


asyncio.run(main())
curl https://api.runware.ai/v1 \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "taskType": "imageInference",
      "taskUUID": "6c1e8a42-3f9d-4b7a-9e05-d28b4c7f1a93",
      "model": "ideogram:4.5@precise-edit",
      "positivePrompt": "Place two of the white ceramic planters with olive trees from the reference image on the sidewalk, one on each side of the door. Keep everything else in the image exactly the same.",
      "inputs": {
        "seedImage": "a3f07d2e-5b1c-4e8f-9a64-0c7d2b9e1f58",
        "referenceImages": [
          "e91b4c6d-7a20-4f35-8d1e-2b5c9f0a7e46"
        ]
      }
    }
  ]'
runware run ideogram:4.5@precise-edit \
  positivePrompt="Place two of the white ceramic planters with olive trees from the reference image on the sidewalk, one on each side of the door. Keep everything else in the image exactly the same." \
  inputs.seedImage=a3f07d2e-5b1c-4e8f-9a64-0c7d2b9e1f58 \
  inputs.referenceImages.0=e91b4c6d-7a20-4f35-8d1e-2b5c9f0a7e46
{
  "taskType": "imageInference",
  "taskUUID": "6c1e8a42-3f9d-4b7a-9e05-d28b4c7f1a93",
  "model": "ideogram:4.5@precise-edit",
  "positivePrompt": "Place two of the white ceramic planters with olive trees from the reference image on the sidewalk, one on each side of the door. Keep everything else in the image exactly the same.",
  "inputs": {
    "seedImage": "a3f07d2e-5b1c-4e8f-9a64-0c7d2b9e1f58",
    "referenceImages": [
      "e91b4c6d-7a20-4f35-8d1e-2b5c9f0a7e46"
    ]
  }
}
Response
[
  {
    "taskType": "imageInference",
    "taskUUID": "6c1e8a42-3f9d-4b7a-9e05-d28b4c7f1a93",
    "imageUUID": "0d7f3b91-c4e2-4a58-b6d0-9e1a5c2f8b74",
    "imageURL": "https://im.runware.ai/image/os/a14d18/ws/2/ii/0d7f3b91-c4e2-4a58-b6d0-9e1a5c2f8b74.jpg"
  }
]

The source is the imageUUID the previous round returned, which is the cheapest way to chain: nothing to download or upload between rounds. References ride along in inputs.referenceImages, up to four of them, and they guide the edit without being edited themselves.

let current = source.imageUUID

for (const instruction of rounds) {
  const [result] = await client.run({
    model: 'ideogram:4.5@precise-edit',
    positivePrompt: instruction,
    inputs: { seedImage: current },
  })

  current = result.imageUUID
}

What restoration protects

After each edit, every pixel that did not meaningfully change is restored from the source, and the edited region is blended into its surroundings. That is why the untouched part of the frame does not drift from round to round. There is no parameter for it, and nothing to switch on.

The left-hand building is the honest place to check. No instruction in the chain mentions it, so any difference between the original and round nine is drift.

The mortar lines and the panes of the sash window match in both insets. Nine renders passed over that building and none of them left a mark on it.

Results come back at most 2048 pixels on the longer side. A larger source is scaled down to fit, so the 2560 × 1440 original above returned at 2048 × 1152, and every round after it stayed at that size. Start from a source that is 2048 pixels or less on its longer side when the output has to match the source's dimensions.

Writing each instruction

Precise Edit turns a plain-language instruction into a structured edit on its own, so there is no special syntax to learn. What matters is that each instruction names one target and one change, and then says what stays.

Place two of the white ceramic planters with olive trees from the reference image, on the sidewalk, one on each side of the door., Keep everything else in the image exactly the same.
ChangePlacementPreserve

The change names the object precisely enough that the model cannot pick the wrong one: not "a plant" but the planter from the reference. The placement anchors it to something already in the frame. The closing sentence costs nothing and tells the model the edit is local, which is what restoration needs to do its job.

One change per round is the rule the whole chain rests on. A round that does one thing can be approved or rejected on its own. A round that repaints the facade, adds the awning and fills the window at once gives you one result to accept or reject, and no way to keep the paint while re-asking for the awning.

Local edits first, global edits last

Restoration protects what the instruction leaves alone. An instruction that relights the whole frame leaves very little alone.

The finished shop front in overcast daylight

Hang a single string of warm white bulb lights along the front edge of the awning. Keep everything else in the image exactly the same.

Round 9Round 10

The dusk round keeps every object where it was, but the sky, the brick, the glass and the pavement are all relit. That is the right result, and it is why lighting, weather and time of day belong at the end of the chain, after the local edits are approved. Relight in round three and every later round inherits that light, so changing your mind about it means redoing every round after it.

Branching from an earlier round

Every round returns its own imageUUID. Keep all of them, and any round becomes a place to branch from: the chain after it stays intact while you try alternatives.

Both alternatives start from round three, so the paint and the sign carry over and only the awning changes. Because restoration holds the rest of the frame, the three versions line up pixel for pixel outside the awning, which is what makes them easy to put side by side in front of a client.

Quality per round

settings.quality takes very_low, low, medium or high, and high is the default. At high the model picks the best of five candidates for each result, which makes it the slowest and most expensive tier. very_low is the fastest and cheapest.

All four ran the same instruction on the same source, and all four spell the name correctly. very_low set it on the lower band of the fascia instead of the sign board. From low up, the name sits on the board, and high spaces the capitals most evenly. The cheap tiers show whether an instruction lands where you meant it to, which is the question a draft round is asking.

That points to a simple split: draft each round at a low tier, and once the instruction is right, run it again at high for the version that goes into the chain. The cheap rounds are the ones that get thrown away.

Tips

  1. One change per round. A round that does one thing can be approved or rejected on its own, and a rejected round costs one call.

  2. Close every instruction with what stays. "Keep everything else in the image exactly the same" tells the model the edit is local.

  3. Keep every imageUUID. Any earlier round is a branch point, and the next call needs nothing else from the response.

  4. Relight last. A change of light touches most of the frame, so put it after the local edits are settled.

  5. Draft low, finish high. Settle the instruction at very_low or low, then run the approved version at high.

  6. Keep sources at 2048 pixels or less on the longer side. A larger source is scaled down, and the whole chain continues at the smaller size.

For edits limited to one region, see Masked edits. For changing the words in a finished design, see Text and localization.