Flux 3 Image: Edit One Thing, Keep the Rest

Making the first image is easy now. Fixing it is the hard part.

You ask for one change. The mug should be green. You get a green mug, and also a new window behind it, a slightly different face on the barista and a logo that was legible five minutes ago and now reads like a ransom note. So you regenerate, and the window is back but the hands are wrong. Every edit is a small bet that the rest of the picture survives, and most of the time you lose a little of it.

Flux 3 Image is Black Forest Labs' answer to that, and it's a more interesting answer than "better quality". The image side of Flux 3 lets you say where things go, change one of them, and expect the rest to stay put. It also reads text well enough to put real words in a frame, and it can look things up on the web before it draws. That combination changes what an image model is for: less slot machine, more layout tool.

We already covered the video half of the family in Flux 3: Scenes, Not Clips. This post is about the stills.

What Flux 3 Image Actually Is

Flux 3 isn't a video model with an image mode bolted on, or the reverse. BFL trained one multimodal model on images, video and audio at the same time, built on its Self-Flow approach, which the lab describes as "efficiently aligning multimodal generation and understanding within the same underlying architecture." The video post goes into why joint training matters for sound and motion. For stills, the short version is that the model has learned from more than pictures, and the image side launched in early October 2026 as the second piece of the family.

On each::labs it comes as two models. Flux 3 Text to Image takes a prompt and makes a picture. Flux 3 Edit takes one to ten images plus a prompt and changes, restyles or combines them. Both share the same small set of controls: aspect ratio, resolution, grounding and safety tolerance. That short list is telling: control in Flux 3 lives inside the prompt, not in a wall of sliders.

BFL says an open-weight version is expected in the coming weeks. If you build on the hosted model now, that's worth keeping in mind for later.

Text That Survives the Render

Text has been the tell of AI images for years. Menus that almost spell words. Labels that turn into a smear.

BFL says Flux 3's handling of complex prompts and text generation has "improved significantly" over earlier FLUX models, and that it renders "high-accuracy text in multiple languages." That comes from BFL's preliminary evaluations, so test it on your own copy. If a model can put the headline on the poster, the label on the jar and the street name on the sign, you skip the round trip to a design tool for every iteration.

The bounding-box docs add one practical habit worth knowing from day one: text gets its own box, and the exact words go in quotes inside that box's description. Don't make the model guess which part of a sentence is supposed to appear on the wall.

Let It Look Things Up First

Here's the feature that will surprise people. Both Flux 3 models have a grounding setting, on by default, that lets the model "research the prompt with web and image search before generating."

Why would an image model search the web? Because prompts are full of real things. A specific landmark, a particular breed, this year's poster for an event, a historical uniform. A model working only from training memory fills those gaps with something plausible, and plausible is exactly what you don't want when the reader knows the real thing. BFL's own example compares the same prompt for this year's official Oktoberfest poster with grounding off and on.

Turn it off when the subject is invented or when speed matters more. BFL's docs say grounding off gives faster results that use only your prompt. For a fantasy creature or an abstract brand texture, there's nothing to look up anyway.

Draw the Layout, Don't Describe It

"A cat on the left, a lamp on the right, a window behind them" is a request, not a layout. The model decides how far left, how big, how close. Flux 3 lets you stop requesting and start placing.

Bounding boxes go straight into the prompt, with no extra parameter. You write a normal caption, tag each element as <id>, then add a JSON array of rows. Each box is [top, left, bottom, right] in integers on a 0 to 1000 grid, measured from the top-left corner, so [0, 0, 500, 500] is always the top-left quarter whatever the output size. Here's a short layout prompt in the shape the docs use:

A quiet bookshop window at dusk. A ginger cat <cat_1> sleeps on a stack of books, and a hand-painted sign <sign_1> hangs above it. [{"id": "sign_1", "bbox": [60, 200, 220, 800], "desc": "Cream wooden sign with gold serif lettering reading \"OPEN LATE\""}, {"id": "cat_1", "bbox": [520, 300, 900, 700], "desc": "Ginger tabby curled up asleep, soft fur lit by a warm lamp"}]

One catch: the grid stretches with the frame. A box that looks square on 1:1 becomes a wide rectangle on 21:9, so design your boxes for the aspect ratio you actually send. And keep boxes generous. The docs note that very small boxes (around 40 by 25 pixels) often fail to appear, so give new content room.

The bigger shift is who writes this. BFL suggests letting a language model draft the caption and the element table from a short idea, which makes layout prompts something an app can generate, not something a designer has to type by hand.

Edit One Thing, Keep Everything Else

This is the part that answers the opening problem. Flux 3 Edit can recolor, replace, move or remove one element, and pixels outside the boxes you touch typically stay as they were. The launch coverage puts it as multi-step edits without changing other parts of the image, which is exactly the thing most edit workflows quietly fail at.

Edit rows look like layout rows with a little more information. Each one says which reference the element comes from (from), where it sits now (src_bbox) and where it should end up (tgt_bbox). Same source and target box means keep it in place. A different target means move it. A new element has no source and gets generated in its target box. Something like this, on a single photo:

Move the potted plant <plant_1> to the right side of the desk and keep the laptop <laptop_1> exactly where it is. [{"id": "plant_1", "from": "ref_image_0", "src_bbox": [300, 80, 700, 300], "tgt_bbox": [300, 700, 700, 920], "desc": "Small potted fern in a white ceramic pot"}, {"id": "laptop_1", "from": "ref_image_0", "src_bbox": [420, 340, 760, 660], "tgt_bbox": [420, 340, 760, 660], "desc": "Silver laptop, lid open"}]

