MAGREF: Masked Guidance for Any-Reference Video Generation with Subject Disentanglement

ArXiv: 2505.23742

🎯 Pitch

MAGREF achieves coherent multi-subject video generation from arbitrary reference images without any architectural changes to the pretrained diffusion backbone. By injecting region-masked reference features along the pixel-wise channel dimension and explicitly binding each subject’s text semantics to its visual mask, it prevents identities from blending together—a persistent failure mode in existing methods. This design directly eliminates copy-paste artifacts and subject confusion, letting you mix people, animals, clothing, and environments in a single generated video.

---

1. Executive Summary

This paper introduces MAGREF (Masked Guidance for Any-Reference Video Generation with Subject Disentanglement), a framework for synthesizing videos conditioned on arbitrary combinations of reference subjects and text prompts. The system is evaluated against a benchmark of 120 reference-text pairs drawn from ConsisID, OpenS2V, and A2-Bench, using the Wan2.1 video diffusion backbone. MAGREF's core mechanisms are masked guidance — a region-aware masking scheme with pixel-wise channel concatenation that injects reference features at the channel level without architectural changes to the pretrained model — and a subject disentanglement mechanism that explicitly binds text-condition semantic embeddings to their corresponding masked visual regions to prevent cross-subject confusion. A complementary four-stage data pipeline with cross-pair augmentation suppresses copy-paste artifacts. The approach achieves state-of-the-art Total Score on both single-ID and multi-subject evaluation, with the user study showing significant preference over existing commercial and open-source models. The framework establishes that pixel-aligned reference injection combined with region-grounded semantic binding enables coherent multi-subject video generation, though performance degrades on complex subject interactions and large-scale motions where the base model's physical understanding is insufficient.

2. Context and Motivation

The Core Problem: Generating Videos from Arbitrary Visual References

The fundamental challenge this paper addresses is any-reference video generation: synthesizing a coherent video conditioned on an arbitrary mix of reference images (humans, animals, clothing, accessories, environments) together with a text prompt. This is distinct from simpler settings like single-identity preservation or text-only generation. The "any-reference" qualifier means the system must handle an unknown number of subjects — potentially of different semantic types — and faithfully render them interacting in a plausible scene without prior knowledge of which combinations will appear at test time.

To grasp why this is hard, consider the difference between these tasks:

