You ask for one headline in an ad banner to be swapped out, and it comes back with the background and product shot you asked them not to touch subtly altered too. Anyone who uses today's image-editing AI knows the feeling. LayerEditor tackles this by folding "editing" and "layer decomposition" into a single model. It edits the image as instructed while, in the same pass, emitting RGBA layers (an RGB layer holding color and an Alpha layer holding transparency) that let you go back and rework each element on its own later. Let's start with why that matters.
The goal of image editing is simple: change only the region you were told to, and leave the rest alone. The trouble lies in the shape of what today's editing models hand back. A multimodal diffusion transformer (a generative model that strings the text instruction and the image into one sequence and paints them together from noise, hereafter MMDiT) produces a single flat image where text, objects, and background are all fused into one layer.
The pain of that format shows up immediately in real work. It's especially acute in jobs where you have to fine-tune every element and drop in assets the user supplied — e-commerce detail pages, ad design, and the like. Every time a change comes in like "make just this line red" or "nudge just this logo up a bit," you have to regenerate the entire image. That racks up processing cost, and regions that should have stayed put get changed by mistake or sprout artifacts along the edges. It's like being asked to pick the raisins out of an already-baked loaf and re-baking the whole loaf to do it.
So why not just split the flat result into layers afterward? That's exactly the route image decomposition research has taken. But there's a trap. The editing model focuses solely on producing a plausible result and pays no mind to layer structure, while the decomposition model only reconstructs layers after the edit is done, so it can't reconcile the requested edit with the target layer structure at the same time. As a result, an edit that looks fine to the eye turns out, when you pull it apart into layers, to have elements missing or wrongly grouped — hard to reuse.
Prior attempts fell into two broad camps. On one side are editing models like Qwen-Image and FireRed-Image-Edit, which follow instructions well and edit with high fidelity but output flat results. On the other are layer-generation and decomposition families — LayerDiff, PSDiffusion, LaDe, UniWorld-Design — along with decomposition models like Qwen-Image-Layered and LiWi, which build layers from text or spatial conditions or recover elements from a finished image. But the paper positions itself on the observation that neither side directly addresses "editing a flat source while jointly generating the edited layer stack." There are workflows like Agent Banana (Ye et al., 2026b) that bolt decomposition and editing together, but they share the same limitation of being split into stages.
LayerEditor binds editing and layer generation into one problem from the start.
The principle behind the first mechanism is "paint the whole picture and each layer together in one place." It lays the edited canvas and an ordered set of layers side by side in a single token sequence and generates them simultaneously. This way each output is painted while referencing the others' information, so the edited result and the layer stack don't drift apart.
The number of layers isn't fixed, either. If the user says "give me six layers, with this content in each," that many RGB-Alpha output pairs get produced. Figure 5 in the paper shows an example splitting rows of text and a bird across six layers. Transparency (Alpha) gets special attention. Preserving fine structures like strands of hair or semi-transparent edges requires a different kind of reconstruction than color, so there's a dedicated Alpha decoder.
Technical box — Token layout - Every output field starts from Gaussian noise and is denoised together within one sequence. The dependencies between the edited canvas and the layer stack are captured by shared attention. - To distinguish the several fields that share the same canvas coordinates, it uses layer-aware rotary coordinates. The source image tokens, the edited canvas, and each layer's RGB/Alpha are assigned different slot coordinates to encode a field's identity and its stacking order, while spatial correspondence is preserved. - The Alpha-only decoder is initialized from the pretrained RGB decoder but trained separately, preserving color-reconstruction ability while specializing solely in transparency recovery.
There's one problem. If you simply fine-tune (SFT) a pretrained editing model to also emit layers, its original editing skill dulls. In the ablation where this mechanism is removed (w/o C-EPD), the paper reports that text breaks, structure warps, and surrounding regions change unintentionally.
C-EPD (Compositional Edit-Prior Distillation) is a distillation strategy — teaching that transfers a large source model's ability into another model — that prevents this degradation. It freezes the original editing model as it is and keeps it as a "teacher," and the "student," which is also learning to produce layers, queries the teacher at the intermediate states it actually passes through. It's like a tutor advising you right there on the path you're walking.
The key is that the teacher looks at two things together. One is the edited canvas the student painted directly (Direct); the other is the image formed by actually compositing the layers the student predicted (Composite). Only when the teacher supervises the composited result too does the error introduced during layer compositing get reflected in training. Matching just the flat canvas can't catch the "looks fine but falls apart when pulled into layers" problem.
The mechanism of querying the teacher along the same trajectory itself follows DiffusionOPD. The purpose differs, though. Progressive distillation and consistency models cut sampling steps to speed things up; here, distillation is used to broaden a single-image output into a structured layer output while holding on to editing ability.
Technical box — C-EPD training - From the current noise state and the predicted velocity, the student estimates a local clean latent for each output field, reconstructs it with the frozen decoder, and then composites back-to-front over a white background using standard source-over. - The teacher receives the same Direct latent, the source image, and the edit instruction, and predicts the target. - Training objective = a term aligning the Direct velocity with the teacher + a term aligning the decoded composited image with the teacher's target. The gradient of the second term propagates through the student's decoding and alpha compositing all the way to the layer-prediction branch. - The whole thing trains the pretrained MMDiT with LoRA (rank-256, adapting via a small set of added weights rather than the full model). It warms up with flow-matching (training that matches the flow from noise to target), then trains with a combined objective that keeps flow matching while adding C-EPD teacher supervision.
For training and evaluation, the authors built their own dataset, LayerEditor-100K. It's 100,000 editing pairs drawn from Crello, PrismLayersPro, and ScaleEdit, where each example holds a source image, an edit instruction, an edit target, and an ordered full-canvas RGBA stack. The native designs in Crello and PrismLayersPro retain their original layer structure to form editing pairs (Route A), while the flat ScaleEdit pairs go through planning, decomposition, refinement, and quality filtering to obtain target layers (Route B). The composition is 48,329 text edits, 36,858 object edits, and 14,813 poster-level appearance edits. Text tasks cover moving, recoloring, replacing, and translating; object tasks cover adding, removing, moving, recoloring, and replacing.
There are two evaluation benchmarks: Crello-Testset (2,994 items) drawn from native designs, and ScaleEdit-Testset (1,000 items) with target layers recovered from flat editing pairs. Both are strictly separated from the training data, down to the source documents and their derived variants.
It's worth noting what the metrics measure. The authors evaluate layer-editing performance primarily on the re-composited image (Composite) — the logic being that the requested edit should survive even after the layers are composited back together. They look at similarity to the edit target via SSIM (how structurally similar) and FID (how close the generated distribution is to the real one) for Direct (the canvas generated directly) and Composite, with Direct serving as an auxiliary diagnostic. At the layer level, they measure agreement via RGBA L1 (pixel-value difference from the reference layer) and Alpha IoU (how much overlap with the reference layer's transparency region). On top of that, there's a 5-dimension rubric scored 1–10 by a VLM (edit consistency, visual quality, layer segmentation, layer composition, and Alpha accuracy).
The comparison set spans both editing and decomposition. They ran ByteDance's Seedream5-Pro via the official API under two settings (Seq., which chains decomposition after editing, and Joint, which requests both in one call), plus a cascade of FireRed-Image-Edit-1.1 (FR) followed by the Qwen-Image-Layered (QIL) family, QIL-Decomp-FT, QIL-Edit-SFT, RevealLayer, and the pure-decomposition LayerD. LayerEditor itself was initialized from FireRed-Image-Edit-1.1.
Start with the most telling question. If you decompose an edited picture into layers and composite it back, how much of the quality against ground truth is retained? Comparing how close the directly generated canvas and the re-composited image each are to the ground truth, to read the loss introduced by going through layers — that's the heart of the effect this paper was after.
On ScaleEdit-Testset, Seedream5-Pro (Seq.) scores Direct SSIM 0.8933 and Composite SSIM 0.7901 — the re-composited output's SSIM against ground truth is about 11.6% lower than the direct output's. It means the edit was done well, but decomposing into layers and compositing back moves it away from the ground truth. LayerEditor, by contrast, scores 0.8925 for the direct output and 0.8839 for the re-composited output — the re-composited output's SSIM against ground truth is only about 1.0% lower than the direct output's. That is, even after decomposing into layers and compositing back, the quality loss against ground truth is small, and this number is the result they were trying to get by binding editing and layer generation into one problem.
The rest of the results are compressed into the table below. The question each group answers is left after the table.
| Group | Metric (benchmark) | LayerEditor | Comparison baseline |
|---|---|---|---|
| Edit quality | Composite SSIM (Crello) | 0.8351 | +5.7% vs. Seedream5-Pro (Joint) |
| Composite FID (Crello) | 33.86 | −38.8% vs. Seedream5-Pro (Joint) | |
| Composite SSIM (ScaleEdit) | 0.8839 | Seedream5-Pro (Joint) 0.8365 | |
| VLM rubric 5-dim avg (Crello) | 6.00 | Seedream5-Pro (Joint) 4.50 | |
| Layer quality | Alpha IoU (Crello) | 0.6074 | — |
| Alpha IoU (ScaleEdit) | 0.6802 | Seedream5-Pro (Joint) 0.6583 | |
| Count control | Alpha IoU (Table 2, 3,994 items) | 0.6196 | Seedream5-Pro (Joint) +0.0493 |
| Semantic grouping | 6.88 | Seedream5-Pro (Joint) +0.97 | |
| Decomposition transfer (I2L) | Composite SSIM | 0.8761 | QIL 0.7963 |
| Alpha IoU | 0.6343 | — | |
| Layer semantics score | 6.39 | Beats QIL and QIL-Decomp-FT |
Edit quality answers "did adding layers make the editing itself worse?" In the rubric average of 6.00 vs. 4.50, the layer-segmentation score in particular is 1.61 points higher than Seedream5-Pro (Joint), and the layer-composition score is 1.29 points higher than FR+QIL-Decomp-FT. Count control looks at "can you re-organize the same edit at the layer granularity the user wants?" Here the observed per-sample latency was 41.5 seconds, the lowest in the table — but the caveat on that number should be read together with the limitations below. Decomposition transfer (I2L) asks "is a model trained for editing also useful for pure decomposition?" Without any I2L-specific fine-tuning, LayerEditor scored Composite SSIM 0.8761 on a held-out 1,171-image benchmark built from the original Crello test split, ahead of QIL's 0.7963. It's a sign that a structure trained to learn editing and layer generation together in one sequence came to embody decomposition ability as well.
This piece has one central question. Even if the composited picture is good, is each individual layer really nice to rework?
Start with what the paper acknowledges. With layer SFT alone and no C-EPD, you get broken text, distorted structure, and altered surrounding regions. Put another way, this framework's editing quality leans heavily on C-EPD. The paper also explicitly states that the local clean latent estimate in the compositing process is an "approximation," not an exact value.
What hasn't been confirmed yet. The central metrics, Composite SSIM/FID, measure "how closely it resembles the target image" — not directly whether the picture is still usable when a specific layer is hidden, moved, or enlarged. In other words, "the composited result is good" and "each individual layer is nice to reuse" are different questions, and the paper's evaluation mostly looks at the former. Whether hiding, moving, or scaling just one layer leaves the rest undisturbed needs follow-up verification.
Clues in the evaluation conditions. Whether layers were split according to the designer's intent is reinforced by the rubric, but since it's VLM-scored there's room for the scoring model's bias to seep in. Many of the comparisons are results from Seedream5-Pro's official API, and API models can vary due to internal factors, so it's not a fully like-for-like comparison. Indeed, platform constraints meant 5 items in Crello-Testset yielded no usable output, and those metrics were computed excluding those cases. The table's latency (Time) is also "per-sample latency observed without controlled hardware," so it must not be read as an absolute speed comparison.
The ceiling of the dataset. The ScaleEdit target layers were produced through planning, decomposition, refinement, and filtering, which means the training and evaluation standard is ultimately a "ground truth" produced by another decomposition process. The quality of that ground truth itself becomes the ceiling.
If ONTLE were deciding whether to bring this technology into actual asset production, we'd measure the following three things directly on our own assets — not on the benchmark numbers.
That's why the AI PM's role remains. What changes is that the unit of judgment drops from "one image" to "a bundle of layers."
If you're considering adoption, do the following yourself.
Element-by-element independent editing becomes possible. A request to "just make the discount number bigger" only needs the number layer swapped, leaving the background and product-shot layers alone. Unlike regenerating an entire image from scratch, there's less room for untouched regions to get shaken up. That said, whether the layers were actually split that cleanly has to be checked once you receive them.