💻 computer science

Editing Everything Everywhere All at Once

This paper introduces MICE, a training-free strategy for Multimodal Diffusion Transformers that enables scalable, high-fidelity multi-instance image editing in a single forward pass by regulating attention mechanisms to prevent semantic interference and attribute leakage.

Original authors: Fabio Quattrini, Carmine Zaccagnino, Enis Simsar, Marta Tintoré Gazulla, Rita Cucchiara, Alessio Tonioni, Silvia Cascianelli

Published 2026-07-01

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Fabio Quattrini, Carmine Zaccagnino, Enis Simsar, Marta Tintoré Gazulla, Rita Cucchiara, Alessio Tonioni, Silvia Cascianelli

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a digital photo of a busy room, and you want to change almost everything in it at once: turn the coffee cup into a water bottle, swap the ceiling tiles for wooden beams, replace the whiteboard with a blackboard, and change the view outside the window to snowy mountains.

Doing this one thing at a time (changing the cup, then the ceiling, then the board) is slow and often leads to a messy result where the changes don't fit together well. But doing it all in one single "snap" is incredibly difficult for current AI. If you ask an AI to do everything at once, it often gets confused. It might accidentally paint the snowy mountains onto the coffee cup, or make the wooden beams look like they belong to the blackboard. This is called "attribute leakage"—the instructions bleed into each other.

The Problem: The "Crowded Room" Effect
Think of the AI's brain as a crowded room where everyone is shouting instructions. If you tell the room, "Change the cup" and "Change the ceiling" at the same time, the AI gets overwhelmed. It tries to listen to everyone, but the voices mix up. The "cup" instruction might accidentally grab the "ceiling" instruction, resulting in a cup that looks like a ceiling. As you add more changes, the confusion gets worse, and the final image looks chaotic.

The Solution: MICE (Multi-Instance Concurrent Editing)
The authors of this paper created a new method called MICE. Think of MICE as a super-efficient traffic controller for the AI's brain. Instead of letting everyone shout over each other, MICE gives each instruction its own "lane" while still letting them see the big picture.

Here is how it works, using simple analogies:

The Segmentation Masks (The Stencils):
First, the user (or a helper tool) draws outlines around the things they want to change. Imagine these are like stencils or cut-out shapes on a piece of paper. MICE uses these stencils to know exactly which part of the image belongs to which instruction.
The "Soft" Wall (The Gaussian Blur):
Old methods tried to build hard, concrete walls between these stencils. If you put a concrete wall between the cup and the ceiling, the result looks jagged and fake, like a bad collage.
MICE uses a soft, fuzzy wall instead. It creates a gentle gradient. The AI knows, "Okay, this part is definitely the cup, and that part is definitely the ceiling." But right where they meet, the wall gets fuzzy. This allows the cup to blend naturally into the table, and the ceiling to blend into the wall, without the instructions for the cup accidentally taking over the ceiling.
The "No-Go" Zones:
MICE also puts up invisible "Do Not Enter" signs. It tells the AI: "The instruction for the cup can talk to the cup, and it can talk to the nearby table to make sure they match. But it is strictly forbidden from talking to the instruction for the snowy mountains." This stops the "mountain" texture from accidentally leaking onto the "cup."
One Pass, One Go:
The magic of MICE is that it does all of this in a single forward pass. Imagine a painter who usually has to paint the cup, wait for it to dry, then paint the ceiling, then wait again. MICE is like a painter who can paint the cup, the ceiling, the window, and the rug all in one single, smooth brushstroke, with every part looking perfect and connected.

Why This Matters
The paper tested this on a new, very difficult challenge called MICE-Bench. While other tests only asked the AI to change 3 things at once, MICE-Bench asked it to change an average of 8.5 things in a single image (some had up to 40 changes!).

The results showed that MICE is much better at:

Listening: It actually changes the right object to the right thing (e.g., the cup becomes a bottle, not a dog).
Preserving: It leaves the parts you didn't ask to change exactly as they were.
Blending: The new objects look like they naturally belong in the photo, with correct lighting and shadows.