Note what isn't on the list of inputs: a mask. Flux 3 Edit has no mask field on each::labs. Regions are targeted with boxes and names in the prompt instead. If you need a classic painted-mask inpainting job, Flux Fill Pro is still the dedicated tool for that.

Two habits from BFL's docs make edits behave. Anchor the surroundings in complex edits, so the model knows what must not move. And expect light to travel: BFL says "shadows, reflections, or nearby lighting may still change" outside a box, which is physically honest. Move a lamp and the room should look different.

Ten References, One Picture

Flux 3 Edit accepts up to ten images in a single request, each at least 256 by 256 pixels and at most 16 megapixels. You refer to them in the prompt by upload order, Image 1, Image 2 and so on, and say what each one contributes.

The person from image 1 wears the jacket from image 2 and stands in the kitchen from image 3, morning light from the window on the left.

That sentence is the whole interface, and it's a good one. Instead of hoping the model infers which upload is the face and which is the wardrobe, you assign jobs. Order matters for one more reason: with aspect ratio on auto, the output follows the first reference. Put the image whose framing you want to keep in slot one.

Pick the Resolution for the Job

Both models offer four output sizes: 768sq (about 0.6 MP), 1k (about 1 MP, the default), 2k (about 4 MP) and 4k (about 16 MP). Aspect ratios run from 21:9 to 9:21 with plenty in between, including 7:5 and 5:7, or auto if you'd rather the model choose for text to image.

The schema is blunt about one thing: 4k can take several minutes. So don't explore at 4k. Find the composition at 1k, where iterations come back fast, then rerun the keeper at 2k or 4k when it's headed for print, a large hero banner or a crop you'll need to zoom into. Resolution is a finishing decision, and treating it as one keeps your session moving.

Flux 3 vs Flux 2: What Actually Changed

The fair comparison is with Flux 2 Pro and Flux 2 Max, which are still live on each::labs and still good at what they do. (Our Flux 2 Pro explainer covers that generation in detail.)

Start with the model itself. Flux 2 is an image model. Flux 3 is a multimodal model whose image side learned alongside video and audio, and BFL reports significant gains in complex prompt handling and text generation over earlier FLUX versions.

Then look at the inputs on each::labs. Flux 2 Pro Edit takes one to four images. Flux 3 Edit takes up to ten. Flux 2 Pro picks its size from six presets such as square_hd and landscape_16_9. Flux 3 gives you fifteen explicit aspect ratios plus auto, and a separate resolution setting that reaches about 16 megapixels. Bounding-box layout and web grounding are new with Flux 3.

The control philosophy changed too. Flux 2 Pro exposes the classic diffusion knobs: guidance scale, inference steps, a seed, and up to four outputs from one request. Flux 3 drops those from the schema and moves control into the prompt itself, through boxes, tagged elements and numbered references. If your pipeline depends on fixing a seed to get a repeatable result, Flux 2 still offers that, and the two can live side by side in the same app.

Running Flux 3 Image on each::labs

Both models sit behind the same prediction endpoint as everything else in the text-to-image and image-to-image catalog. A text-to-image call looks like this:

curl -X POST \
  -H "Authorization: Bearer $EACHLABS_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{
    "model": "flux-3-text-to-image",
    "version": "0.0.1",
    "input": {
      "prompt": "Editorial photo of a ceramic coffee cup on a marble counter, a small card beside it printed with the words \"Slow Mornings\" in black serif type",
      "aspect_ratio": "4:5",
      "resolution": "1k",
      "grounding": false
    },
    "webhook_url": ""
  }' \
  https://api.eachlabs.ai/v1/prediction/

For edits, point model at flux-3-edit and add image_urls with one to ten references. Same auth, same response handling. You get a prediction ID back and poll it or take a webhook.

Because Flux 3 and Flux 2 share that request shape, comparing them on the same brief is a change of model string, not a new integration. And if a still is only the first frame of something bigger, the video variants live on the same Flux 3 family page, ready to chain in a flow. BFL's Flux 3 Image documentation is the reference for the full box format.

Frequently Asked Questions

What is Flux 3 Image and how is it different from Flux 3 Video?

Same model family, different output. Flux 3 was trained jointly on images, video and audio, and the image side ships as two models on each::labs: Text to Image and Edit. The video side generates clips with native sound. If you want stills you can lay out, edit element by element and combine from up to ten references, you want the image models.

Does Flux 3 Edit need a mask?

No, and it doesn't accept one. You target regions with bounding boxes written into the prompt, plus clear names for each element. Pixels outside the boxes typically stay unchanged, though shadows and reflections nearby can shift. For painted-mask inpainting, Flux Fill Pro is the model built for it.

What does grounding do in Flux 3?

It lets the model run a web and image search on your prompt before generating, so real places, objects and events come out closer to the real thing. It's on by default. Switch it off for invented subjects or when you want faster results that rely only on your prompt.

What resolution can Flux 3 generate?

Up to 4k, which is about 16 megapixels, with 768sq, 1k and 2k below it. The default is 1k. 4k renders can take several minutes, so explore small and rerun the keeper at the larger setting.