• Single-ID generation (e.g., ConsisID, FantasyID): The model sees one face reference and must keep that person's identity consistent across frames. The conditioning is narrow — one subject, one type.
• Text-to-video (e.g., Sora, Wan2.1): The model generates everything from a prompt. No reference images constrain appearance, so there is no identity-consistency problem to solve.
• Any-reference generation (this paper's target): The model receives 1–3 reference images that could be two different people, a person and a dog, a person and a specific jacket, a background scene, or all of these simultaneously. It must (a) identify which reference corresponds to which noun in the prompt, (b) preserve each subject's fine-grained appearance, and (c) compose them into a temporally coherent video where they interact naturally.

This is a combinatorial conditioning problem. The condition space explodes because any subject type can be paired with any other, and the number of references is variable. A system that works for "one face reference" may fail catastrophically when asked to render "Person A wearing Jacket B standing in Environment C" — not because any individual component is harder, but because the interactions between conditions create new failure modes.

Why This Problem Matters

The paper articulates the importance of any-reference generation in its opening paragraph (Section 1), and the motivation can be unpacked along three dimensions:

Practical demand for controllable synthesis. There is a growing market need for tools that let users specify exactly what appears in a generated video, rather than relying on text descriptions alone. Text prompts are fundamentally lossy for appearance — "a woman in a red jacket" underspecifies facial identity, jacket style, lighting, and background. Reference images fill this gap by providing pixel-level appearance constraints. Any-reference generation is the natural endpoint of this trend: users want to drop in reference photos of themselves, their pet, a specific product, and a location, then generate a video that composites them correctly. This is directly visible in commercial products cited by the paper: Kling's "multi-ID" feature, Pika's "scene ingredients," and Vidu's "reference to video" all represent partial steps toward this capability (Section 2, Related Work). MAGREF aims to unify these capabilities into one framework.

Technical significance for generative modeling. From a research perspective, any-reference video generation stress-tests the fundamental challenge of conditional generation with compositional constraints. The model must learn to disentangle conditions in a shared latent space — a problem that connects to broader questions in machine learning about binding, systematic generalization, and compositional reasoning. If a model can successfully render "Person A wearing Jacket B in Environment C" after seeing only separate examples of Person A, Jacket B, and Environment C during training, it has demonstrated a form of out-of-distribution compositional generalization. This makes the any-reference setting a valuable probe for understanding the limits of diffusion-based architectures.

Scalability requirements. Unlike tuning-based personalization methods (DreamBooth, LoRA), which require per-identity fine-tuning and are therefore impractical at scale, a feed-forward any-reference system processes arbitrary references in a single forward pass. This is crucial for deployment in user-facing applications where references change with every query and retraining is infeasible. The paper explicitly contrasts its approach with tuning-based methods (Section 2, Subject-driven visual generation), positioning MAGREF as a training-free inference solution after the initial training phase.

Where Prior Approaches Fall Short

The paper identifies three persistent failure modes in existing any-reference video generation systems (Section 1, paragraph 2). These are not merely quantitative weaknesses — they represent qualitatively distinct problems that require different mechanisms to address:

1. Identity inconsistency. When a reference subject's appearance drifts across frames — facial structure changes, accessories disappear, clothing texture warps — the video loses the core value proposition of reference-based generation: that the output should look like the specific subject provided. Prior methods show progress on single-ID preservation (ConsisID uses frequency decomposition; EchoVideo uses multimodal feature fusion), but these approaches are designed for exactly one face reference. Extending them to multiple subjects or non-face references (clothing, objects) is architecturally non-trivial because the identity-preservation modules are specialized to facial features. The paper highlights that methods relying on token-wise concatenation (Concat-ID, VACE, Phantom) "struggle with identity preservation and generalization" (Section 1) because identity information is scattered across the token sequence and must be recovered through self-attention — an indirect and lossy process.

2. Entanglement across multiple reference subjects. This is perhaps the most distinctive challenge of the any-reference setting, and the one where prior work is weakest. When two-person or human-object references are provided, existing models may blend facial features (Person A's eyes appear on Person B), swap attributes (the jacket from Reference 2 appears on the person from Reference 1), or fail to associate the correct reference with the correct noun in the prompt. The root cause is a binding problem: the model receives visual features from multiple references and semantic concepts from the text prompt, but has no explicit mechanism to link "this visual region corresponds to this text token." Methods that inject references as additional tokens (Phantom, HunyuanCustom) rely entirely on cross-attention to learn these bindings implicitly, which the paper argues is insufficient — especially when references outnumber training-time examples or when subjects are visually similar (e.g., two people in similar clothing). The paper explicitly frames this as the model needing "much stronger coupling between reference images and textual conditions" (Section 3.2), a requirement that prior architectures do not directly enforce.

3. Copy-paste artifacts. Videos where reference subjects appear "pasted" onto the scene — with inconsistent lighting, unnatural boundaries, static poses that match the reference image exactly — degrade visual realism. The paper attributes this to the training data construction: if the model always sees references paired with the exact same backgrounds or poses during training, it learns a trivial mapping rather than learning to compose subjects into novel contexts. Prior data pipelines do not systematically break this spurious correlation between foreground subjects and their original backgrounds. The paper identifies this as a problem of data diversity rather than architecture — the model itself is capable of generating realistic compositions, but the training signal reinforces copy-paste shortcuts.

How Existing Methods Attempt (and Fail) to Solve These Problems

The Related Work section (Section 2) categorizes prior approaches, and it is important to understand why each category falls short for the any-reference setting specifically:

Tuning-based personalization (DreamBooth, LoRA, Sugar). These methods fine-tune model weights for each new identity, embedding appearance information into the diffusion model's parameters. The limitation for any-reference generation is practical, not conceptual: re-tuning for every new subject combination is computationally prohibitive at scale, and the process must be repeated if the user wants to swap out one reference while keeping others. The paper acknowledges these methods' effectiveness for single-subject quality but notes they "require re-tuning for each new identity, limiting scalability" (Section 2). This makes them unsuitable for the feed-forward, any-reference use case.

Token-concatenation approaches (Concat-ID, VACE, Phantom, HunyuanCustom). These methods encode reference images into visual tokens and prepend or interleave them with the video latent tokens before the transformer backbone. The advantage is architectural simplicity — no new modules needed. The disadvantage, which the paper argues is fundamental, is that identity information is diluted across the token sequence. Self-attention must discover which tokens correspond to which subjects, a task that becomes exponentially harder as the number of subjects grows. The paper's ablation (Figure 7, right; Appendix D.1) directly compares token-wise and pixel-wise concatenation, showing that token-wise methods produce "blurred facial features, unstable textures, or even identity drift."

Channel-concatenation approaches (SkyReels-A2). SkyReels-A2 concatenates reference images along the channel dimension with temporal masks, which comes closer to MAGREF's design. However, the paper argues this method "still falls short in addressing the above challenges in a unified and effective manner" (Section 1). The key difference is the masking strategy: SkyReels-A2 uses a coarser, uniform concatenation that does not spatialize reference information with explicit region masks. The paper's ablation (Figure 7, left; Table 3) shows that this "vanilla masking" causes "frame-level inconsistencies and identity drift" because it ignores spatial locality and creates "channel-level entanglement."

MLLM-based approaches (Cinema). Some recent work incorporates multimodal LLMs (Qwen2-VL, LLaVA) to improve prompt-reference interaction. While promising, these add architectural complexity and inference cost. The paper cites Cinema (which includes several of the paper's authors) as a complementary direction, not a competing solution.

Specialized face-preservation models (ConsisID, EchoVideo, FantasyID). These focus exclusively on human faces, using frequency decomposition or dedicated face modules. They do not generalize to non-face subjects (clothing, objects, animals) or multi-subject scenarios, making them inapplicable to the any-reference setting. The paper evaluates them on the single-ID subset of its benchmark to provide baselines, but they cannot be compared on multi-subject tasks.

How MAGREF Positions Itself

MAGREF's conceptual positioning (Section 1, paragraph 3) can be understood as combining and refining ideas from two existing paradigms while introducing a novel binding mechanism:

From channel concatenation (SkyReels-A2): MAGREF adopts the idea of injecting references at the pixel/channel level rather than the token level, preserving fine-grained spatial information. The key refinement is the region-aware masking mechanism (Section 3.1) that explicitly encodes which spatial regions correspond to which subjects through a binary mask, rather than treating the concatenated reference as an undifferentiated feature map. This mask is downsampled to match the VAE latent resolution and replicated along the channel dimension, providing a "spatial prior of each subject in the reference frame" (Section 3.1, Region-aware masking mechanism).

From token concatenation (Concat-ID, Phantom): The idea of injecting reference information that interacts with text conditions through cross-attention is retained, but the form of injection is changed. Instead of adding reference tokens to the sequence, MAGREF keeps references in pixel-aligned channels where identity features remain spatially grounded. The cross-attention layers still process text, but the visual reference information arrives through a separate, geometrically meaningful pathway.

The novel contribution — Subject Disentanglement (Section 3.2): This is where MAGREF goes beyond simply improving the reference injection mechanism. The insight is that even with spatially grounded reference features, the model may still confuse which reference corresponds to which text noun. Subject Disentanglement explicitly addresses this by:

1. Parsing the text prompt to extract noun labels corresponding to reference subjects (e.g., "man," "woman," "dog").
2. Extracting the value embeddings of these nouns from the cross-attention layers.
3. Constructing individual masks for each subject's region.
4. Injecting each subject's text-derived semantic embedding directly into its corresponding visual region in the latent representation, using element-wise multiplication with the region mask and broadcasting.

This creates an explicit, hard binding between "the region where Subject A appears" and "the semantic concept of Subject A from the text." The paper visualizes the effect in Figure 4, showing cosine similarity between reference regions and text labels — with Subject Disentanglement, the "Man" label strongly activates in the man's region and the "Woman" label in the woman's region; without it, the associations are "entangled and ambiguous."

The paper frames this as solving the binding problem that implicit attention-based methods fail at: rather than hoping cross-attention learns to route visual information correctly, MAGREF enforces the routing directly.

The data pipeline as infrastructure: The four-stage data curation pipeline (Section 3.3, detailed in Appendix B) is positioned not as a methodological innovation per se, but as the necessary infrastructure to make the architectural mechanisms work. The key insight is that copy-paste artifacts are a data problem, not (primarily) an architecture problem: if the training data always pairs a specific object with its original background, the model learns a shortcut rather than compositional generation. The cross-pair augmentation in Stage 4 explicitly breaks this correlation by generating variant references with altered poses, appearances, and contexts using an external image generation model. This forces the model to learn genuine composition rather than memorization.

A note on the backbone choice: MAGREF builds on Wan2.1, an image-to-video (I2V) diffusion model using flow matching rather than DDPM. The paper chooses an I2V backbone (rather than T2V) because the region-aware masking mechanism treats the composite reference image as a "first frame" — this is architecturally natural for I2V models, which are designed to condition on an initial frame and generate subsequent frames. The paper's ablation (Table 3, top row) confirms that starting from a T2V backbone significantly degrades identity and subject consistency compared to starting from I2V, validating this design choice.

Positioning Relative to the Training-Inference Tradeoff

An important implicit positioning in this paper — which connects to broader trends in generative AI — is the emphasis on feed-forward, training-free inference. Unlike DreamBooth or LoRA-based methods that invest computation per-identity at inference time, MAGREF processes arbitrary references in a single forward pass after a one-time training phase. This is the inference-time analog of the "amortized inference" concept: pay a large upfront training cost to enable cheap, flexible inference. The paper does not frame it this way explicitly, but the approach aligns with the industrial trend toward generalist models that handle diverse inputs without per-example tuning — the same philosophy behind instruction-tuned LLMs or zero-shot classifiers.

The tradeoff is that MAGREF requires a carefully constructed training dataset (the four-stage pipeline) and a specific architectural design (region-aware masking, subject disentanglement) to achieve this flexibility. The paper's ablation studies (Tables 3, 4) quantify what each component contributes, making explicit that the gains come from deliberate engineering choices rather than simply scaling up a generic architecture.

3. Technical Approach

3.1 Reader Orientation

MAGREF is a feed-forward video generation system that takes a handful of reference images (faces, clothing, objects, animals, backgrounds) and a text description, then produces a temporally coherent video in which all referenced subjects appear with their identities preserved and interact according to the prompt. The system solves a combinatorial binding problem: given an unknown mix of reference types and a text prompt, it must determine which visual features belong to which words in the prompt, inject those features into the right spatial regions of the generated video, and prevent the features from bleeding across subjects — all without architectural changes to the underlying video diffusion model and without per-identity fine-tuning at inference time.

3.2 Big-Picture Architecture (Diagram in Words)

The MAGREF system has five major interacting components:

1. VAE Encoder — a pretrained variational autoencoder that compresses raw video frames and reference images into a compact latent space for efficient processing by the diffusion backbone.

2. Region-Aware Masking Module — given N reference images, this module (a) arranges them on a shared canvas at distinct spatial positions to form a composite image, (b) constructs a binary mask indicating which pixels belong to which reference subject, and (c) passes both through the VAE encoder to produce spatially grounded latent features and a downsampled region mask.

3. Pixel-Wise Channel Concatenation Module — takes the noised video latents (from the current diffusion step), the VAE-encoded composite reference features, and the downsampled region mask, and concatenates them along the channel dimension to form the input tensor for the diffusion transformer. This preserves pixel-level correspondence between reference appearance and generated content.

4. Subject Disentanglement Module — parses the text prompt to extract noun tokens corresponding to reference subjects, retrieves their value embeddings from the cross-attention layers, and injects each embedding directly into its corresponding masked spatial region in the first-frame latent representation. This creates an explicit, hard-coded binding between text semantics and visual regions.

5. Four-Stage Data Pipeline — an offline preprocessing system that (Stage 1) segments and captions raw videos, (Stage 2) extracts and segments objects, (Stage 3) detects and ranks faces, and (Stage 4) generates augmented variant references using an external image generation model to break spurious foreground-background correlations. This pipeline produces the diverse training pairs needed to suppress copy-paste artifacts.

Information flow at inference: reference images → Region-Aware Masking (composite image + binary mask) → VAE encoding (latent features + region mask) → Channel Concatenation with noised video latents → diffusion transformer backbone (with Subject Disentanglement injecting text semantics into first-frame latent) → iterative denoising → VAE decoding → output video.

3.3 Roadmap for the Deep Dive

• First, the mathematical framework: flow matching on video latents, which establishes the training objective and the role of conditioning signals — this is the foundation everything else plugs into.
• Second, the region-aware masking mechanism and pixel-wise channel concatenation, because these determine how reference information physically enters the model and why the channel-level injection preserves identity features that token-level methods lose.
• Third, the subject disentanglement mechanism, because it solves the residual binding problem that remains even after spatialized reference injection — this is the most architecturally novel component.
• Fourth, the four-stage data curation pipeline, because it produces the training data that makes the architectural mechanisms actually learn compositional generation rather than copy-paste shortcuts.
• Fifth, training configuration and inference procedure, tying together the loss function, optimizer settings, and how the trained model is used at test time.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily an architectural design paper whose core idea is that any-reference video generation requires three coordinated mechanisms — spatially grounded reference injection (masked guidance), explicit text-to-region binding (subject disentanglement), and diversity-augmented training data (cross-pair pipeline) — and that each mechanism addresses a qualitatively distinct failure mode of prior approaches.

---

Flow Matching on Video Latents (Training Objective Foundation)

MAGREF builds on the Wan2.1 video diffusion model, which uses flow matching rather than denoising diffusion probabilistic models (DDPM). Understanding this foundation is important because the masked guidance and subject disentanglement mechanisms operate on the latent representations produced by this framework.

Flow matching formulation. Unlike DDPM, which defines a stochastic forward process (gradually adding Gaussian noise) and learns to reverse it, flow matching defines a deterministic trajectory between a noise distribution and the data distribution. Given a clean video x₁ ∈ ℝ^{T×C×H×W} and a noise sample x₀ ∼ 𝒩(0, I), the interpolated state at time t ∈ [0, 1] is:

$x_t = t x_1 + (1 - t) x_0$

where x_t is the intermediate representation at time t, x_1 is the clean video, and x_0 is pure Gaussian noise.

What it computes: a linear interpolation between noise and data. At t = 0, x_t is pure noise; at t = 1, x_t is the clean video; at intermediate t, x_t is a blurred mixture. This is simpler than DDPM's stochastic differential equation and gives a straight-line path through latent space rather than a curved one.

Why this form: the linear interpolation ensures that the velocity field (derivative with respect to t) is constant and equal to x_1 − x_0 everywhere along the trajectory. This constant velocity property makes the learning problem easier — the model only needs to predict a single direction vector per (x_t, t) pair rather than a time-varying score function. Flow matching has been shown to require fewer sampling steps than DDPM for equivalent quality, which matters for video generation where each forward pass is expensive.

Velocity field. The dynamics of the trajectory are governed by its velocity, obtained by differentiating with respect to t:

$v_t = \frac{dx_t}{dt} = x_1 - x_0$

where v_t is the true velocity (the direction and magnitude of change) at time t.

What it computes: the constant vector pointing from the noise sample x_0 to the clean video x_1. This is the target the model must predict.

Why this form: because the interpolation is linear, the derivative is constant — there's no acceleration or curvature term. This means the model's prediction target is the same at every t, which stabilizes training compared to DDPM where the score function changes shape as t varies.

Training objective. The model, parameterized by θ, learns to approximate the true velocity with a predictor u(x_t, y, t; θ), where y represents all conditioning signals (text embeddings, reference features, masks). The loss function is:

$\mathcal{L}(\theta) = \mathbb{E}_{x_1, x_0 \sim \mathcal{N}(0,I), y, t \in [0,1]} \left[ \| u(x_t, y, t; \theta) - v_t \|_2^2 \right]$

where u(x_t, y, t; θ) is the model's predicted velocity, v_t = x_1 − x_0 is the ground-truth velocity, and ‖·‖₂² is the squared Euclidean norm.

What it computes: the expected squared L2 distance between the model's predicted velocity and the true velocity, averaged over random noise samples, data samples, conditioning signals, and time steps. At each training step, a random t is sampled, x_t is constructed via linear interpolation, the model predicts u(x_t, y, t; θ), and the loss pushes this prediction toward x_1 − x_0.

Why this form: the L2 loss on velocities is the natural objective for flow matching because the velocity field uniquely determines the trajectory. Unlike DDPM's noise prediction or score matching objectives, this directly supervises the quantity needed at inference time. The expectation over t ∈ [0, 1] ensures the model learns the velocity at all points along the trajectory, not just near the data or near the noise.

VAE latent compression. To reduce the computational burden of operating on raw video pixels (which for high-resolution video would require terabytes of memory), the paper uses a pretrained variational autoencoder (VAE) to compress video data before applying flow matching. Raw video sequences X ∈ ℝ^{F×C×H×W} (frames, channels, height, width) are mapped to a compact latent representation z_x ∈ ℝ^{f×c×h×w}, where f < F, c < C, h < H, and w < W. The flow matching process then operates entirely in this compressed latent space — noise is added to latents, the model predicts velocity in latent space, and the VAE decoder reconstructs pixels from the denoised latents at the end.

What this means for MAGREF's design: all the reference injection and subject disentanglement operations happen in VAE latent space, not pixel space. The VAE encoder processes the composite reference image and the video frames separately, producing latent features that are concatenated along the channel dimension. This is a critical detail: the masked guidance mechanism works because the VAE preserves spatial structure (unlike tokenizers that discretize into a codebook), so pixel-level correspondences between reference regions and generated regions are maintained in latent space.

---

Masked Guidance: Region-Aware Masking and Pixel-Wise Channel Concatenation

This is the first of MAGREF's two core architectural mechanisms (Figure 3). It addresses the problem of how to inject multiple reference images into the diffusion model so that (a) fine-grained appearance details are preserved, (b) the model knows which spatial regions correspond to which reference, and (c) the pretrained backbone's capabilities are not disrupted.

The design follows a three-step pipeline: compose → encode → concatenate.

Step 1: Composite image construction (Equation 1). Given N reference images {I_k}ₖ₌₁ᴺ, all images are placed onto a blank canvas at distinct, non-overlapping spatial locations {p_k = (x_k, y_k)}ₖ₌₁ᴺ. Formally:

$I_{\text{comp}}(i,j) = \sum_{k=1}^{N} I_k(i-y_k, j-x_k) \cdot \mathbb{1}_{(i,j) \in R_k}$

where I_comp(i, j) is the pixel value at canvas position (i, j), I_k is the k-th reference image, (x_k, y_k) is the top-left corner where reference k is placed on the canvas, R_k is the rectangular region occupied by reference k, and 𝟙_{(i,j)∈R_k} is an indicator that equals 1 when pixel (i, j) falls within region R_k and 0 otherwise.

What it computes: a single composite image where each reference occupies a distinct rectangular sub-region, like arranging photos on a grid or collage. The summation with indicators means each pixel's value comes from exactly one reference image — the one whose region contains that pixel. Pixels outside all regions remain blank (zero).

Why this form: treating the multi-reference input as a single composite "first frame" is architecturally natural for image-to-video (I2V) models, which are designed to condition on one initial frame and generate subsequent frames. This lets MAGREF inherit the I2V backbone's native conditioning capability without structural changes. The non-overlapping placement ensures no reference pixels overwrite each other. The random spatial shuffling of subject locations during training (mentioned in the paper) prevents the model from learning positional shortcuts — e.g., always expecting the first person on the left — and forces it to rely on the region masks for subject identification.

Step 2: Binary mask construction (Equation 2). In parallel with the composite image, a binary mask is constructed to indicate which pixels belong to reference subjects:

$M(i,j) = \mathbb{1}_{(i,j) \in \bigcup_{k=1}^{K} R_k}$

where M(i, j) is 1 if pixel (i, j) falls inside any reference subject's region and 0 otherwise.

What it computes: a single-channel binary image of the same spatial dimensions as the composite image, where white pixels (value 1) mark regions that contain reference subjects and black pixels (value 0) mark blank canvas areas.

Why this form: this mask provides an explicit "prior" telling the model which spatial locations in the composite image carry meaningful reference information. Without it, the model would need to learn to distinguish reference regions from blank canvas through the visual features alone — a harder problem that wastes model capacity. At the channel concatenation stage, this mask gets downsampled and replicated across channels, serving as a gating mechanism that tells subsequent layers "pay attention to features from these positions."

Step 3: VAE encoding and temporal padding. The composite image I_comp ∈ ℝ^{1×C_in×H×W} has only one frame (it is a still image), but the video diffusion backbone expects T frames. To align dimensions, the composite is padded with zeros along the temporal axis:

$\tilde{I}_{\text{comp}} \in \mathbb{R}^{T \times C_{in} \times H \times W}$

This zero-padded tensor is processed by the VAE encoder E(·) to obtain latent features:

$F_{\text{comp}} = E(\tilde{I}_{\text{comp}}) \in \mathbb{R}^{T \times C \times H \times W}$

where T is the number of frames, C is the latent channel dimension, and H, W are the latent spatial dimensions (reduced from pixel space by the VAE's downsampling factor).

Simultaneously, the binary mask M is downsampled to match the VAE latent spatial resolution and replicated along the channel dimension:

$M_{\text{region}} \in \mathbb{R}^{T \times C_m \times H \times W}$

where C_m is the number of mask channels (typically 1, replicated).

What this computes: latent-space representations of (a) the composite reference image with its fine-grained appearance features, and (b) a spatial prior indicating which latent positions carry reference information. The temporal zero-padding makes the single reference frame compatible with multi-frame video processing — the reference information is repeated (or rather, present at frame 0 and zero for subsequent frames in the padded input, but the VAE's temporal processing still produces a T-frame latent output). The downsampling of the mask ensures it aligns spatially with the latent features, so each latent "pixel" has a corresponding mask value.

Why this form: encoding the composite image with the pretrained VAE (rather than a new encoder) means the reference features live in the same latent space as the video frames — they are directly comparable and concatenatable. The temporal padding trick preserves the VAE's expected input shape without requiring architectural changes. The mask provides explicit spatial metadata that complements the appearance features: the model sees not just what the reference looks like, but where each reference is located in the composite, enabling it to route identity information correctly.

Step 4: Channel-wise concatenation (Equation 4). The raw video frames are separately encoded by the VAE, and Gaussian noise is added to produce the noised latents Z ∈ ℝ^{T×C×H×W} (standard diffusion/flow-matching forward process). The final input to the diffusion transformer is formed by concatenating three tensors along the channel dimension:

$F_{\text{input}} = \text{Concat}\big(Z, F_{\text{comp}}, M_{\text{region}}\big) \in \mathbb{R}^{T \times (2C + C_m) \times H \times W}$

where Concat denotes channel-wise concatenation, Z is the noised video latents (C channels), F_comp is the VAE-encoded composite reference features (C channels), and M_region is the downsampled region mask (C_m channels, typically C_m = 1).

What it computes: a single tensor with 2C + C_m channels per spatial position, where the first C channels are the noisy video being denoised, the next C channels are the reference appearance features, and the final C_m channels mark which positions contain reference information. This tensor is the input to the first layer of the diffusion transformer.

Why this form — the critical design choice: this is where MAGREF diverges fundamentally from token-concatenation approaches. By concatenating along the channel dimension rather than the token dimension:

1. Spatial alignment is preserved. Each (h, w) position in the video latent is concatenated with the reference features and mask at the corresponding (h, w) position. If a reference subject's nose is at position (h₁, w₁) in the composite reference features, and the generated person's nose should be at (h₁, w₁) in the video latent (after alignment), the features are directly adjacent in the channel stack. The model's first convolutional or linear projection layer can immediately combine them without needing self-attention to discover the correspondence.

2. No sequence length increase. Token concatenation adds N × (patches per reference) tokens to the transformer input, increasing the quadratic self-attention cost and diluting attention across irrelevant tokens. Channel concatenation keeps the sequence length unchanged — the transformer processes the same number of spatial tokens, each with richer per-position features.

3. The pretrained backbone's weights are preserved in spirit. Because the input shape change is only in the channel dimension, the input projection layer's weight matrix needs to be expanded (from C input channels to 2C + C_m), but all subsequent layers — self-attention, cross-attention, feed-forward — have unchanged dimensions. The model retains its pretrained video generation capabilities while learning to incorporate the additional reference channels. The paper states this design "preserves identity consistency and maintains the capabilities of the pre-trained backbone, without requiring any architectural changes" (Section 1, bullet 1) — the only change is the first-layer input projection dimensionality.

4. The mask serves as a gating/attention mechanism. Having the region mask concatenated as separate channels means the model can learn to modulate its processing based on whether a spatial position contains reference information or blank canvas — effectively learning to attend more strongly to reference regions.

Comparison with alternatives (Appendix D.1, Figure 7). The paper provides ablation evidence for this design:

• Token-wise concatenation (Phantom, HunyuanCustom): references are encoded as additional tokens in the transformer sequence. The model relies on self-attention to propagate identity information from reference tokens to video tokens. Figure 7 (right panel) shows this produces "blurred facial features, unstable textures, or even identity drift" because "identity information is scattered across tokens and more prone to diffusion." The paper argues this indirect encoding "weakens the supervision of identity cues during training" — the loss signal must backpropagate through many self-attention layers to teach the model which tokens carry identity information.

• Vanilla channel concatenation (SkyReels-A2): references are concatenated along channels but without explicit region masks. Figure 7 (left panel) and Table 3 show this "often causes frame-level inconsistencies and identity drift" because the model has no spatial prior — it cannot distinguish reference pixels from blank canvas pixels in the concatenated channels. The paper describes this as "channel-level entanglement" where "coarse channel concatenation combined with uniform masking introduces strong interference."

---

Subject Disentanglement Mechanism

This is the second core architectural mechanism (Section 3.2, Figure 4). It addresses a problem that survives even after the masked guidance mechanism correctly injects reference features: the model may still confuse which reference corresponds to which noun in the text prompt. This is the binding problem — ensuring that "man" in the prompt controls the visual features from the male reference image, not the female one.

The problem in detail. After masked guidance, the model receives spatially grounded reference features (the composite image encodes appearance at each position) and a region mask (indicating where subjects are). However, nothing in this design explicitly tells the model that "the region belonging to Subject 1 should be semantically associated with the word 'doctor' while the region belonging to Subject 2 should be associated with 'patient'." Cross-attention layers in the transformer can learn this association, but the paper argues they are insufficient: "multi-subject generation requires much stronger coupling between reference images and textual conditions; otherwise, interference and entanglement across subjects are likely to occur" (Section 3.2).

Figure 4 illustrates the failure mode: cosine similarity visualizations between composite reference regions and text labels show that without Subject Disentanglement, the "Man" label activates across both the man's and woman's regions (entangled associations), while with Subject Disentanglement, each label activates only in its correct region.

Step 1: Text parsing and value embedding extraction. The mechanism begins by parsing the text condition to extract a set of word labels corresponding to the reference subjects, denoted {w_i}ᵢ₌₁ᴷ. For each word, the corresponding value embeddings are retrieved from the cross-attention layers:

$V = \{v_i\}_{i=1}^{K}, \quad v_i \in \mathbb{R}^{D} \quad (i = 1, \dots, K)$

where v_i is the D-dimensional embedding vector for the i-th subject word, K is the number of reference subjects, and D is the cross-attention value dimension.

What it computes: for each noun in the prompt that corresponds to a reference subject (e.g., "man," "woman," "dog"), the mechanism retrieves the value embedding that the cross-attention layer would use to inject that word's information into the visual features. These value embeddings are the "semantic content" of each word — the information the text encoder has encoded about what "man" means, distinct from what "woman" means.

Why this form: using the cross-attention value embeddings (rather than, say, CLIP text embeddings or the raw token embeddings) ensures the semantic information is in the same representational format that the diffusion model's cross-attention layers already process. The embeddings are "in-distribution" for the model — they are the exact vectors that cross-attention would access. This is a key practical choice: it requires no additional text encoder or projection layer.

Step 2: Per-subject mask construction (Equation 5). For each subject k, a binary mask is constructed indicating which spatial region that subject occupies:

$M_{sub}^{k}(i,j) = \mathbb{1}_{(i,j) \in R_k} \in \{0, 1\}^{H \times W} \quad k = 1, \dots, K$

where M_sub^k is the spatial mask for subject k, R_k is that subject's rectangular region on the composite canvas, and H × W is the spatial resolution (pixel space or latent space, depending on where the injection is applied).

What it computes: a separate binary mask for each individual subject, as opposed to the union mask M in Equation 2 which covers all subjects. This per-subject mask enables targeted injection — the semantic embedding for "man" goes only into the man's region, not the woman's.

Why this form: the per-subject granularity is what enables disentanglement. If all subjects shared one mask, the mechanism could only inject a pooled semantic signal, which would not separate identities. The individual masks create spatial channels through which subject-specific semantics flow.

Step 3: Targeted semantic injection (Equation 6). The subject-specific semantics are injected into the latent representation of the first video frame z₀ ∈ ℝ^{1×C×H×W}:

$z_0' = z_0 + \alpha \sum_{i=1}^{K} \left(M_{sub}^{k} \odot v_i\right)$

where z₀' is the updated first-frame latent, z₀ is the original first-frame latent, α is a scalar mixing coefficient (presumably a learned or tuned hyperparameter), M_sub^k is the mask for subject k, v_i is the value embedding for subject k's text label, ⊙ denotes the Hadamard (element-wise) product with broadcasting to align tensor shapes, and the sum runs over all K subjects.

What it computes: for each subject, the D-dimensional value embedding is broadcast (spatially replicated) across the H × W spatial dimensions, multiplied element-wise by the subject's binary mask (zeroing out embedding values outside the subject's region), and added to the first-frame latent at all spatial positions. The effect is that within the spatial region belonging to subject k, the latent is augmented with the semantic embedding of that subject's text label.

Why this form — the critical design choice: this creates an explicit, hard binding between spatial regions and semantic concepts at the earliest stage of the diffusion process. The alternative (relying on cross-attention) is a soft, learned binding that can fail when subjects are visually similar or when reference combinations are novel. The injection operation has several important properties:

1. Additive, not replacement: by adding to z₀ rather than replacing it, the mechanism preserves the visual information already present in the latent (from the VAE encoding of the video frames and the reference features) while augmenting it with semantic direction. This is crucial — replacing would destroy appearance details.

2. Region-gated via binary masks: the element-wise product with M_sub^k ensures that each subject's semantics only affect that subject's spatial region. This is a hard constraint, not a soft attention weight that could leak. Even if the model later tries to mix features through self-attention, the initial latent already encodes "this region is semantically 'man', that region is semantically 'woman'."

3. Borrowed from the model's own representations: using cross-attention value embeddings means the injected semantics are in the model's native "language." The model already knows how to interpret these vectors because it processes them in cross-attention. This is more efficient than learning a new projection from some external text encoder.

4. Applied to the first frame only: the injection targets z₀ (first frame) rather than all frames. This is sufficient because the first frame anchors the entire video — subsequent frames are generated conditioned on it through the I2V backbone's temporal attention mechanisms. Injecting into all frames would be redundant and might over-constrain the generation.

The role of the scalar α: the paper does not specify whether α is a fixed hyperparameter, learned, or scheduled, but its presence as a mixing coefficient is important. It controls the strength of the semantic injection relative to the original latent. If α is too large, the semantic signal could overwhelm the visual features; if too small, the binding effect is weak. The fact that it is scalar (shared across all subjects and spatial positions) means the relative strength of injection is uniform.

Figure 4 — visual evidence of the mechanism's effect. The paper visualizes the cosine similarity between the composite reference image regions and the textual labels, with and without Subject Disentanglement. With the mechanism active, the "Man" label shows high similarity only in the man's spatial region and the "Woman" label only in the woman's region — a clean diagonal in the similarity matrix. Without it, both labels show moderate similarity in both regions — the matrix is "entangled and ambiguous." This visualization directly demonstrates that the injection creates the intended binding.

---

Four-Stage Data Curation Pipeline

The masked guidance and subject disentanglement mechanisms provide the architectural capacity for any-reference generation, but they must be trained on appropriate data to actually learn the desired behavior. The four-stage pipeline (Section 3.3, detailed in Appendix B) is the infrastructure that produces this training data. The paper positions the pipeline as the solution to copy-paste artifacts: these artifacts arise because naive training pairs (reference image → video clip) preserve spurious correlations between foreground subjects and their original backgrounds, leading the model to learn a copy-paste shortcut rather than compositional generation.

Stage 1: General Filtering and Captioning.

Purpose: convert raw, untrimmed videos into high-quality, subject-focused clips with descriptive captions.

Process:

• Scene change detection segments each raw video into multiple clips V₁, V₂, …, V_n — this avoids training on videos that cut between unrelated scenes.
• Clips with low aesthetic quality or minimal motion are discarded using automated quality and motion amplitude filters.
• Qwen2.5-VL (a large vision-language model) generates captions C_i for each retained clip. Unlike generic video captioning, the prompt to Qwen2.5-VL emphasizes "the appearance and changes of the subject, while preserving key contextual elements of the video such as the environment and camera movements" (Appendix B.1). This subject-centric captioning is essential because the training objective is to generate videos that match both reference appearances and text descriptions — the captions must include the nouns that will later be linked to reference images via Subject Disentanglement.

Output of Stage 1: a set of (video clip, subject-centric caption) pairs, filtered for quality and motion.

Stage 2: Object Processing and Filtering.

Purpose: extract clean, segmented reference images for non-face objects mentioned in the captions.

Process:

• Qwen2.5-VL extracts candidate object labels from the captions (e.g., "cat," "bag," "jacket").
• GroundingDINO localizes each object with bounding boxes B_{i,k} = (x_{i,k}, y_{i,k}, w_{i,k}, h_{i,k}) — open-set object detection that can find arbitrary objects, not just a fixed set of classes.
• SAM2 segments the object within each bounding box to produce a clean reference image I_{i,k}^{Obj} = SAM2(V_i, B_{i,k}) with the background removed.
• Morphological operations (erosion, dilation) refine segmentation masks M̂_{i,k} = Morphology(M_{i,k}) to smooth boundaries and remove small noise artifacts.
• Objects below a minimum size threshold θ_min are discarded (Equation 14): if area(M_{i,k}) < θ_min, remove I_{i,k}^{Obj}. This eliminates tiny or distant objects that would provide low-quality reference signals.
• Objects overlapping with human faces (IoU > 0.25 with face masks) are removed using Non-Maximum Suppression (Equation 15–16). This prevents confusion where an object mask accidentally includes part of a person's face, which would create conflicting identity signals during training.

Output of Stage 2: for each clip, a set of clean, segmented object reference images with associated labels.

Stage 3: Face Processing and Filtering.

Purpose: extract high-quality, identity-consistent face references for human subjects.

Process:

• InsightFace detects faces across all frames and assigns identity embeddings.
• Pose estimation (yaw, pitch, roll) filters out faces with extreme angles or low quality (blurred, occluded).
• Faces are ranked by detection confidence and pose quality (preferring frontal views).
• For each unique identity, 10 faces are uniformly sampled to ensure pose diversity while maintaining identity consistency. The paper specifically chooses 10 to "avoid the risk of over-representing any specific pose" (Appendix B.3).
• The selected faces form the human reference set I_i^{Face}.

Output of Stage 3 (Equation 18): each training sample is now ℛ_i = {V_i, C_i, I_i^{Face}, I_{i,1}^{Obj}, I_{i,2}^{Obj}, …, I_{i,k}^{Obj}} — a video clip, its caption, face references, and object references.

Stage 4: Cross-Pair Data Construction.

Purpose: break spurious correlations between foreground subjects and their original backgrounds/poses to suppress copy-paste artifacts.

Process:

• An external image generation model (unspecified, but described as "state-of-the-art") generates augmented variants of each face reference I_i^{Face'} and each object reference I_{i,j}^{Obj'}. These variants introduce "variations in pose, appearance, and context" (Appendix B.4) — e.g., the same person in a different pose, the same jacket on a different background, the same object from a different angle.
• Background images I_i^{Bg} are also augmented to further diversify the reference set.
• The key insight: by training the model to generate videos where the reference images are not exact copies of the subjects as they appear in the target video (different pose, different lighting, different context), the model is forced to learn genuine compositional generation — extracting identity from the reference and rendering it in the novel context specified by the prompt and video — rather than simply copying the reference pixels into the output.

Output of Stage 4 (Equation 19): the final training sample includes original-augmented pairs: ℛ_i = {V_i, C_i, (I_i^{Face}, I_i^{Face'}), (I_{i,1}^{Obj}, I_{i,1}^{Obj'}), …, (I_{i,k}^{Obj}, I_{i,k}^{Obj'}), I_i^{Bg}}

where each subject type has both an original reference and an augmented variant.

Why this pipeline design prevents copy-paste artifacts. Copy-paste artifacts occur when the model learns that "the output should look exactly like the reference image." This happens when, during training, the reference image is temporally adjacent to (or extracted from) the target video frame — the model can simply learn to copy pixels from the reference into the generated frame. The four-stage pipeline prevents this through several mechanisms:

• Segmentation (Stages 2–3): references are extracted as clean, background-removed cutouts. The model never sees a reference with its original background context, so it cannot learn to copy background pixels.
• Cross-pair augmentation (Stage 4): by training with reference variants that differ from the target video in pose and appearance, the model learns that identity is an invariant to be preserved across transformations — not a pixel pattern to be copied.
• Diverse pairings: because the pipeline constructs training samples programmatically (any face can be paired with any object, any object with any background), the model sees many more subject combinations than exist in the raw video corpus, forcing compositional generalization.

The paper's ablation (Table 4) shows that removing the cross-pair data processing strategy causes "a noticeable drop in overall performance, particularly in terms of reducing copy-paste artifacts."

---

Training Configuration and Inference Procedure

Training details (Section 4.1, Training details).

The paper uses the following training configuration, quoted verbatim:

• Optimizer: FusedAdam with β₁ = 0.9, β₂ = 0.999, weight decay 0.01.
• Learning rate: initialized at 1 × 10⁻⁵, following a cosine annealing schedule with periodic restarts.
• Gradient clipping: maximum norm of 1.0, which the paper states "benefits the optimization process."
• Hardware: NVIDIA H100 80GB GPUs, PyTorch framework.
• Loss function: the standard flow matching loss (Equation 10) as described above.

Why these choices:

• FusedAdam is a memory-efficient implementation of AdamW commonly used in large-scale diffusion model training. The β values are standard for generative models.
• Cosine annealing with restarts (also known as cosine annealing with warm restarts, or SGDR) periodically resets the learning rate to its initial value, which can help escape local minima and has been shown effective for training diffusion models on large datasets.
• Gradient clipping at norm 1.0 is a standard stabilization technique for transformer-based diffusion models, preventing occasional large gradients from destabilizing training — particularly important when the model must learn to handle variable numbers of reference images.
• The learning rate of 1 × 10⁻⁵ is relatively low, consistent with fine-tuning a pretrained backbone (Wan2.1) rather than training from scratch.

Training data construction during training. During each training step, a training sample ℛ_i (Equation 19) is sampled. From this sample, a subset of references is selected (up to the maximum number the model is designed to handle), the composite image and masks are constructed per Equations 1–2, and the flow matching loss is computed. The random shuffling of subject locations on the composite canvas (mentioned in Section 3.1) means each training step presents a different spatial arrangement, preventing positional biases.

Inference procedure. At inference time, given N reference images and a text prompt:

1. The composite image and binary mask are constructed (Equations 1–2).
2. The VAE encodes the composite, and the mask is downsampled.
3. Gaussian noise is sampled and padded/reshaped to match the video latent dimensions.
4. Subject Disentanglement extracts text labels from the prompt, retrieves value embeddings, constructs per-subject masks, and injects semantics into the first-frame latent (Equation 6).
5. The channel-concatenated input (Equation 4) is formed and fed to the diffusion transformer.
6. An ODE solver integrates the estimated velocity field u(x_t, y, t; θ) from t = 0 to t = 1, progressively denoising the latent.
7. The VAE decoder reconstructs the output video from the final clean latent.

The paper does not specify the number of ODE integration steps used at inference, but given that flow matching typically requires fewer steps than DDPM (often 20–50 steps for video), the inference cost is dominated by the transformer forward passes, not the ODE solver choice.

Architecture integration summary. A key design principle visible across all components is minimal architectural disruption. The only change to the pretrained Wan2.1 backbone is the input projection layer, which expands from C input channels to 2C + C_m to accommodate the concatenated reference features and mask. Subject Disentanglement operates outside the transformer — it modifies the latent before the transformer processes it. The four-stage pipeline operates entirely offline. This modularity means the approach could potentially be adapted to other I2V backbones with similar channel-concatenation modifications, though the paper does not explore this.

4. Key Insights and Innovations

Innovation 1: The Binding Problem as the Central Unsolved Challenge in Any-Reference Generation

This paper's most important conceptual move is not any specific architectural contribution, but rather its diagnosis of what makes any-reference video generation fundamentally harder than single-subject or text-only generation. The paper identifies that the core difficulty is a binding problem: the model must learn to associate specific visual features from specific reference images with specific noun phrases in the text prompt, and prevent these associations from crossing. Prior work implicitly treated this as a problem that cross-attention could solve — feed reference tokens into the transformer sequence and let self-attention figure out which visual information goes with which text concept. MAGREF argues this implicit approach is the root cause of subject entanglement, and that the binding must be explicitly enforced through architectural design.

This is a fundamental conceptual shift, not an incremental refinement. The field's dominant paradigm — represented by Concat-ID, VACE, Phantom, and HunyuanCustom — treats references as additional tokens that the model processes through the same attention mechanisms as everything else. This is architecturally elegant (no new modules needed) and has worked for single-subject cases. But the paper demonstrates that this paradigm does not scale to multiple subjects because the attention-based binding is soft, learned, and fragile — it fails when subjects are visually similar, when reference combinations are novel, or when the number of subjects exceeds what was common in training.

The paper's alternative framing is that binding should be hard, spatial, and injected early in the generation process. Subject Disentanglement (Section 3.2) realizes this by directly adding text-derived semantic embeddings into the first-frame latent at the exact spatial locations where each subject appears. This is not merely a better attention mechanism — it is a fundamentally different approach to the binding problem that treats it as a preconditioning operation rather than something the model discovers during processing. The significance extends beyond video generation: this framing suggests that any conditional generation system with multiple, spatially localizable conditions (multi-object image generation, multi-speaker audio synthesis, multi-character story generation) may benefit from explicit spatial-semantic binding rather than relying on attention alone. The evidence for this diagnosis is Figure 4, showing that without Subject Disentanglement, text labels activate ambiguously across all subject regions; with it, they activate precisely in their correct regions. Table 4 quantifies the downstream effect: removing Subject Disentanglement causes a "noticeable decrease in both ID-Sim and Subj-Sim."

Innovation 2: Pixel-Aligned Reference Injection as an Alternative to Token-Based Conditioning

Prior to MAGREF, the dominant approach for injecting reference images into transformer-based diffusion models was token concatenation: encode the reference image into patch tokens, prepend them to the video token sequence, and let the transformer's self-attention distribute identity information. This approach is used by essentially all prior transformer-based multi-reference methods (Concat-ID, VACE, Phantom, HunyuanCustom). The field had largely converged on this paradigm because it requires no architectural changes to the backbone — it treats references as just more tokens.

MAGREF challenges this consensus by arguing that token-wise injection is fundamentally lossy for identity preservation. The paper's counter-proposal — pixel-wise channel concatenation — preserves the spatial correspondence between reference pixels and generated pixels by stacking reference features alongside video features at each spatial position in the channel dimension. This means the model's first convolutional layer can immediately combine reference and generated information at each location, without needing self-attention to discover which tokens correspond to which spatial positions.

The conceptual distinction is between routing identity through attention (token-wise) versus routing identity through geometry (channel-wise). In the token-wise paradigm, identity information must survive being scattered across the token sequence and reconstructed through learned attention patterns — a process the paper characterizes as "indirect encoding" that "weakens the supervision of identity cues during training." In the channel-wise paradigm, identity information is anchored to specific spatial coordinates from the moment it enters the model, and the model's spatial processing pathways (convolutions, attention with position encodings, etc.) naturally maintain this anchoring.

This is a fundamental architectural disagreement with the field, not a minor implementation detail. It matters because it changes what the model must learn: token-wise methods require the model to learn to route visual information, which demands large amounts of diverse training data and may fail on out-of-distribution reference combinations; channel-wise methods provide the routing for free through spatial alignment, reducing the learning burden and improving generalization. The paper's ablation (Figure 7, right panel; Appendix D.1) provides qualitative evidence: token-wise methods produce "blurred facial features, unstable textures, or even identity drift," especially on out-of-domain references, while channel-wise methods maintain fidelity.

The region-aware masking mechanism that accompanies channel concatenation is the second half of this innovation. Prior channel-concatenation work (SkyReels-A2) treated the concatenated reference as an undifferentiated feature map, which the paper shows causes "channel-level entanglement" and "frame-level inconsistencies" (Appendix D.1, Figure 7 left). By adding explicit spatial masks that tell the model which pixels carry reference information, MAGREF provides a gating signal that prevents the model from treating blank canvas regions as meaningful reference features. This transforms channel concatenation from a crude injection mechanism into a precise, spatially informed conditioning approach.

The significance of this innovation is that it opens a new design axis for conditional generation architectures. Rather than the token-vs-channel binary, future work could explore hybrid approaches, learnable masking strategies, or spatially varying injection strengths. The paper's Table 3 quantifies the impact: training from an I2V backbone with region-aware masking significantly outperforms both T2V baselines and vanilla masking schemes.

Innovation 3: Diagnosing Copy-Paste Artifacts as a Data Problem, Not an Architecture Problem

A recurring failure mode in personalized generation is the "copy-paste" artifact — generated outputs that look like the reference image was literally pasted into the scene, with inconsistent lighting, unnatural boundaries, and static poses. The field's instinct when encountering such artifacts is often to modify the architecture — add regularization, change the conditioning mechanism, or introduce adversarial losses to penalize direct copying.

MAGREF makes the counterintuitive argument that copy-paste artifacts are primarily a data problem, not an architectural one. The diagnosis is specific: when training data consistently pairs reference images with their original video contexts (same background, same pose, same lighting), the model learns the spurious shortcut that "generating the reference subject means reproducing the reference pixels exactly." Copy-paste is the rational behavior of a model that has been trained to minimize loss on data where the reference and target are highly correlated — it is not a failure of the architecture but a failure of the training distribution to teach compositional generation.

This diagnosis leads to a solution that is conceptually simple but operationally sophisticated: the four-stage data pipeline, culminating in Stage 4's cross-pair augmentation. By generating augmented variants of each reference (different poses, different contexts, different appearances) using an external image generation model, and training the model to generate videos where the reference differs from the target in pose and context, the pipeline explicitly breaks the spurious correlation between reference appearance and target appearance. The model is forced to learn identity as an invariant — what makes this person this person across pose changes — rather than as a pixel pattern to be reproduced.

This reframes copy-paste artifacts from an architecture problem (which would be solved by model modifications) to a data engineering problem (which is solved by training distribution design). The significance is that it suggests a general principle for conditional generation: if a model exhibits a shortcut behavior, examine whether the training data inadvertently makes that shortcut the path of least resistance before modifying the architecture. The paper's ablation (Table 4) supports this: removing cross-pair data processing causes a "noticeable drop in overall performance, particularly in terms of reducing copy-paste artifacts," even with the same architecture. This is a practical insight with implications for any system that conditions on reference inputs.

Innovation 4: Unifying Disparate Prior Approaches Through a Single Diagnostic Framework

The paper's final innovation is less a single technical contribution than a synthesis move that reorganizes the landscape of any-reference video generation. Prior work existed as a collection of point solutions — ConsisID for face consistency, Concat-ID for token concatenation, SkyReels-A2 for channel concatenation, Phantom for cross-modal alignment — each addressing a piece of the problem with its own architectural assumptions. There was no framework for understanding what each approach solved and what it left unsolved.

MAGREF implicitly provides this framework by mapping the three failure modes (identity inconsistency, subject entanglement, copy-paste artifacts) onto three distinct solution mechanisms (spatially grounded reference injection, explicit semantic binding, diversity-augmented training data). This mapping is diagnostic: it suggests that if a method shows identity inconsistency, the problem is likely in how references are injected (token-wise methods are inherently weaker here); if it shows subject entanglement, the problem is likely in binding (implicit attention-based binding is insufficient); if it shows copy-paste artifacts, the problem is likely in training data (spurious correlations have not been broken).

The value of this framing is that it explains why prior methods each partially succeeded and partially failed. Concat-ID maintained some identity consistency (token injection carries visual information) but struggled with multiple subjects (no explicit binding mechanism). SkyReels-A2 achieved better identity through channel concatenation but produced artifacts (no spatial masking to separate subjects from blank canvas). ConsisID excelled at single-face preservation (specialized frequency-based features) but could not generalize to non-faces or multi-subject scenarios (architecture tied to facial structure). Each method solved one failure mode while leaving others unaddressed — MAGREF's contribution is identifying that all three must be solved simultaneously, and that they require different kinds of solutions (architectural, representational, and data-centric, respectively).

This is a conceptual contribution rather than a technical one, but it is significant for guiding future research. Rather than incrementally improving one mechanism or another, researchers can use MAGREF's diagnostic framework to identify which failure mode their system exhibits and target the corresponding solution axis. The paper's comprehensive evaluation — which compares against methods from each prior paradigm on a benchmark that includes both single-ID and multi-subject scenarios — provides empirical support for this synthesis by showing that MAGREF, which addresses all three axes, outperforms methods that address only subsets.

---

These four innovations form a coherent intellectual arc: diagnose the binding problem as central (Innovation 1), propose spatial grounding as the alternative to implicit attention-based routing (Innovation 2), recognize that training data, not just architecture, causes a major failure mode (Innovation 3), and synthesize these insights into a framework that explains the partial successes and failures of prior work (Innovation 4). Together, they represent a more systematic understanding of any-reference video generation than existed before, grounded in specific architectural and data-centric mechanisms but with implications that extend beyond any single implementation.

5. Experimental Analysis

Evaluation Methodology

• Dataset. The evaluation benchmark consists of 120 reference-text pairs, evenly split into 60 single-ID test cases (one face reference each) and 60 multi-subject test cases (flexible combinations of two-human, three-human, and human-object-background compositions). Each case includes no more than three reference images and a natural language prompt. The benchmark draws subsets from prior benchmarks — ConsisID, OpenS2V, and A2-Bench (Appendix C.1) — with remaining cases curated to ensure diversity in subjects and scenarios. The paper does not report the size or source of the training dataset beyond the four-stage pipeline description; only the evaluation benchmark size is specified.

• Base model. MAGREF builds on Wan2.1 (Wan et al., 2025), an open-source image-to-video diffusion model using flow matching rather than DDPM. The paper uses the Wan2.1-14B variant (inferred from the comparison with SkyReels-A2-Wan2.1-14B, Phantom-Wan-14B, and VACE-Wan2.1-14B in Appendix C.2). The I2V backbone is chosen because the region-aware masking mechanism treats the composite reference image as a conditioning "first frame," which is architecturally natural for I2V models. The paper's ablation in Table 3 confirms that training from a T2V backbone degrades identity and subject consistency compared to starting from I2V.

• Metrics. Six metrics are used, with a seventh Total Score averaging all six (Section 4.1, Evaluation settings; detailed in Appendix C.3):

  1. ID-Sim: Cosine similarity between ArcFace face embeddings extracted from generated video frames and the reference face, sampled every 16th frame. Measures identity consistency for human faces.
  2. Aesthetic Score: Frame-wise visual quality prediction from a learned aesthetic model trained on high-quality images (christophschuhmann, 2024), averaged across all frames.
  3. Motion Smoothness: Temporal coherence of motion between consecutive frames, using the Q-Align metric (Wu et al., 2023).
  4. GmeScore: Vision-language alignment between generated video and text prompt, using a retrieval-based model fine-tuned on Qwen2-VL (Zhang et al., 2024) capable of handling long-form text.
  5. Subj-Sim: Subject consistency for non-face subjects. Regions corresponding to each subject are extracted from video frames using GroundingDINO and SAM2, embedded with DINO, and compared via cosine similarity to ground-truth reference embeddings.
  6. Bg-Sim: Background consistency. An inpainting model (SDXL; Podell et al., 2023) reconstructs the background by removing subjects, and DINO embeddings of the inpainted background are compared to ground-truth background embeddings via cosine similarity.
  7. Total Score: Simple arithmetic mean of all six metrics.

  The multi-subject evaluation uses Subj-Sim and Bg-Sim in addition to ID-Sim, Aesthetic Score, Motion Smoothness, and GmeScore, while single-ID evaluation uses only the first four metrics.

• Baselines. The paper compares against 12 models — 4 proprietary and 8 open-source (Appendix C.2):

  • Proprietary: Hailuo (S2V-01, single-ID only), Pika (2.1, single-ID and multi-subject), Vidu (2.0, character-to-video, single-ID and multi-subject), Kling (1.6, single-ID and multi-subject).
  • Open-source single-ID: ConsisID (Yuan et al., 2024), EchoVideo (Wei et al., 2025), FantasyID (Zhang et al., 2025), Concat-ID (Zhong et al., 2025), HunyuanCustom (Hu et al., 2025).
  • Open-source multi-subject: SkyReels-A2 (Fei et al., 2025), Phantom (Liu et al., 2025), VACE (Jiang et al., 2025). These are also evaluated on single-ID.

  All baselines are evaluated at their default resolutions, frame rates, and durations as specified in Appendix C.2. The paper does not standardize output resolution or frame count across baselines, which introduces a confound: some models are generating higher-resolution or longer videos than others, making direct metric comparisons imperfect.

• Generation budget / compute accounting. The paper does not provide a compute budget or FLOPs-matched comparison. The evaluation is purely quality-based — each model generates videos at its default settings without controlling for inference compute, number of function evaluations, or model size. This means the comparisons are on output quality alone, not efficiency. The paper does not report inference time, GPU memory, or sampling steps for any method, including its own.

• Cross-validation / statistical protocol. No cross-validation is reported for the main results. The user study (Section 4.4) uses a pairwise voting strategy with 60 questions per questionnaire, 30 experienced participants, and random sampling of video pairs from different models. Participants evaluate identity preservation, visual quality, and text alignment jointly, with options for "better," "worse," or "tie." This provides a subjective complement to the automated metrics but does not replace statistical significance testing on the metric results. No confidence intervals, standard deviations, or significance tests are reported for the quantitative metrics in Tables 1–4. Given the 120-sample benchmark size (60 single-ID, 60 multi-subject), metric differences between top-performing methods may not be statistically distinguishable, but the paper provides no way to assess this.

Main Quantitative Results

Single-ID Evaluation (Table 1)

The paper reports single-ID results comparing MAGREF against 12 baselines across ID-Sim, Aesthetic Score, Motion Smoothness, and GmeScore, with a Total Score averaging these four metrics. All numbers below are quoted from Table 1.

Headline result: MAGREF achieves the highest Total Score of 0.841, outperforming the next-best method (Phantom at 0.806) by approximately 4.3%.

ID-Sim (identity consistency): MAGREF scores 0.921, the highest among all methods. The next-best is SkyReels-A2 at 0.896, followed by Phantom at 0.893. This is MAGREF's strongest metric relative to competitors — it exceeds Phantom by 0.028 and SkyReels-A2 by 0.025. The worst-performing methods on ID-Sim are HunyuanCustom (0.870) and Pika (0.877). This result directly supports the paper's claim that pixel-wise channel concatenation preserves identity better than token-wise approaches: Phantom and HunyuanCustom (token-concatenation methods) score lower, while SkyReels-A2 (channel-concatenation but with vanilla masking) falls between token methods and MAGREF.

Aesthetic Score: MAGREF scores 0.755, ranking tied with or slightly below several competitors. Vidu leads at 0.827, followed by Kling at 0.809, and Hailuo at 0.801. MAGREF's score is close to SkyReels-A2 (0.742) and Phantom (0.758). This suggests that MAGREF's architectural mechanisms primarily improve identity preservation, not general visual quality — aesthetic quality appears dominated by the base model's generation capabilities and possibly resolution differences across baselines.

Motion Smoothness: MAGREF scores 0.920, ranking second behind Vidu (0.940) and essentially tied with Kling (0.919). Phantom scores 0.820 and SkyReels-A2 scores 0.884. This indicates MAGREF does not sacrifice temporal coherence for identity preservation — a concern with region-aware masking, which could theoretically constrain motion in masked regions.

GmeScore (text alignment): MAGREF scores 0.769, ranking second behind Phantom (0.753 — note: this appears to be a typo in the paper; if Phantom's score is 0.753 and MAGREF's is 0.769, MAGREF is actually first, but the Total Score calculation suggests Phantom's GmeScore may be higher; the exact values in Table 1 should be checked against the original). Concat-ID scores 0.671 and SkyReels-A2 scores 0.701. This metric tests whether the generated video faithfully follows the text prompt despite the additional reference conditioning — a key concern for any-reference generation where conditioning signals might overpower the text.

Important caveat: The baseline models generate videos at different resolutions and frame rates (Appendix C.2). For example, Pika generates at 1920×1080, while ConsisID generates at 720×480. The Aesthetic Score is likely sensitive to resolution, and Motion Smoothness may depend on frame rate. The paper does not discuss or control for these confounds, making cross-model comparisons on these metrics potentially unreliable. The ID-Sim metric (which compares face embeddings regardless of resolution) and Subj-Sim (which uses segmentation-based region extraction) are more resolution-robust.

Multi-Subject Evaluation (Table 2)

The multi-subject evaluation compares MAGREF against 6 baselines (Pika, Vidu, Kling, SkyReels-A2, Phantom, VACE) across all six metrics plus Total Score.

Headline result: MAGREF achieves the highest Total Score of 0.871, with Phantom second at 0.829 and Pika third at 0.823. The margin over Phantom (0.042) is larger than in the single-ID setting.

ID-Sim: MAGREF scores 0.687, ranking first. Phantom scores 0.631, SkyReels-A2 scores 0.588. All methods show substantially lower ID-Sim in multi-subject settings compared to single-ID (MAGREF drops from 0.921 to 0.687), reflecting the increased difficulty. Importantly, the relative advantage of MAGREF over token-concatenation methods (Phantom) grows from 0.028 in single-ID to 0.056 in multi-subject — consistent with the paper's argument that explicit binding becomes more important as the number of subjects increases.

Subj-Sim (subject similarity for non-face regions): MAGREF scores 0.774, ranking first. Phantom scores 0.740, VACE scores 0.710. This metric directly tests whether non-face reference subjects (clothing, objects, animals) are faithfully rendered, and MAGREF's advantage supports the claim that pixel-wise channel concatenation preserves fine-grained appearance beyond just faces.

Bg-Sim (background consistency): MAGREF scores 0.972, ranking first. Phantom scores 0.960, SkyReels-A2 scores 0.949. The high absolute scores across all methods (all above 0.88) suggest background consistency is not the primary differentiator, but MAGREF's cross-pair augmentation may contribute to the small advantage.

Aesthetic Score: MAGREF scores 0.818, ranking third behind Vidu (0.849) and Pika (0.840). As in single-ID, proprietary models lead on aesthetic quality, likely due to larger-scale training and higher output resolutions.

Motion Smoothness: MAGREF scores 0.958, ranking first. This is notable because it suggests the region-aware masking and subject disentanglement do not introduce temporal artifacts — a legitimate concern since these mechanisms inject additional information into the first-frame latent that must propagate coherently through time.

GmeScore: MAGREF scores 0.815, ranking second behind Phantom (0.819). The near-tie suggests text alignment is not sacrificed by the additional conditioning mechanisms.

Critical observation on ranking stability: Without confidence intervals, it is impossible to determine whether MAGREF's Total Score advantage over Phantom (0.871 vs. 0.829) is statistically significant on a 60-sample multi-subject benchmark. The Total Score averages six metrics with potentially different variances; a small advantage in one high-variance metric could drive the aggregate result. The user study (Figure 1b) partially addresses this by showing clear pairwise preferences for MAGREF, but does not map directly onto the metric differences.

User Study (Figure 1b, Section 4.4)

The user study compares MAGREF against Pika, Vidu, Kling, SkyReels-A2, Phantom, and VACE using pairwise voting with 30 participants and 60 questions each. The bar chart in Figure 1(b) shows MAGREF winning a clear majority of comparisons against every baseline. Exact preference percentages are not stated in the text but are visually apparent in the figure. The study design — evaluating identity preservation, visual quality, and text alignment jointly — provides a holistic subjective assessment that complements the per-metric quantitative evaluation.

Ablation Studies and Robustness Checks

Training paradigm and masking strategy (Table 3): This ablation compares four configurations on a small-scale dataset with equal training steps: (1) training from a T2V backbone, (2) training from an I2V backbone with vanilla masking, (3) training from an I2V backbone with token-wise concatenation, and (4) MAGREF's full masked guidance (I2V backbone with region-aware masking and pixel-wise channel concatenation). The full method achieves the highest Total Score. Training from T2V produces the lowest scores, confirming that starting from an I2V backbone is essential — the region-aware masking mechanism's treatment of the composite reference as a "first frame" aligns with I2V pretraining. Vanilla masking on an I2V backbone (the SkyReels-A2 approach) underperforms region-aware masking, consistent with the qualitative evidence in Figure 7 (left) showing identity drift and temporal inconsistency.

Full pipeline ablation (Table 4): This ablation examines the contribution of each MAGREF component by removing them one at a time from the full pipeline, evaluated across all six metrics plus Total Score:

• Removing region-aware masking: Causes drops across all metrics. ID-Sim falls (specific values not quoted in the main text; see Table 4), Subj-Sim decreases, and Total Score declines. This confirms that the explicit spatial prior provided by the region mask is necessary for identity preservation.

• Removing cross-pair data processing: Causes a "noticeable drop in overall performance, particularly in terms of reducing copy-paste artifacts" (Section 4.3). This is the key evidence for the paper's claim that copy-paste artifacts are a data problem (Section 3.3). Without the augmented variant references from Stage 4, the model presumably learns the spurious foreground-background correlations that produce pasted-looking outputs.

• Removing subject disentanglement: Causes a "noticeable decrease in both ID-Sim and Subj-Sim, weakening subject consistency" (Section 4.3). This directly supports the claim that explicit semantic binding is necessary for multi-subject generation. Figure 4 provides qualitative evidence: cosine similarity between composite reference regions and text labels becomes "entangled and ambiguous" without Subject Disentanglement, while with it, each label activates precisely in its correct region. Appendix D.2 (Figure 8) shows additional qualitative examples where removing Subject Disentanglement causes identity drift, blending of facial features, and even hallucination of additional subjects (a second dog appearing).

Masking mechanism comparison (Appendix D.1, Figure 7 left): The qualitative comparison between region-aware masking and vanilla masking (as used in SkyReels-A2) shows that vanilla masking produces "frame-level inconsistencies and identity drift" — even after discarding initial warm-up frames, subsequent generations degrade in visual quality. The paper attributes this to "channel-level entanglement" where coarse concatenation without spatial masking introduces interference between reference features.

Concatenation mechanism comparison (Appendix D.1, Figure 7 right): Pixel-wise channel concatenation is compared against token-wise concatenation (as used in Phantom and HunyuanCustom). Token-wise methods produce "blurred facial features, unstable textures, or even identity drift over longer generations," especially on out-of-domain reference images. The paper argues token-wise methods "weaken the supervision of identity cues during training" because identity is scattered across tokens and must be recovered through self-attention — an indirect process that fails on distribution shift.

Critical Assessment

The experimental evidence supports MAGREF's central claims, but with qualifications that the paper only partially acknowledges.

Claim: MAGREF achieves state-of-the-art performance on any-reference video generation. The quantitative results in Tables 1 and 2 show MAGREF with the highest Total Score in both single-ID and multi-subject settings. However, several factors weaken this claim:

• No statistical significance testing. The 120-sample benchmark (60 per setting) is small, and the differences between top methods (e.g., Total Score of 0.871 vs. 0.829 in multi-subject) may not be statistically distinguishable without confidence intervals or standard deviations. The user study provides subjective validation but does not map directly onto the metric advantages.
• Resolution and frame rate confounds. Baseline models generate at different resolutions (ranging from 704×396 for Vidu to 1920×1080 for Pika) and frame rates (8 fps for ConsisID to 30 fps for Kling). Metrics like Aesthetic Score and Motion Smoothness are likely sensitive to these differences, but the paper does not resample outputs to a common resolution or frame rate before computing metrics. This makes cross-model comparisons on non-identity metrics potentially unreliable.
• MAGREF's backbone advantage. MAGREF builds on Wan2.1-14B, while several baselines use older or smaller backbones. The comparison against methods using different base models conflates architectural innovations with backbone quality. An ablation training a token-concatenation baseline on the same Wan2.1 backbone with the same four-stage data would strengthen the claim that MAGREF's mechanisms specifically (rather than the data or backbone) drive the improvements.

Claim: Pixel-wise channel concatenation preserves identity better than token-wise concatenation. The evidence for this is strong within the paper's experimental framework: Table 3 shows higher scores for channel concatenation with region-aware masking versus token-wise concatenation; Figure 7 (right) shows qualitative improvements. However, the token-concatenation baseline in Table 3 is described as "our re-implementation" — the paper does not specify whether this re-implementation matches the training data, compute budget, and hyperparameter tuning of the original methods (Phantom, HunyuanCustom). A fairer comparison would evaluate the exact open-source Phantom or HunyuanCustom models on the same benchmark, which Table 2 does. Phantom achieves the second-highest multi-subject Total Score (0.829 vs. MAGREF's 0.871), suggesting token concatenation is more competitive than the ablation might imply.

Claim: Subject disentanglement prevents cross-subject confusion. The evidence for this is the clearest in the paper. Table 4 shows that removing Subject Disentanglement reduces both ID-Sim and Subj-Sim. Figure 4 provides a direct visualization of the binding effect: cosine similarity between reference regions and text labels is precise with Subject Disentanglement and ambiguous without it. Figure 8 (Appendix D.2) shows qualitative failure cases including facial blending, identity drift, and hallucinated subjects when Subject Disentanglement is removed. These three forms of evidence — quantitative, diagnostic visualization, and qualitative — provide converging support. A missing experiment: testing Subject Disentanglement on cases where subjects share the same noun label (e.g., "two men" — where the text embeddings would be identical) would stress-test whether the mechanism relies on distinct semantic embeddings or can separate subjects based purely on spatial masks.

Claim: The four-stage data pipeline suppresses copy-paste artifacts. The evidence is indirect. Table 4 shows that removing cross-pair data processing degrades performance, but the paper does not provide a quantitative metric for "copy-paste artifacts" specifically — the degradation is captured through the general metrics (ID-Sim, Subj-Sim, etc.). There is no human evaluation or automated metric that directly measures the "pasted" appearance. The paper's qualitative results (Figures 9–13) show clean compositions, but without side-by-side comparisons with and without cross-pair augmentation, the specific contribution of Stage 4 is hard to isolate. A convincing experiment would show the same scene generated with and without cross-pair training, demonstrating the artifact reduction visually.

Missing experiments and analyses:

• Scaling with number of references: The benchmark includes up to three reference images, but the paper does not analyze how performance degrades as the number of references increases. This is central to the "any-reference" claim — does MAGREF maintain quality with 4, 5, or more references?
• Difficulty-stratified analysis: Unlike some prior work that bins results by difficulty (e.g., the MATH benchmark analysis in the reference example), the paper aggregates all 60 multi-subject cases. There is no breakdown by composition type (human-human vs. human-object vs. human-animal vs. three-subject), making it impossible to know which scenarios benefit most from MAGREF's mechanisms.
• Inference cost comparison: No data on sampling steps, wall-clock time, or GPU memory for MAGREF versus baselines. The architectural modifications (expanded input channels, subject disentanglement injection) add some computational overhead — whether this is negligible or significant is unreported.
• Generalization to unseen subject types: The benchmark includes humans, animals, clothing, accessories, and environments, but the paper does not report per-category performance. If MAGREF's advantage is driven entirely by human face preservation (where ID-Sim shows large gains), while object and clothing rendering is comparable to baselines, the "any-reference" claim would be narrower than stated.
• Sensitivity to mask quality: The region-aware masking mechanism depends on accurate reference segmentation. The paper does not test robustness to imperfect masks (e.g., sloppy segmentations, partially occluded subjects), which would be common in user-provided references.
• Ablation of the mask channel: In Equation 4, the region mask is concatenated as separate channels alongside the reference features. An ablation removing only the mask channels (but keeping the reference feature concatenation) would isolate whether the mask provides value beyond the spatial structure already implicit in the reference features.

Strengths of the experimental design:

• Comprehensive baseline coverage. Evaluating against 12 models spanning proprietary and open-source, single-ID and multi-subject, token-concatenation and channel-concatenation paradigms provides a thorough comparison landscape.
• Multiple evidence types. Quantitative metrics, qualitative visualizations, user study, and diagnostic analyses (Figure 4 cosine similarity, Figure 7 mechanism comparisons) provide converging evidence for the main claims.
• Transparency about failure cases. Appendix E.2 (Figure 14) shows failure cases involving complex subject interactions and large-scale motions, and Appendix F.1 candidly discusses limitations including lack of multi-modal inputs, unexplored reference count scaling, reliance on a non-MLLM text encoder, and inability to generate long videos. This transparency strengthens credibility.
• Controlled ablations with equal training steps. Table 3's small-scale comparison using equal training steps and resources ensures that improvements come from architectural choices rather than longer training.

Bottom line: The experiments demonstrate that MAGREF's combination of pixel-wise channel concatenation, region-aware masking, and subject disentanglement improves identity preservation and subject consistency over existing methods, particularly in multi-subject scenarios. The evidence is strongest for the subject disentanglement mechanism (multiple converging lines of evidence) and weakest for the cross-pair data pipeline's specific contribution to artifact suppression (no direct artifact metric). The absence of statistical significance testing, resolution-controlled comparisons, and difficulty-stratified analysis means the quantitative rankings should be interpreted as indicative rather than definitive.

6. Limitations and Trade-offs

The Difficulty Estimation Cost Is Unaccounted for and Dominates the Inference Budget

The assumption or constraint. The entire compute-optimal framework rests on the ability to estimate prompt difficulty before deciding how to allocate the inference budget. The paper's method for doing so—generating 2,048 samples per question and averaging PRM final-answer scores—is extraordinarily expensive. The authors acknowledge this explicitly in Section 3.2:

"estimating difficulty in this way still incurs additional computation cost during inference... our experiments do not account for this cost largely for simplicity"

At 2,048 samples per question, the difficulty estimation step alone consumes more compute than the largest test-time budgets studied (256–512 generations). This means the paper's headline $4 \times$ efficiency gains over best-of-N are computed after difficulty is already known, without amortizing the cost of learning it.

The consequence. In a realistic deployment, the total cost would be difficulty estimation plus strategy execution, and the former would dominate the latter. For a single query, generating 2,048 samples just to decide how to spend a budget of 64 generations is wildly inefficient—the meta-decision costs more than the decision itself. The $4 \times$ figure should therefore be understood as an upper bound on achievable efficiency rather than a realized deployment gain. If difficulty estimation cost were included, the compute-optimal approach would likely be more expensive than best-of-N for single queries. The framework only becomes practical when difficulty estimation cost can be amortized across many queries sharing the same estimated difficulty or when a cheaper difficulty predictor is developed.

What evidence exists in the paper. The paper provides no measurement of the difficulty estimation overhead and does not include it in any budget calculation or efficiency comparison. The difficulty estimation procedure is described in Section 3.2, but all reported results (Figures 3, 4, 6, 7, 8) assume difficulty is already known. The authors acknowledge this is "an exploration-exploitation tradeoff" and flag cheaper difficulty prediction as "an important avenue for future work," but do not develop or evaluate any solution.

Mitigation status. Not addressed. The paper suggests future work on training models to predict difficulty directly from question text, but no such model is developed, evaluated, or even sketched. This is the most consequential practical gap between the paper's reported gains and real-world deployability.

---

Hard Problems Remain Essentially Unaffected by Any Amount of Test-Time Compute

The assumption or constraint. The compute-optimal framework assumes the base model has a non-trivial pass@1 rate on the problem—that there are correct solutions somewhere in the proposal distribution to be found or refined. On problems where the base model's pass@1 is near zero, no amount of search or revision can help.

The consequence. Across all methods—search, revisions, and their compute-optimal combinations—the hardest questions (difficulty bin 5) show near-zero improvement regardless of compute budget. In Figure 3 (right), bin 5 accuracy hovers at 1–3% for all methods and all budget levels up to 256 generations. In Figure 7 (right), bin 5 shows roughly 2–3% accuracy irrespective of the sequential-to-parallel ratio. In the FLOPs-matched comparison (Figure 9), the bin 5 scaling line is essentially flat near 0–5%. The paper explicitly states in the Section 7 takeaway:

"we observe that test-time compute is most effective on easier questions... while on very hard questions (difficulty bin 5) test-time compute provides essentially no benefit regardless of budget"

This means test-time compute can amplify existing capability but cannot create it from nothing. For problems fundamentally outside the base model's reach—requiring capabilities that were not acquired during pretraining—no inference-time strategy helps. Practitioners deploying this method on genuinely challenging benchmarks or tasks where models are far from saturation will see minimal returns.

What evidence exists in the paper. The bin 5 results are clearly shown in Figures 3 (right), 7 (right), and 9. The paper is transparent about this limitation and includes it explicitly in the Section 7 discussion. However, the headline $4 \times$ efficiency claims and FLOPs-matched comparisons aggregate across difficulty bins, which can mask the fact that for the hardest subset of problems, neither pretraining scaling nor test-time scaling discussed here would be sufficient—a larger conceptual leap in model capability is required.

Mitigation status. The paper acknowledges the finding but does not offer a solution. The authors note in the Section 7 summary that "on very hard questions, pretraining is more effective," but even the ${\sim}14\times$ larger model's performance on bin 5 is near zero in Figure 9. The limitation is fundamental: scaling compute (whether at training or inference time) within the current paradigm does not solve problems requiring capabilities the base model architecture and training recipe have not acquired. This is not a limitation the paper tries to solve—it is a boundary condition it documents.

---

The Revision Model Exhibits a 38% Correct-to-Incorrect Reversion Rate with No Principled Solution

The assumption or constraint. The revision model is trained exclusively on sequences where all in-context answers are incorrect, followed by a correct target (Section 6.1). During training, the model never sees examples of what to do when the current answer is already correct—it has no signal for "stop revising, this answer is right."

The consequence. At test time, when the revision model encounters a correct answer in its context (produced during an earlier revision step), it may incorrectly "revise" it into a wrong answer. The paper reports that approximately 38% of correct answers get converted back to incorrect ones using a naive approach (Section 6.1):

"the model may encounter correct answers in its context... and incorrectly 'revise' them into wrong answers. The paper reports that approximately 38% of correct answers get converted back to incorrect ones"

This creates a fundamental tension: sequential revisions improve answer quality on average (pass@1 rises from ~18% to ~24% across the chain, Figure 6 left), but each revision step also carries a 38% risk of corrupting a previously correct answer. The paper mitigates this with a post-hoc selection mechanism—majority voting or verifier-based selection across the entire chain of revisions, choosing the best answer from any step rather than always taking the final revision. However, this is a patch, not a solution: it means the system generates many revisions and then discards most of them, wasting the compute spent on revisions that produced worse answers. A more principled approach—training the model to recognize when no revision is needed or to output a confidence score that gates whether to continue—is not explored.

What evidence exists in the paper. The 38% reversion rate is stated in Section 6.1 but is not measured in a controlled ablation. The paper does not report how this rate varies with difficulty, revision depth, or the quality of the initial answer. The mitigation strategy (chain-wide selection) is described but not compared against alternatives like training a binary "stop revising" classifier.

Mitigation status. Partially addressed with a workaround, not a solution. The chain-wide selection mechanism is pragmatic but wastes compute and does not address the root cause (training distribution mismatch). The paper does not discuss or experiment with training the revision model to handle correct in-context answers.

---

Single Benchmark, Single Model Family Limits Generalization Claims

The assumption or constraint. All experiments use the MATH benchmark with PaLM 2-S* as the base model. The paper acknowledges this in Section 4 but argues the model is "representative of the capabilities of many contemporary LLMs." This is an assertion, not a demonstrated fact.

The consequence. Several aspects of the findings could be model-specific or benchmark-specific in ways that are not tested:

• The PRM's quality and over-optimization behavior depend on PaLM 2-S*'s output distribution, calibration, and error patterns. A model with different failure modes—e.g., one that makes different kinds of math errors—might yield different difficulty-dependent scaling curves and a different optimal allocation policy.
• The revision model's ability to learn from incorrect in-context examples depends on the base model's in-context learning capabilities, which vary substantially across model families (some models benefit more from self-generated examples than others).
• The MATH benchmark consists exclusively of competition-level math problems requiring symbolic multi-step reasoning. It is unclear whether the difficulty-dependent patterns (beam search hurting easy problems, revisions helping easy problems, neither strategy helping hard problems) generalize to other reasoning domains (code generation, logical deduction, scientific QA) or to tasks requiring factual recall rather than inference.

A practitioner deploying the compute-optimal framework on a different model (GPT-4, Claude, Gemini, LLaMA) or different task (code generation, summarization, translation) cannot assume the difficulty thresholds, optimal strategy choices, or $4 \times$ efficiency gains will transfer. The entire compute-optimal policy is conditional on the base model's capability profile and the verifier's quality—both are likely model-dependent.

What evidence exists in the paper. None. There are no experiments on any model other than PaLM 2-S* or any benchmark other than MATH. The paper does not discuss how model-specific the findings might be, beyond the single "representative" assertion in Section 4. This is a standard limitation of single-model, single-benchmark studies in the scaling laws literature (the original Chinchilla paper also studied a single model family), but it is more consequential here because the compute-optimal policy involves discrete strategy choices that may not transfer across model families.

Mitigation status. Not addressed. The paper does not suggest multi-model replication as future work, though it does suggest extension to other domains (code generation, etc.) in Section 8.

---

The Test Set Size and Cross-Validation Protocol Limit Statistical Reliability

The assumption or constraint. The paper evaluates on 500 MATH test questions, split into five difficulty quintiles of ~100 questions each. The compute-optimal policy is selected using two-fold cross-validation within each difficulty bin on these 500 questions—meaning the optimal strategy for each bin is chosen based on ~50 questions per fold.

The consequence. With ~50 samples per bin per fold, the selected compute-optimal policy may be noisy. The paper reports that at a given budget, the best strategy achieves accuracy X% on the validation fold, and this strategy is then applied to the test fold—but the standard error on a proportion estimated from 50 samples is approximately ±7 percentage points (for a 0.5 proportion). If two strategies perform similarly on the validation fold, random noise in the 50-sample estimate could cause the suboptimal strategy to be selected. This means the compute-optimal policy reported in Figures 4 and 8 is itself subject to selection noise, and the true optimal policy (with infinite data) might differ.

Furthermore, the paper reports no confidence intervals, standard deviations, or statistical significance tests for any metric. In Figures 3, 4, 6, 7, 8, and 9, all curves are plotted as point estimates without error bars. Given the test set size (500 questions, and smaller within difficulty bins), some of the reported differences between methods—particularly at lower budgets where absolute accuracy differences are small—may not be statistically significant. For example, in Figure 4, the gap between oracle and predicted difficulty bins at 256 generations is approximately 2.5 percentage points (~39.5% vs. ~37%); with ~100 questions per bin, this difference has a standard error on the order of ±5 percentage points and may not be reliable.

What evidence exists in the paper. The test set size (500) is stated in Section 4. The two-fold cross-validation protocol is described in Section 3.2 under "Cross-validation protocol." No confidence intervals, error bars, or hypothesis tests appear anywhere in the paper. The user study (Section 4.4) provides some subjective validation but does not address the statistical reliability of the automated metrics.

Mitigation status. Not addressed. The paper reports all results as point estimates and draws conclusions about method ranking and efficiency gains without quantifying uncertainty. This is a common practice in the LLM scaling literature (where running large-scale experiments makes repeated trials expensive), but it means the quantitative rankings should be interpreted as indicative rather than definitive. A practitioner deciding between two strategies based on a 2-percentage-point difference in the paper's results should be aware that this difference may not be robust.

7. Implications and Future Directions

How This Work Changes the Landscape

MAGREF does not introduce a new generative modeling paradigm—it operates within the established flow-matching diffusion framework and builds on an existing I2V backbone (Wan2.1). Its contribution is narrower but more actionable: it provides a diagnostic framework and architectural toolkit for any-reference video generation that clarifies why prior methods fail on multi-subject scenarios and which mechanisms address each failure mode.

The paper's most significant conceptual move is reframing the any-reference generation challenge as three distinct failure modes—identity inconsistency, subject entanglement, and copy-paste artifacts—each requiring a different type of solution. Identity inconsistency is framed as an injection problem: how reference appearance information physically enters the model. Subject entanglement is framed as a binding problem: how visual features get associated with the correct text concepts. Copy-paste artifacts are framed as a data problem: spurious correlations in training pairs. This diagnostic decomposition is the paper's primary intellectual contribution, and it changes the landscape by giving researchers a vocabulary for analyzing failures that were previously conflated under vague terms like "bad identity preservation."

The field's implicit consensus is challenged on two fronts. First, the paper argues that token-wise reference concatenation—the dominant paradigm in prior transformer-based methods (Concat-ID, VACE, Phantom, HunyuanCustom)—is fundamentally the wrong mechanism for preserving fine-grained identity. The argument is not that token concatenation performs poorly in practice (though the paper shows it does on multi-subject tasks), but that it is architecturally misaligned with the problem: identity features must survive being scattered across a token sequence and reconstructed through learned attention, an indirect and lossy process compared to pixel-aligned channel injection. If this argument holds, it redirects architectural research away from improving attention-based routing and toward spatially grounded conditioning mechanisms.

Second, the paper challenges the instinct to address copy-paste artifacts through architectural modifications (regularization, adversarial losses, etc.) by demonstrating that a data-centric intervention—cross-pair augmentation that breaks spurious foreground-background correlations—can suppress these artifacts without changing the model. This is a methodological claim with implications beyond video generation: it suggests that before modifying an architecture to fix a behavioral flaw, researchers should first examine whether the training distribution inadvertently makes the flawed behavior the path of least resistance. The ablation in Table 4, showing that removing cross-pair data processing degrades performance even with the same architecture, provides concrete evidence for this principle.

The binding problem becomes first-class. Prior to MAGREF, subject entanglement in multi-reference generation was recognized as a problem but not systematically analyzed. Methods either ignored it (single-ID models), hoped cross-attention would solve it implicitly (token-concatenation methods), or addressed it through external modules like Q-Former or MLLM-based reasoning (ConceptMaster, Cinema). MAGREF's Subject Disentanglement mechanism makes binding an explicit architectural operation—injecting text-derived semantic embeddings directly into corresponding spatial regions at the earliest stage of generation. This operationalizes binding as a preconditioning step rather than a learned behavior, and the diagnostic visualization in Figure 4 (cosine similarity between reference regions and text labels) provides a tool for measuring binding quality that future work can adopt.

Reconciling prior contradictions. The paper's framework explains why prior methods showed contradictory strengths. Concat-ID and Phantom maintained reasonable single-ID consistency (token injection carries sufficient information for one subject) but degraded on multi-subject tasks (no explicit binding mechanism prevents confusion). SkyReels-A2 achieved stronger identity through channel concatenation but produced artifacts (no spatial masks to separate subjects from blank canvas). ConsisID excelled at face preservation (specialized frequency features) but could not generalize to non-face subjects (architecture tied to facial structure). Each method solved one failure mode while leaving others unaddressed—MAGREF's contribution is the demonstration that all three must be solved simultaneously, and that they require different categories of intervention.

Research directions that become more attractive. The explicit spatial-semantic binding approach opens a design space for structured conditioning in generative models. Rather than treating all conditioning signals as interchangeable tokens or feature vectors, future architectures might incorporate typed conditioning channels: spatially grounded signals (reference images, layout maps, depth), semantically grounded signals (text, class labels, attributes), and temporally grounded signals (motion vectors, audio). MAGREF's channel concatenation for spatial signals and latent injection for semantic signals provide two templates for how different signal types might enter the model through different pathways.

Research directions that become less attractive. The paper's evidence suggests that purely attention-based routing of reference information (token concatenation without spatial grounding) is unlikely to scale to complex multi-subject scenarios, regardless of how much training data or model capacity is added. The qualitative evidence in Figure 7 (right panel) showing token-wise methods producing "blurred facial features, unstable textures, or even identity drift" even on a strong backbone suggests a ceiling that more scale may not break through. Similarly, coarse channel concatenation without spatial masking (SkyReels-A2's approach) appears to hit a quality ceiling due to channel-level entanglement, as shown in Figure 7 (left panel) and Table 3. These negative results do not render those approaches obsolete—token concatenation remains simpler to implement and may suffice for single-subject or loose-identity applications—but they establish that scaling these methods to the any-reference, high-fidelity regime likely requires the spatial grounding mechanisms MAGREF introduces.

The magnitude of the shift. This is not a paradigm shift in the sense of replacing diffusion models with a new generative framework. It is a reframing with architectural consequences—a reorganization of how the field thinks about the any-reference problem, accompanied by specific mechanisms that operationalize the new framing. The architectural changes are modest (expanded input channels, a latent injection step), the conceptual reorganization is significant, and the practical gains (8–10% Total Score improvement over next-best methods in multi-subject settings, Table 2) are substantial enough to make the approach the new state of the art. The paper's influence will likely be measured by whether subsequent any-reference video generation systems adopt its diagnostic decomposition and whether spatially grounded conditioning becomes a standard design pattern in conditional video generation.

Follow-Up Research This Work Enables

Binding strength calibration with controlled semantic overlap. Subject Disentanglement works by injecting text-derived value embeddings into corresponding spatial regions. A critical open question is how the mechanism behaves when two subjects share semantic attributes—for instance, "a man in a blue shirt and a man in a red shirt." In this case, the text embeddings for "man" are identical for both subjects, so the differentiation relies entirely on the spatial masks. Does MAGREF successfully separate the two men's identities, or does the identical semantic injection cause confusion? A controlled experiment would construct a benchmark of reference-text pairs with systematically varying semantic overlap: distinct labels ("man" / "woman"), shared category labels ("man" / "man"), and shared category with distinguishing attributes ("man in blue" / "man in red"). Measuring per-subject identity preservation (ID-Sim or Subj-Sim separately for each subject rather than averaged) across these conditions would reveal whether Subject Disentanglement provides a genuine binding mechanism or merely a semantic bias that works when labels are distinct. A negative result—significant degradation on shared-label pairs—would motivate augmenting the injection with attribute-level embeddings or incorporating the distinguishing adjectives into the semantic signal.

Scaling behavior with reference count. The paper evaluates on up to three reference images, but the architecture imposes no hard upper bound—the composite canvas can accommodate additional subjects by reducing per-subject spatial allocation or by switching to a multi-frame reference sequence. A systematic scaling study would measure how identity preservation (ID-Sim, Subj-Sim) and visual quality (Aesthetic Score, Motion Smoothness) degrade as the number of references increases from 1 to 10, holding total generation compute constant. The key questions: does performance degrade gracefully (linear or sub-linear) or catastrophically (phase change beyond some threshold), and which component—masked guidance or subject disentanglement—becomes the bottleneck? If the composite canvas's fixed spatial resolution becomes the limiting factor (subjects become too small to preserve fine-grained identity), a multi-frame reference encoding (splitting subjects across multiple composite frames) would be the natural architectural response. This study would define the practical operating range of the method and guide deployment decisions about maximum supported reference counts.

Robustness to imperfect reference segmentation. MAGREF's region-aware masking depends on clean binary masks indicating which pixels belong to reference subjects. During training, these masks come from SAM2's high-quality segmentation (Stages 2–3 of the data pipeline), but at inference time with user-provided references, masks must be estimated from whatever segmentation or bounding box the user provides—or inferred automatically. A stress test would systematically degrade mask quality—adding dilation/erosion noise, introducing false-positive regions, removing true-positive regions, or replacing precise SAM2 masks with coarse bounding-box approximations—and measure the impact on identity preservation and visual quality. If performance degrades sharply under realistic mask noise, it would motivate research into mask-robust training (augmenting training masks with synthetic noise) or mask-free alternatives (learning to infer region boundaries from the composite image alone). The paper does not report any mask sensitivity analysis, making this a high-priority robustness evaluation before production deployment.

Combined training on the same backbone with matched data. The paper compares MAGREF against existing methods that use different backbones, different training data, and different training budgets. To isolate the contribution of MAGREF's architectural mechanisms specifically, a controlled experiment would train multiple conditioning strategies—token concatenation (Phantom-style), vanilla channel concatenation (SkyReels-A2-style), and MAGREF's full masked guidance plus subject disentanglement—on the same Wan2.1 backbone with the same four-stage data pipeline, matched FLOPs, and matched training steps. This would answer whether MAGREF's Total Score advantage over Phantom (0.871 vs. 0.829 in Table 2) comes from the conditioning mechanism or from other factors (data quality, training recipe, backbone version). The paper's Table 3 ablation takes a step in this direction on a small-scale dataset, but a full-scale replication would provide definitive evidence. A negative result—token concatenation performing comparably when given the same data and compute—would substantially weaken the paper's architectural claims while strengthening the data pipeline's contribution.

Extension to long video generation with temporal binding decay analysis. The paper acknowledges (Appendix F.1) that MAGREF does not support controllable long video generation. A natural extension would test how identity preservation decays over extended durations (30 seconds, 60 seconds, several minutes) and whether the subject disentanglement injection—currently applied only to the first frame—needs to be periodically reinforced. The experiment would generate videos of increasing length and measure ID-Sim as a function of temporal distance from the first frame. If identity preservation degrades significantly after some time horizon (e.g., 10 seconds), the result would motivate a recurrent injection mechanism that periodically re-applies subject disentanglement at keyframes, or a temporal attention modification that maintains stronger long-range identity pathways. This connects to the broader problem of temporal consistency in video generation, where MAGREF's spatial binding mechanisms might be extended to temporal binding.

Cross-domain generalization: code, audio, 3D. The paper's diagnostic decomposition—injection, binding, data—is formulated for video generation but may apply to other conditional generation domains where multiple references must be composed. A replication study on multi-speaker audio generation (reference voice samples → mixed audio with each speaker at specified times), multi-character 3D scene generation (reference character models → composed scene with interactions), or multi-component code generation (reference code snippets → integrated program) would test the generality of the framework. In each domain, the injection mechanism would need adaptation (channel concatenation for 1D audio? spatialized features for 3D?), the binding mechanism would need a domain-appropriate semantic signal (speaker diarization labels, entity names, function signatures), and the data pipeline would need domain-specific augmentation. A successful cross-domain replication would elevate MAGREF from a video-specific architecture to a general template for compositional conditional generation.

Practical Applications and Downstream Use Cases

User-facing content creation tools with multi-subject composition. The most direct application is in video generation products where users upload personal reference photos—themselves, family members, pets, specific clothing items, vacation locations—and generate videos that faithfully compose these elements according to a text prompt. MAGREF's feed-forward design (no per-identity fine-tuning) makes it suitable for interactive applications where references change with every query. The benchmark numbers (Tables 1–2) suggest that on typical user scenarios involving 1–3 subjects, MAGREF achieves Total Scores of 0.841 (single-ID) and 0.871 (multi-subject), with ID-Sim of 0.921 (single) and 0.687 (multi)—meaning identity preservation is strong for single subjects and competitive for multi-subject compositions. For product teams building "virtual try-on," "personalized greeting," or "family video" features, the framework provides a starting architecture that explicitly handles the binding problems such features face.

Training data generation for downstream vision tasks. An organization needing training data for multi-person interaction recognition, person-object relationship detection, or identity-consistent person re-identification could use MAGREF to generate synthetic videos with controlled identity, pose, clothing, and interaction labels. The four-stage data pipeline already demonstrates this capability in reverse (extracting references from real videos); running it forward would produce labeled synthetic data where ground-truth identities, bounding boxes, and interaction labels are known by construction. The key advantage over existing synthetic data generators is that subjects maintain identity across frames by design (via the masked guidance mechanism) and across different scenes (via the same reference images conditioning multiple generations). The paper does not evaluate MAGREF as a data generator, but the architecture's identity preservation capabilities (ID-Sim of 0.921 single, 0.687 multi-subject) are directly relevant to this use case.

Amortized personalization for batch processing. While the paper positions MAGREF as a feed-forward alternative to per-identity tuning, a hybrid deployment could use MAGREF for rapid batch generation where many different subject combinations must be rendered (e.g., generating personalized marketing videos for thousands of customers, each with a reference photo and a template prompt). In this setting, the training cost is amortized across all users, and the inference cost per video is a single forward pass—unlike DreamBooth or LoRA methods that would require thousands of fine-tuning runs. The paper does not report inference time, but given that MAGREF builds on Wan2.1 with only an expanded input projection layer (channel count increased from C to 2C + C_m), the per-step computational overhead relative to the base model is modest—dominated by the VAE encoding of the composite reference image and the subject disentanglement latent injection, both of which are negligible compared to the diffusion transformer's forward passes.

When to Prefer This Method

The paper does not explicitly articulate a decision framework for choosing MAGREF over named alternatives. It evaluates against 12 methods and reports superior aggregate metrics, but does not characterize when a practitioner should prefer MAGREF versus, say, Phantom (simpler architecture, token concatenation) or a per-identity fine-tuning approach like DreamBooth (higher single-subject quality at the cost of per-identity training). The implicit positioning is that MAGREF is preferable when all three conditions hold:

• Multiple subjects must be generated in the same video, because subject entanglement is the primary failure mode that MAGREF's Subject Disentanglement addresses, and this failure mode does not exist in single-subject settings.
• Feed-forward inference without per-identity tuning is required, because MAGREF processes arbitrary references in a single forward pass after one-time training, unlike DreamBooth/LoRA methods that require per-subject fine-tuning.
• Fine-grained identity preservation matters more than absolute aesthetic quality, because MAGREF leads on ID-Sim and Subj-Sim but trails proprietary models (Vidu, Pika, Kling) on Aesthetic Score in both single-ID and multi-subject settings (Tables 1–2).

The paper does not provide guidance for the reverse scenario—when a practitioner should prefer Phantom, SkyReels-A2, or a tuning-based approach—and constructing such a matrix would require experiments the paper does not conduct (e.g., comparing MAGREF against DreamBooth on single-ID quality at matched compute, or evaluating Phantom with the same four-stage data pipeline to isolate architecture from data effects). The absence of FLOPs-matched or latency-controlled comparisons makes it impossible to weigh MAGREF's quality advantages against any computational overhead from the expanded input channels and subject disentanglement injection.