In Summary
MICE is a "training-free" tool (it doesn't need to be re-taught how to paint; it just changes how the AI pays attention). It acts like a smart organizer that keeps different editing instructions separate but harmonious, allowing you to edit a complex image with many changes in one go, without the AI getting confused or mixing up the details.

Technical Summary: MICE (Multi-Instance Concurrent Editing)

Problem Statement

While text-guided image editing has advanced significantly, editing multiple distinct elements within a single image remains challenging. Existing solutions typically rely on multi-turn pipelines, where edits are applied sequentially. This approach is inefficient, time-consuming, and prone to visual degradation (drift) as the number of iterations increases. Furthermore, the final output in sequential editing is often path-dependent, especially when editing overlapping regions.

Concurrent editing—performing all transformations in a single forward pass—offers a practical alternative for efficiency and better global harmonization. However, current single-pass methods struggle with semantic interference. When multiple instructions target different regions, their semantic signals often interfere, leading to attribute leakage (where an edit intended for one object affects another) and poor edit disentanglement. As the number of concurrent edits increases, maintaining spatial locality and global visual coherence becomes progressively more difficult.

Methodology: MICE

The authors propose MICE (Multi-Instance Concurrent Editing), a training-free, architecture-agnostic strategy designed for Multimodal Diffusion Transformers (MMDiTs) based on Flow Matching. MICE operates by modifying the additive bias of the joint attention mechanism to regulate interactions between instance-specific tokens without requiring gradient descent or architectural changes.

Core Mechanism: Smoothly-Disentangled Attention

Unlike prior methods that use hard binary masks (0 or $-\infty$ ) to strictly isolate or allow attention, MICE introduces a continuous, spatially-smoothed attention bias. This approach balances instance isolation with global harmonization.

Instance Identification: The method utilizes segmentation masks ( $M$ ) for each target instance, which can be user-provided or generated by a promptable segmentation model (e.g., SAM).
Instance-Aware Smoothing: To prevent interference between adjacent instances during smoothing, the authors apply a Gaussian kernel to each mask independently. Crucially, if a smoothed region of one instance overlaps with the strict bounds of another instance, the overlapping values are explicitly zeroed out. This ensures that the smoothing effect respects instance boundaries.
Bias Matrix Construction: The smoothed masks are mapped into log-probability space to form an additive bias matrix ( $B$ $B$ ) for the attention logits. The bias values are defined based on token types:
- Prompt Tokens: Strict binding is enforced between prompt tokens of the same instance to prevent attribute leakage within the textual domain.
- Global vs. Local: The global prompt and background tokens interact unbiasedly with all latent and context tokens to preserve global visual coherence.
- Instance-Specific Interactions: For tokens belonging to a specific instance (latent or context), the bias allows interaction with neighboring tokens with a decreasing negative bias proportional to the distance from the instance mask. This is controlled by a temperature hyperparameter ( $\tau$ ) and kernel size ( $k$ ).
- Suppression: Tokens from unrelated instances are prevented from attending to each other (bias set to $-\infty$ ), effectively suppressing cross-instance interference.

This strategy allows the edited instance to blend naturally with its surroundings (harmonization) while preventing its attributes from leaking into other edited regions (disentanglement).

Key Contributions

MICE Strategy: A novel, training-free method for scalable multi-instance editing that modifies joint attention biases in MMDiTs. It replaces rigid hard masking with a principled, parametric additive bias that enables soft transitions between isolation and harmonization.
Instance-Aware Smoothing: A specific technique to smooth segmentation masks without causing interference between neighboring instances, ensuring that the attention bias respects spatial boundaries.
MICE-Bench: The introduction of a new benchmark specifically designed to evaluate high-density concurrent editing. Unlike existing benchmarks (e.g., LoMOE-Bench) which average 3 edits per image, MICE-Bench contains 260 samples with an average of 8.5 concurrent edits (ranging from 5 to 40), providing a more rigorous test for scalability and disentanglement.
Comprehensive Evaluation: Extensive experiments demonstrating that MICE outperforms strong baselines (including MultiDiffusion, LoMOE, LayerEdit, and IDAttn) and recent state-of-the-art models (Qwen-Image-Edit, Gemini 3 Pro Image) in terms of instruction faithfulness, background preservation, and localized edit quality.

Experimental Results

The authors evaluated MICE on both LoMOE-Bench and the newly introduced MICE-Bench using various FLUX model backbones (4B, 9B, 32B).

Performance Metrics: The evaluation used Target CLIP Score (Tgt C), Localized CLIP Score (Loc C), Mean Absolute Error on Background (MAEB), and Attempt Rate (AR%).
Comparison with Baselines:
- On MICE-Bench, MICE achieved superior Localized CLIP Scores compared to multi-branch methods (MultiDiffusion, LoMOE) and regularization-based approaches (IDAttn).
- MICE demonstrated better background preservation (lower MAEB) and higher instruction faithfulness than end-to-end single-pass models like Qwen-Image-Edit and even the closed-source Gemini 3 Pro Image.
- The ablation study confirmed that the proposed instance-aware smoothing strategy outperforms naive Gaussian smoothing and strict segmentation masks, particularly in high-density scenarios where instance overlap is common.
Efficiency: MICE scales efficiently with the number of edits. Unlike multi-branch approaches (e.g., MultiDiffusion) which show linear increases in VRAM usage and inference time as the number of branches grows, MICE maintains a computational footprint similar to single-pass methods like IDAttn.

Significance and Claims

The paper claims that MICE addresses a fundamental limitation in current image editing paradigms: the trade-off between efficiency and the quality of multi-instance edits. By enforcing attribute binding through a principled attention bias rather than heuristic layer-specific tuning or computationally expensive gradient descent, MICE offers a portable and scalable solution.

The authors emphasize that their method:

Eliminates the need for training, making it immediately applicable to existing pre-trained MMDiT models.
Improves disentanglement in high-density editing scenarios where previous methods fail due to semantic interference.
Preserves global visual consistency while allowing for complex, localized transformations.

The work suggests that for practical, high-density image editing, end-to-end regularized approaches like MICE are necessary to overcome the scaling bottlenecks and numerical instabilities inherent in multi-branch or iterative optimization methods. The release of MICE-Bench is also highlighted as a significant step toward standardizing the evaluation of complex, multi-instance editing tasks.