NextFlow: Unified Sequential Modeling Activates Multimodal Understanding and Generation

ArXiv: 2601.02204

🎯 Pitch

A single autoregressive transformer can now generate high-quality 1024×1024 images in just 5 seconds—by predicting visual scale rather than pixel order. This unified model matches specialized diffusion systems in visual quality while natively adding image editing and understanding, cracking open a path to truly general multimodal AI.

1. Executive Summary

This paper introduces NextFlow, a unified decoder-only autoregressive transformer that natively activates both multimodal understanding and generation by processing 6 trillion interleaved text-image discrete tokens. Built on Qwen2.5-VL-7B and evaluated across text-to-image benchmarks (GenEval, DPG, WISE, PRISM-Bench), image editing suites (ImgEdit, OmniContext, GEdit-Bench, EditCanvas), and multimodal understanding tasks, NextFlow departs from traditional raster-scan autoregression by adopting next-scale prediction for visual generation (generating images hierarchically from coarse structural layouts to fine-grained details) paired with a dual-codebook tokenizer that decouples semantic and pixel-level features. This design achieves generation of 1024 × 1024 images in roughly 5 seconds—approximately 6× fewer FLOPs than MMDiT-based diffusion models at the same resolution—while matching or surpassing specialized diffusion baselines on GenEval (0.84 overall with RL, tying Qwen-Image) and establishing new state-of-the-art results on image editing (4.49 overall on ImgEdit). The paper further introduces a prefix-tuning strategy for GRPO that stabilizes reinforcement learning by restricting policy optimization to the coarse-scale prefixes that determine global image structure, establishing that a purely autoregressive architecture can rival diffusion models in visual quality when the generation paradigm is restructured around scale rather than raster order, though the approach remains fundamentally bounded by the information bottleneck of discrete vector quantization on the hardest fine-grained detail tasks.

2. Context and Motivation

The Core Problem: Unification of Multimodal Understanding and Generation Remains Fragmented

The fundamental challenge this paper tackles is the architectural fragmentation of multimodal AI systems. Despite remarkable progress in both large language models (LLMs) for text understanding and diffusion models for visual generation, these capabilities have evolved along separate trajectories, creating systems that excel in one modality but cannot seamlessly integrate with the other. A model that can reason about an image cannot necessarily generate one, and a model that can generate photorealistic images typically lacks the logical reasoning and instruction-following capabilities of an LLM.

This separation is not merely an inconvenience — it represents a fundamental architectural gap. As the authors articulate in Section 1:

"diffusion models excel at pixel-level fidelity but lack the inherent logical reasoning and in-context learning capabilities of LLMs, whereas traditional multimodal LLMs are often restricted to perception only."

The implication is that truly general intelligence requires a system that can perceive, reason about, and create across modalities within a single unified framework — not as a pipeline of specialized components stitched together. This is the problem NextFlow addresses: how to build a single decoder-only transformer that achieves competitive performance on both visual understanding (answering questions about images) and visual generation (creating images from text descriptions) without compromising either capability.

The Two Existing Paradigms and Their Limitations

The paper situates itself at the intersection of two distinct research streams, each with fundamental limitations that prevent true unification.

Hybrid AR-Diffusion Architectures

Recent work including Transfusion (Zhou et al., 2024) and Bagel (Deng et al., 2025) demonstrated that combining autoregressive text modeling with diffusion-based image generation can yield promising results for unified understanding and generation. These systems typically use separate representations for text (discrete tokens) and images (continuous latents), with different training objectives for each modality.

However, the authors identify a critical limitation of this approach:

"the reliance on two different representations creates a gap between generation and understanding. This separation imposes re-encoding overheads for interleaved tasks and might fundamentally constrain the potential for deep multimodal integration."

This "gap" is more than an implementation detail. When a model uses continuous latents for image generation but discrete tokens for text understanding, tasks that require interleaving the two — such as generating a coherent alternating sequence of text descriptions and corresponding images, or performing chain-of-thought reasoning that involves both verbal and visual steps — become architecturally awkward. The model must constantly translate between representation spaces, which adds computational overhead and prevents end-to-end gradient flow across modalities. This is why the authors position pure autoregressive approaches as potentially superior: they treat every modality as a single sequence of discrete tokens, enabling seamless interleaving without representation switching.

Pure Autoregressive Models (Raster-Scan)

On the other side, purely autoregressive models like Chameleon (Team, 2024), EMU3 (Wang et al., 2024), and EMU3.5 (Cui et al., 2025) demonstrated that a single transformer could theoretically handle both text and images by converting everything into discrete tokens and applying next-token prediction uniformly. This vision is appealing in its simplicity: one architecture, one training objective (cross-entropy loss), one sequence of tokens.

However, the paper identifies two fundamental bottlenecks that have prevented these models from being practically competitive with diffusion approaches:

Bottleneck 1: Prohibitive Computational Cost at High Resolutions. The standard approach to autoregressive image generation is raster-scan order — flattening an image into a 2D grid of tokens and predicting them one by one, left-to-right, top-to-bottom. This is the natural extension of how LLMs process text. But unlike text, where sequence length grows linearly with the number of words, the sequence length of flattened visual tokens grows quadratically with image resolution. A 1024 × 1024 image encoded with a typical VQ tokenizer (e.g., 16× downsampling) produces 64 × 64 = 4,096 tokens. But generating each token requires a forward pass through the entire transformer, meaning the computational cost scales as $O(N^2)$ with resolution where $N$ is the number of tokens per dimension. As the authors note:

"generating a single 1024 × 1024 image via raster-scan autoregression can take over 10 minutes [13, 74], making these models significantly slower than their diffusion counterparts and impractical for interactive applications."

This is not a minor inefficiency — it fundamentally disqualifies raster-scan AR models from real-world deployment in any latency-sensitive application (e.g., interactive image editing, real-time generation). Diffusion models, by contrast, process all tokens in parallel at each denoising step, making them dramatically faster at high resolutions despite requiring multiple iterative steps.

Bottleneck 2: Semantic Gap from Reconstruction-Oriented Tokenizers. The second bottleneck is more subtle but equally important. Pure AR models typically use VQ-VAE-based tokenizers trained to reconstruct images from discrete codes. These tokenizers optimize for pixel-level reconstruction fidelity — the ability to compress an image into discrete indices and decode it back with minimal distortion. However, the resulting discrete codes often lack high-level semantic density:

"While these tokenizers optimize for pixel-level fidelity, the resulting discrete codes often lack high-level semantic density. This semantic gap fundamentally limits the model's performance on multimodal understanding tasks, as the visual tokens fail to capture the abstract concepts necessary for complex reasoning and alignment with the textual latent space."

This is a crucial insight. Multimodal understanding tasks (e.g., answering "Why is this image funny?" or "What will happen next in this scene?") require the model to extract abstract concepts from visual inputs — humor, causality, social context, spatial relationships. If the tokenizer's codes are designed primarily to reconstruct pixels (edges, textures, colors), they may not capture these higher-level semantic properties in a way that is accessible to the language model. The visual tokens become impoverished input representations for reasoning, even if they faithfully preserve pixel information.

This explains a pattern observed across prior work: pure AR models often achieved reasonable image generation quality (since generation only requires the model to produce tokens the decoder can reconstruct) but consistently underperformed on visual understanding benchmarks compared to models with dedicated vision encoders (since understanding requires rich semantic representations). The tokenizer acts as an information bottleneck between the visual world and the language model, and reconstruction-oriented training does not guarantee that semantically meaningful information survives the compression.

How NextFlow Positions Itself

NextFlow's contribution is not a single novel technique but rather a systematic re-engineering of the pure autoregressive paradigm to address both bottlenecks simultaneously, making it practically competitive with diffusion approaches while retaining the architectural elegance of a unified decoder-only transformer.

Against the raster-scan bottleneck: NextFlow adopts next-scale prediction (building on VAR; Tian et al., 2024), which restructures autoregressive generation from a pixel-by-pixel raster order to a coarse-to-fine hierarchical order. Instead of generating a 64×64 grid token-by-token in spatial order, the model first generates a 1×1 grid capturing the overall image layout, then a 2×2 grid refining the structure, then 4×4, 8×8, and so on up to 64×64. Each scale step generates an entire grid of tokens in parallel (within that scale), conditioned on all previous (coarser) scales. This fundamentally changes the computational scaling:

• Raster-scan: $N^2 \times N^2 = N^4$ sequential token generations for an $N \times N$ grid (each of the $N^2$ positions requires a separate forward pass).
• Next-scale: $\sum_{k=1}^K s_k$ sequential scale steps, where $s_k$ is the number of tokens at scale $k$, but tokens within each scale are generated in one forward pass. The total sequential steps are $O(\log N)$ rather than $O(N^2)$.

The consequence is dramatic: the authors report generation of 1024 × 1024 images in roughly 5 seconds, compared to over 10 minutes for raster-scan counterparts — a >100× speedup. This brings AR models into the same efficiency regime as diffusion models, removing the primary practical barrier to deployment.

Against the semantic gap bottleneck: NextFlow employs a dual-codebook tokenizer (building on TokenFlow; Qu et al., 2025) that decouples semantic and pixel-level features into separate codebooks. One codebook captures high-level semantic concepts (distilled from a semantic teacher model like SigLIP), while the other captures pixel-level visual details. Both are learned jointly with shared constraints that maintain alignment between the two representations. This means the discrete tokens fed to the transformer carry both the abstract conceptual information needed for reasoning and the fine-grained visual information needed for high-fidelity reconstruction — addressing the core limitation of reconstruction-only tokenizers.

The authors demonstrate empirically (Figure 8) that this dual-branch design leads to significantly better generative performance than a single-branch VQGAN tokenizer, even when the single-branch variant achieves slightly higher raw reconstruction PSNR. The interpretation is that semantic constraints shape a latent space that is structurally easier for the autoregressive model to learn, even if it is slightly harder for the decoder to reconstruct.

Against hybrid architectures: NextFlow's purely autoregressive design (unlike Transfusion or Bagel) means there is no representation gap between modalities. Text and visual tokens are processed identically through the same transformer layers with the same output head. This enables seamless interleaved generation — alternating text paragraphs and images in a single coherent output — which hybrid architectures struggle with due to the need to switch between discrete and continuous generation modes. It also means standard LLM techniques (reinforcement learning, chain-of-thought prompting, in-context learning) transfer directly to the visual generation setting, which the authors exploit with their GRPO prefix-tuning strategy and CoT reasoning experiments.

Why This Matters: Practical and Theoretical Significance

The paper's motivation extends beyond technical novelty to address concrete deployment and research implications:

Practical impact — interactive visual AI. A model that can both understand and generate images within a single architecture enables applications that are awkward or impossible with separate systems. Consider an AI assistant that can: (a) analyze a user's uploaded photo, (b) reason about what editing operations are needed based on a natural language request ("make the lighting warmer and remove the person in the background"), (c) generate the edited result, (d) explain what it changed and why — all within a single model, with no pipeline switching. The speed requirement (5 seconds per 1024×1024 image) makes this feasible for interactive use, unlike previous AR models that were too slow.

Theoretical significance — resolving the AR-diffusion debate in practice. The paper positions itself as empirical evidence that a purely autoregressive architecture can match state-of-the-art diffusion models when the generation paradigm and tokenizer design are properly engineered. This is not obvious or widely accepted — the dominant narrative in 2024-2025 has been that diffusion models are inherently superior for visual generation, and that AR models, while conceptually elegant, are forced to choose between speed and quality. NextFlow challenges this narrative by showing that the apparent limitations of AR models were artifacts of specific design choices (raster-scan order, reconstruction-only tokenizers) rather than fundamental properties of autoregressive modeling.

Training efficiency and simplicity. The authors emphasize the infrastructure benefits of a unified architecture. In a purely AR system, training is conceptually simple: everything is cross-entropy loss over discrete tokens, with no need for separate training objectives, separate optimization schedules, or complex multi-phase training pipelines that balance different loss terms (as is common in diffusion models). The paper's training pipeline (Section 3) is certainly complex — spanning alignment, multi-stage pre-training, continue-training, SFT, and RL — but the underlying objective remains uniform throughout. This simplicity may enable more efficient scaling, as the entire model capacity is devoted to a single task (predicting the next token in a multimodal sequence) rather than being partitioned across modalities.

Enabling new capabilities through architectural unification. A key motivation that distinguishes this paper from pure generation papers is the emphasis on capabilities that emerge specifically from unification: chain-of-thought reasoning for visual generation (where the model "thinks" about a prompt before drawing), in-context learning for image editing (where the model infers a transformation pattern from example image pairs and applies it to a new input), and interleaved text-image storytelling. These capabilities are not impossible in hybrid architectures, but they are more natural and efficient in a system where text and images inhabit the same token space and are processed by the same mechanism.

The Specific Gap This Paper Fills

Prior to NextFlow, the landscape of multimodal models could be described as:

1. Understanding-only models (LLaVA-style, Qwen2.5-VL) that could perceive images but not generate them.
2. Generation-only models (Stable Diffusion, FLUX) that could create images from text but not reason about existing ones.
3. Unified hybrid models (Transfusion, Bagel) that could do both but with separate representations, creating friction for interleaved tasks.
4. Unified pure AR models (Chameleon, EMU3, Janus) that used a single representation but were prohibitively slow at high resolutions and suffered from semantic deficits in the tokenizer.

NextFlow aimed to fill the gap between categories 3 and 4: achieving the architectural purity of pure AR models (single representation, single objective) while matching or exceeding the practical performance of hybrid models and specialized diffusion systems. The key innovations to bridge this gap are the next-scale prediction paradigm (addressing speed) and the dual-codebook tokenizer (addressing semantic quality) — both building on prior work but integrated into a systematic training recipe validated at unprecedented scale (6 trillion tokens).

The authors frame this not as incremental improvement but as establishing a new design point:

"NextFlow serves as a proof of concept that a single decoder-only transformer can effectively perceive, reason, and create."

The phrase "proof of concept" is deliberate — it acknowledges that there remain limitations (the information bottleneck of discrete quantization, the capacity challenges of a 7B model doing both understanding and generation) but argues that the fundamental viability of the approach is now demonstrated, and that further scaling along the axes identified in the conclusion (data quality, model size via MoE, improved tokenization) represents a clear path forward.

3. Technical Approach

3.1 Reader Orientation

What the system is: NextFlow is a single 7-billion-parameter decoder-only transformer that takes a sequence of interleaved text and image tokens as input and produces a sequence of interleaved text and image tokens as output — it is simultaneously a language model, an image generator, an image editor, and a multimodal reasoning engine, all within one architecture.

What problem it solves and the shape of the solution: The paper tackles the fundamental incompatibility between two facts: (1) autoregressive transformers are the dominant architecture for language tasks, and (2) autoregressive models have been prohibitively slow and semantically weak for high-resolution image generation. The solution reshapes autoregressive image generation from a per-token raster-scan order into a coarse-to-fine hierarchical order — generate the overall structure first, then progressively fill in details — paired with a tokenizer that separately encodes semantic meaning and pixel-level appearance. The "shape" of the solution is: replace $O(N^4)$ sequential operations with $O(\log N)$ scale steps, while enriching the discrete token vocabulary so that visual codes carry the abstract concepts needed for reasoning, not just the pixel information needed for reconstruction.

3.2 Big-Picture Architecture (Diagram in Words)

The system has six major components, arranged in a pipeline from raw pixels/text to generated pixels/text:

1. Dual-Codebook Tokenizer (Section 2.1): converts images into two parallel streams of discrete tokens — a semantic codebook that captures high-level concepts (objects, relationships, scene type) by distilling from a pretrained SigLIP2 visual encoder, and a pixel codebook that captures fine-grained visual details (textures, edges, colors) via CNN-based encoding/decoding. Text is tokenized with a standard text tokenizer. The output is a single sequence of interleaved text tokens and paired (semantic, pixel) visual index tuples.

2. Multiscale 3D Rotary Position Embedding (RoPE) (Section 2.2): injects positional information into the transformer's attention layers that encodes three dimensions for every token: (x, y) spatial coordinates for visual tokens (normalized to a fixed range [0, C] to handle variable resolutions) and a scale index that indicates which hierarchical resolution level this token belongs to. Text tokens receive diagonal positions (t, t, t). This enables the model to distinguish which tokens come from which spatial location and which scale, which is critical for the next-scale prediction paradigm.

3. Decoder-Only Transformer Backbone (Section 2.2): a standard autoregressive transformer (initialized from Qwen2.5-VL-7B) with a single shared output head that predicts both text tokens and visual codebook indices. The model processes the entire interleaved sequence causally — each token can attend to all previous tokens in the sequence — and is trained with standard cross-entropy loss over the unified vocabulary.

4. Next-Scale Prediction Mechanism (Section 2.2, 3.2): rather than generating visual tokens one-by-one in raster order, the model generates visual content hierarchically. At each "scale step," the model produces an entire grid of tokens at a given resolution (e.g., 1×1 → 2×2 → 4×4 → ... → 64×64), conditioned on all previously generated (coarser) scales. Tokens within a single scale are generated in parallel (in one forward pass), but scales are generated sequentially from coarsest to finest.

5. Scale Reweight and Self-Correction (Section 2.2, 3.2): two training-time mechanisms that stabilize the next-scale prediction process. Scale reweighting assigns higher loss weights to earlier (coarser) scales to prevent the model from ignoring structural layout in favor of abundant fine-scale detail tokens. Self-correction trains the model to handle exposure bias — the mismatch between teacher-forcing during training (where the model conditions on ground-truth previous scales) and autoregressive inference (where the model conditions on its own potentially suboptimal previous-scale predictions).

6. Optional Diffusion Decoder (Section 2.3, 3.3): a post-processing refinement module that takes the discrete visual token embeddings (from both semantic and pixel codebooks) and runs them through a diffusion model (UNet or Transformer-based) to regenerate the image with higher perceptual fidelity, particularly for challenging details like small faces and text. This is analogous to a super-resolution stage and is disabled by default for most evaluations.

Information flows as follows: raw image → dual-codebook tokenizer (produces semantic + pixel indices) → interleave with text tokens → add Multiscale 3D RoPE → autoregressive transformer processes sequence → at generation time, the model produces visual tokens scale-by-scale from coarse to fine → VQ decoder (or optional diffusion decoder) reconstructs pixels from visual indices → output image. For text generation, the process is standard next-token prediction within the same sequence.

3.3 Roadmap for the Deep Dive

This is primarily an architectural design and training methodology paper whose core idea is that a properly designed autoregressive model — with hierarchical generation and semantically enriched tokenization — can match or exceed diffusion models across understanding and generation.

The deep dive will proceed in this order:

• First, the dual-codebook tokenizer design (Section 3.4.1) — since it defines the discrete vocabulary that the transformer operates over, determines the sequence length (and thus computational cost), and sets the information ceiling for both understanding and generation.

• Second, the Multiscale 3D RoPE positional encoding (Section 3.4.2) — since it is the mechanism that enables the transformer to understand the spatial and hierarchical structure of visual tokens, which is essential for the next-scale prediction paradigm.

• Third, the next-scale prediction mechanism (Section 3.4.3) — the core architectural innovation that replaces raster-scan generation, including the generation schedule (how many scales, what resolutions), the training objective (scale-reweighted cross-entropy), and the self-correction strategy for handling exposure bias.

• Fourth, the transformer architecture design choices (Section 3.4.4) — the shared output head, initialization from Qwen2.5-VL, and the handling of interleaved text-image sequences as a unified sequence.

• Fifth, the optional diffusion decoder (Section 3.4.5) — how it integrates with the discrete token representations and the trade-offs it introduces.

• Sixth, the training pipeline (Section 3.4.6) — the full chronological recipe (alignment, multi-stage pre-training, continue-training, SFT, RL with prefix-tuning GRPO) organized as a single complete narrative, since the training stages are interdependent and build on each other.

3.4 Detailed, Sentence-Based Technical Breakdown

NextFlow is fundamentally a systems paper that demonstrates how to make a pure autoregressive multimodal model competitive through careful engineering of the tokenizer, generation paradigm, and training recipe. The core intellectual contribution is the synthesis of several existing techniques (dual-codebook tokenization from TokenFlow, next-scale prediction from VAR, GRPO from DeepSeekMath) into a coherent framework validated at 6 trillion tokens of training data.

3.4.1 Dual-Codebook Tokenizer: Decoupling Semantics from Pixels

The tokenizer is the foundation of any autoregressive visual model because it determines what "alphabet" of discrete tokens the transformer learns to predict. NextFlow's tokenizer, building on TokenFlow (Qu et al., 2025), is designed to solve a specific problem: standard VQ-VAE tokenizers optimize for pixel reconstruction fidelity, producing codes that are numerically efficient for compression but semantically impoverished for reasoning. The dual-codebook design separates these two objectives into parallel encoding streams.

Architecture. The tokenizer has four sub-components:

1. Semantic Encoder: initialized from SigLIP2-so400m-naflex, a pretrained vision-language model that produces continuous embeddings capturing high-level semantic content. The upgrade to SigLIP2 (from the original TokenFlow's SigLIP-so400m) enables native handling of variable resolutions and aspect ratios — crucial for a system that generates images at diverse sizes.

2. Pixel Encoder: a CNN-based architecture trained from scratch that focuses on low-level visual features (edges, textures, colors). This is a standard VQ-VAE encoder designed for reconstruction fidelity.

3. Dual Codebooks: two separate learned vector quantizers. The semantic codebook quantizes the output of the semantic encoder into discrete indices, while the pixel codebook quantizes the output of the pixel encoder. The key design choice is that the quantization process is jointly constrained by both reconstruction fidelity and semantic consistency — during codebook lookup, the distance metric is a weighted sum of semantic distance (to the semantic teacher's features) and pixel distance (to the original image), not just pixel distance as in standard VQ-VAE.

4. Pixel Decoder: a CNN that reconstructs the image from the quantized pixel codes. The authors increase the decoder capacity (doubling it following architectural insights from Muse (Chang et al., 2023) and TokenFlow) to reduce local artifacts and improve fine details.

Training procedure. The tokenizer training uses a three-stage strategy designed to prevent the semantic encoder from dominating early optimization:

• Stage 1 — Pixel branch pre-training: The pixel encoder, pixel codebook, and pixel decoder are trained independently to establish strong reconstruction capabilities. This avoids the problem in the original TokenFlow where the pretrained semantic encoder's features dominated the optimization landscape from the start, limiting the pixel branch's ability to learn.

• Stage 2 — Joint training: All components (semantic encoder, pixel encoder/decoder, both codebooks) are initialized from their respective pre-trained checkpoints and trained jointly with the combined reconstruction + semantic consistency loss. Starting from a good initialization for both branches accelerates convergence and improves final performance.

• Stage 3 — Pixel decoder doubling: The pixel decoder capacity is doubled and fine-tuned separately. This stage substantially reduces local artifacts and enhances fine details such as small faces and text — the hardest regions for compressed discrete representations to capture.

Additional training details: the tokenizer is trained on high-fidelity images with oversampling of face-containing samples to improve facial detail preservation. The authors randomly drop 50% of VAR scales during training (meaning some scales are excluded from the encoding/decoding process), which they find "enhances the robustness of numerical distributions in the codebook and results in better reconstruction." They also enforce fp32 precision during the quantization step to maintain numerical stability — a practical detail reflecting the sensitivity of vector quantization to floating-point errors at large codebook sizes.

Why dual-codebook over single-codebook VQ-VAE? The authors provide an explicit ablation (Figure 8) comparing their dual-branch TokenFlow-style tokenizer against a standard single-branch VQGAN. The single-branch baseline achieves marginally higher raw reconstruction PSNR (+0.5 dB at 256² resolution), which is expected since it optimizes purely for pixel fidelity. However, under identical generative model training protocols (40k steps, ~40M samples), the dual-branch tokenizer achieves significantly lower vision loss and consistently superior GenEval scores. The interpretation is that the semantic constraints in the dual-branch architecture shape a latent space that is structurally easier for the autoregressive model to learn, even though that latent space is slightly harder for the decoder to reconstruct. This aligns with findings in REPA (Yu et al., 2024) and VA-VAE (Yao et al., 2025) — semantic alignment in the latent space acts as a regularization that prevents the discrete codes from overfitting to pixel-level idiosyncrasies, producing a more compressible and learnable representation.

The multi-scale VQ design (applying quantization at multiple resolutions, as in VAR) further enhances reconstruction quality by allowing the codebook to specialize at different spatial scales. Scale settings are detailed in Appendix A.1.

3.4.2 Multiscale 3D Rotary Position Embedding (RoPE)

Positional encoding is a critical design decision in any transformer, but in NextFlow it takes on heightened importance because the model must simultaneously understand: (a) the sequential order of text tokens, (b) the 2D spatial positions of visual tokens, and (c) which hierarchical scale each visual token belongs to — all within a single unified sequence. The standard approach of using 1D positional indices would confuse spatial structure with sequence order (making the model think two spatially adjacent tokens are semantically related just because they appear consecutively in the flattened sequence).

Three-dimensional positions. NextFlow introduces a 3D RoPE that assigns each token a position vector in $\mathbb{R}^3$, with each dimension encoding a different type of positional information:

$\text{position} = (p_x, p_y, p_s)$

where $p_x$ and $p_y$ are spatial coordinates and $p_s$ is the scale index.

For text tokens at sequence position $t$, the three dimensions are simply replicated: $(t, t, t)$. This collapses the 3D encoding to a 1D sequential encoding that matches standard RoPE behavior, ensuring that text processing is unaffected by the added spatial dimensions.

For visual tokens, the spatial coordinates are computed as normalized positions within the image:

$(p_x, p_y) = \left(\frac{C}{\sqrt{HW}}(i + 0.5), \frac{C}{\sqrt{HW}}(j + 0.5)\right)$

where $(i, j)$ are the grid coordinates of the patch at scale $s$, $H \times W$ is the grid size at that scale, and $C$ is a constant range factor (omitted in Figure 5 for clarity).

What this computes: Each visual token receives a spatial position that maps its grid location $(i, j)$ to a fixed coordinate range $[0, C]$, regardless of the actual resolution $H \times W$. The 0.5 offset centers the positional encoding within each patch rather than anchoring it to the patch corner. The scale index $s$ is appended as the third dimension.

Why this form: The key property is resolution invariance. By normalizing all spatial positions to the same range $[0, C]$, grids of different resolutions (e.g., 16×16 and 32×32) share the same coordinate space. This eliminates the need for positional extrapolation when the model encounters higher-resolution images during training — for example, when transitioning from 256-res pre-training to 512-res pre-training. If positions were absolute pixel coordinates, a 32×32 grid would use position values the model never saw during 16×16 training, requiring the model to extrapolate its positional embeddings to unseen values. With normalized coordinates, the 32×32 grid simply samples more densely within $[0, C]$, using positions the model has already learned. The 0.5 offset centers the position within the patch, which is important for the autoregressive prediction task — the model needs to understand that the patch represents the center of its spatial region, not its corner.

Additional learnable components. Beyond the 3D RoPE base encoding, NextFlow adds two complementary positional signals:

1. Learnable scale embeddings: Following VAR, each scale receives a dedicated learnable embedding that is added to the token embeddings, allowing the model to learn scale-specific processing strategies (e.g., "at scale 1, focus on global layout; at scale 10, focus on fine textures").

2. Sinusoidal scale length embeddings: A separate sinusoidal encoding over the number of scales in the generation schedule. This disambiguates the target output resolution — for example, a 256×256 image uses 12 scale steps while a 1024×1024 image uses 18 scale steps. The model needs to know how many scales it should generate to produce a coherent schedule. The sinusoidal encoding takes the total number of scales $K$ and encodes it as a continuous signal:

$\text{PE}(k, 2i) = \sin(k / 10000^{2i/d})$ $\text{PE}(k, 2i+1) = \cos(k / 10000^{2i/d})$

where $k$ is the scale index and $d$ is the embedding dimension. This allows the model to generalize across different generation schedules — it can produce images at resolutions it wasn't explicitly trained on by interpolating between learned scale length embeddings.

The combination of 3D RoPE (spatial + scale position) with learnable scale embeddings and sinusoidal scale length encoding gives the model a complete positional description for every token: where it is spatially, which resolution level it belongs to, and how many resolution levels the overall generation process will use.

3.4.3 Next-Scale Prediction: The Core Generation Mechanism

The next-scale prediction paradigm (borrowed from VAR, Tian et al., 2024) is the architectural innovation that makes NextFlow practically fast enough to compete with diffusion models. Rather than generating a 2D grid of visual tokens one token at a time in raster order (left-to-right, top-to-bottom), the model generates entire scale grids at progressively higher resolutions.

Generation schedule. The generation process follows a predetermined scale schedule that defines the spatial resolution at each step. For a 1024 × 1024 image with the 1:1 aspect ratio (from Appendix A.1, Table 14):

$\text{Schedule}_{1:1} = \{(h_1, w_1), (h_2, w_2), ..., (h_{18}, w_{18})\}$

where the resolutions progress as: (1,1) → (2,2) → (3,3) → (4,4) → (5,5) → (6,6) → (7,7) → (8,8) → (10,10) → (12,12) → (14,14) → (16,16) → (20,20) → (24,24) → (28,28) → (32,32) → (48,48) → (64,64). The total number of steps $K = 18$ for 1024-level resolution. For 512-level, the model uses the first 16 scales; for 256-level, the first 12 scales.

Key design property of the schedule: The spatial area $h_k \times w_k$ at each scale $k$ is approximately constant across different aspect ratios. For instance, a 1:1 image at scale 10 has a 10×10 = 100 grid, while a 4:1 image at the same scale has a 20×5 = 100 grid. This means all images, regardless of aspect ratio, have similar sequence lengths at each scale, which is essential for efficient batched training (no padding or truncation waste from variable-length sequences).

Generation process. At each scale step $k$, the model:

1. Receives as context all previously generated tokens — text tokens plus visual tokens from scales $1$ through $k-1$.
2. Generates the entire $h_k \times w_k$ grid of visual tokens in parallel — all positions within this scale are predicted in a single forward pass (the autoregressive decoding loop iterates over positions within the scale, but since they condition only on previous tokens, they can be generated sequentially with KV-caching making the per-token cost amortized).
3. Each position generates a pair of tokens: one from the semantic codebook and one from the pixel codebook.
4. The generated scale-$k$ tokens are appended to the sequence and become available as context for scale $k+1$.

This process starts from the coarsest scale (1×1 grid — a single token representing the global image layout) and progressively refines to the finest scale (64×64 = 4096 tokens for 1024×1024 images).

Why next-scale instead of raster-scan? The computational argument is central. In raster-scan, generating a 64×64 grid requires 4096 sequential forward passes through the transformer, each generating exactly one token. The total computational cost is:

$\text{FLOPs}_{\text{raster}} = \sum_{n=1}^{4096} \text{FLOPs}(n) \approx O(N^4)$

where $\text{FLOPs}(n)$ is the cost of a forward pass with sequence length $n$, and $N = 64$ is the grid dimension.

In next-scale prediction, the cost is:

$\text{FLOPs}_{\text{next-scale}} = \sum_{k=1}^{18} \left(h_k \times w_k\right) \cdot \text{FLOPs}\left(\sum_{j=1}^{k-1} h_j \times w_j + h_k \times w_k\right) \approx O(N^2 \log N)$

The asymptotic improvement comes from two factors: (1) the number of sequential steps is 18 instead of 4096 (a $\sim$227× reduction), and (2) early steps operate on very short sequences (the 1×1 step has sequence length 1), making them extremely cheap.

The paper quantifies this in Appendix A.2, showing that for a 1024×1024 image with hidden size $h = 4096$, the FLOPs ratio is:

$\frac{\text{FLOPs}_{\text{MMDiT}}}{\text{FLOPs}_{\text{NextFlow}}} \approx \frac{6.18 \times 10^{12}}{1.04 \times 10^{12}} \approx 5.96$

MMDiT requires approximately 6× more total FLOPs than NextFlow. However, the wall-clock speedup is even larger because MMDiT's 18 denoising steps are all full-length (all 4096 tokens processed in every step), while NextFlow's early steps are extremely cheap. The authors report 5 seconds per 1024×1024 image versus "over 10 minutes" for raster-scan counterparts — a >100× wall-clock improvement.

Training with next-scale prediction. During training, the model uses teacher forcing: at each scale step, it receives the ground-truth visual tokens for all previous scales and must predict the ground-truth tokens for the current scale. The loss is standard cross-entropy over the unified vocabulary (text tokens + semantic codebook indices + pixel codebook indices), but with scale-dependent reweighting (described below). Importantly, the model predicts both semantic and pixel tokens at every scale, but during evaluation the authors primarily use the pixel tokens for VQ decoding (semantic tokens are used for understanding tasks).

Scale reweighting for stable training. The next-scale paradigm creates an inherent training imbalance: early scales determine the global structure of the image but contain very few tokens (the 1×1 scale has 1 token; the 64×64 scale has 4096 tokens), while later scales contain the vast majority of tokens but only refine local details. With uniform per-token loss weighting, the optimization is dominated by fine-scale tokens — the model gets 4096× more gradient signal from the final scale than from the first scale. This causes the model to prioritize local texture fidelity at the expense of global structural coherence, particularly severe at high resolutions where the scale-to-scale token count disparity is extreme.

The solution is scale-aware loss reweighting that maintains the total vision loss constant (so the text loss is unaffected) but redistributes weight toward early scales:

$w_s = \frac{1}{(h_s \times w_s)^\alpha}$

where $h_s \times w_s$ is the spatial resolution at scale $s$ and $\alpha$ is a hyperparameter controlling the reweighting strength (set to $\alpha = 0.9$ in experiments).

What this computes: For each scale $s$, the per-token loss is multiplied by $w_s$ before summing. Since later scales have large $h_s \times w_s$ values, their per-token weight is much smaller than early scales. For example, with $\alpha = 0.9$:

• Scale 1 (1×1): $w_1 = 1 / 1^{0.9} = 1.0$
• Scale 10 (12×12): $w_{10} = 1 / 144^{0.9} \approx 1 / 87.4 \approx 0.0114$
• Scale 18 (64×64): $w_{18} = 1 / 4096^{0.9} \approx 1 / 1778 \approx 0.00056$

The total contribution of each scale to the loss is $w_s \times (h_s \times w_s) = (h_s \times w_s)^{1-\alpha}$. With $\alpha = 0.9$, this becomes $(h_s \times w_s)^{0.1}$, which grows very slowly with resolution — a 4096× larger grid contributes only about $4096^{0.1} \approx 2.3\times$ more to the total loss. This prevents the fine-scale tokens from dominating optimization.

Why this form: The inverse-power-law weighting is a natural choice because the token count grows approximately quadratically with scale index. The hyperparameter $\alpha$ controls how aggressively to counterbalance this growth:

• $\alpha = 0$: uniform weighting (original problem)
• $\alpha = 1$: equal total contribution per scale (aggressive reweighting)
• $\alpha = 0.9$: slightly favors later scales (empirically optimal)

The motivation comes from flow matching techniques in diffusion models (Esser et al., 2024; Labs, 2024) that emphasize difficult intermediate timesteps. In the VAR framework, early scales are analogous to the large-timestep regime in diffusion — they determine the global structure and are harder to learn precisely, so they need more training signal.

Empirically, the need for scale reweighting became apparent during the transition from 256-res to 512-res pre-training (Figure 11). At 512×512 resolution, the token count per image increased by approximately 3000 tokens, and the authors observed a significant increase in artifacts and structural degradation. Lower-scale losses trended upward even as total vision loss decreased, indicating that the optimization was ignoring the structural scales. The GenEval score dropped from 0.67 to 0.57. Introducing scale reweighting with $\alpha = 0.9$ stabilized loss reduction across all scales and restored generation quality.

Self-correction for exposure bias. The next-scale paradigm introduces a specific form of exposure bias (the mismatch between training and inference distributions): during teacher-forcing training, the model always conditions on ground-truth tokens from previous scales. At inference time, it must condition on its own predictions, which may be suboptimal. This is particularly damaging because errors in early (coarse) scales propagate to all subsequent finer scales — if the 2×2 layout is wrong, no amount of detail in the 64×64 scale can fix it.

The self-correction mechanism trains the model to handle these suboptimal inputs. During training, when encoding an image into discrete tokens for teacher forcing, instead of deterministically selecting the closest codebook index, the authors sample from a multinomial distribution over the top-k nearest indices:

$P(\text{index} = j | x) = \frac{\exp(-\beta \cdot d(x, c_j))}{\sum_{i \in \text{top-k}} \exp(-\beta \cdot d(x, c_i))}$

where $x$ is the encoder output, $c_j$ are codebook vectors, $d(\cdot, \cdot)$ is distance, and $\beta$ is a temperature parameter (implicitly controlled by the top-k range). The model continues to predict the top-1 (correct) index as the target.

What this does: The model sees input sequences where some visual tokens have been deliberately perturbed (replaced with nearby but suboptimal codebook indices), simulating the errors that occur during autoregressive inference. Since the model's target remains the correct (top-1) token, it learns to "correct" these perturbations — to output the right token even when given noisy context. This is analogous to scheduled sampling (Bengio et al., 2015) but adapted for the discrete codebook setting.

The residual feature modification. A critical finding during development was that directly applying self-correction to accumulated VAR features (the standard approach where the input features for each scale are the sum of all previous scale features) led to performance degradation. The authors hypothesize:

"self-correction significantly complicates the input feature space, creating a mismatch with text features that are directly retrieved from the codebook."

To address this, NextFlow modifies the visual input representation to use residual features — features from each scale are independently retrieved from the codebook and upsampled as needed, without accumulation. This constrains the complexity of the visual input feature space and maintains consistency with text token representations (which are always direct codebook lookups).

Ablation results (Figure 10) confirm this interaction: self-correction with accumulated features (prob=1.0, 30% of tokens) degrades performance below the non-corrected baseline. Self-correction with residual features yields substantial improvements, with the optimal setting being: apply self-correction with probability $p = 1.0$ (on 100% of training samples) to 60% of visual tokens per scale. This strikes a balance between providing enough corrupted context for the model to learn correction while maintaining enough clean context for stable training.

3.4.4 Transformer Architecture and Interleaved Sequence Modeling

NextFlow builds on a standard decoder-only Transformer architecture (specifically, Qwen2.5-VL-7B) with several design choices tailored to multimodal sequence modeling.

Initialization and vocabulary expansion. The transformer is initialized from Qwen2.5-VL-7B (Bai et al., 2025), which already has strong multimodal priors from its own pre-training (including a vision encoder and alignment training). NextFlow replaces the original ViT vision encoder with the dual-codebook tokenizer described above and expands the vocabulary to include:

• Vision code indices for both the semantic and pixel codebooks
• Special boundary tokens: <boi> (beginning of image) and <eoi> (end of image) that demarcate image regions within the interleaved sequence

The embeddings for the newly added visual codebook indices are initialized directly from the tokenizer's codebook embeddings, providing a warm start that preserves the semantic structure learned during tokenizer training.

Shared output head. A key architectural decision is whether to use separate output heads for text and visual tokens (modality-specific prediction) or a single shared head (unified prediction). Separate heads are common in multimodal models (e.g., Show-o (Xie et al., 2024), Orthus (Kou et al., 2024)) because they allow modality-specific optimization, but they increase parameter count and complexity. The authors conducted a controlled ablation (Section 3.2.1, Figure 9) comparing single-head vs. dual-head architectures under a lightweight setting (5M alignment + 5M SFT samples).

The single-head architecture consistently demonstrated lower total loss and vision loss throughout both alignment and SFT phases, with comparable text loss during SFT. The authors adopted the single-head design for its architectural simplicity and empirically better performance. This is a significant finding because it suggests that a sufficiently expressive transformer can handle both modalities through the same prediction mechanism — the modality-specific processing happens in the representation layers, not in separate output projections.

Interleaved sequence format. The model processes interleaved text-image sequences as a single continuous stream:

<text_token_1> <text_token_2> ... <boi> <sem_idx_1> <pix_idx_1> <sem_idx_2> <pix_idx_2> ... <eoi> <text_token_k> ...

Each image is represented as a sequence of (semantic, pixel) token pairs, bounded by <boi> and <eoi> markers. The autoregressive attention mask is causal: each token can attend to all previous tokens in the sequence, including tokens from both modalities. This means an image generated later in the sequence can condition on earlier text and images, and text generated later can condition on earlier images — enabling the interleaved storytelling, recipe instruction, and dynamic scene generation capabilities demonstrated in Figure 18.

Handling different generation paradigms. For text generation, the model performs standard autoregressive decoding: predict the next token conditioned on the entire sequence history, one token at a time. For image generation, the model switches to next-scale prediction: at each scale step, predict the entire $(h_k \times w_k)$ grid of visual tokens. The model naturally handles both because the output format is simply "predict the next token(s) in the sequence" — whether those tokens represent text, coarse-scale image structure, or fine-scale image details is determined by position and context, not by separate generation mechanisms.

The <boi> token serves as the trigger: when the model generates a <boi>, it knows the upcoming tokens will be visual, and it should switch to the next-scale prediction schedule. The <eoi> token marks the end of the image and the return to text generation. The scale schedule is fully deterministic given the target resolution, so the model doesn't need to predict when to transition between scales — it follows the predefined schedule.

3.4.5 Optional Diffusion Decoder

The dual-codebook VQ tokenizer, while efficient, imposes an inherent information bottleneck: any discrete representation with a finite codebook loses some high-frequency detail relative to the original continuous signal. For most applications, this loss is imperceptible or acceptable given the efficiency gains. However, for applications requiring photo-realistic quality (particularly in challenging regions like small faces, text, and complex textures), the paper introduces an optional diffusion-based refinement module.

Architecture. After the transformer generates the discrete visual token indices, the corresponding embeddings from both the semantic and pixel codebooks are retrieved. These three representations are combined:

1. Semantic codebook embeddings: the quantized semantic features (continuous vectors, one per token)
2. Pixel codebook embeddings: the quantized pixel features
3. Decoded semantic features: the semantic embeddings are additionally processed through the tokenizer's semantic decoder to yield high-dimensional feature maps that are explicitly aligned with ground-truth semantic features during tokenizer training (from TokenFlow's training objective)

These three elements are concatenated, passed through a linear projection layer to match the diffusion model's input dimension, and fed as a visual condition to the diffusion model. Simultaneously, the image caption (or generation prompt) is processed through the diffusion model's text encoder and injected via cross-attention as usual.

Why semantic features in addition to codebook embeddings? The semantic decoder features provide spatial context that goes beyond per-token information. During TokenFlow training, the semantic decoder is explicitly trained to reconstruct high-dimensional features that match the SigLIP2 encoder's output — these features carry rich local semantic information (what type of object, material, or texture is present at each location) that may be partially lost in the discrete quantization. By providing these continuous features as conditioning, the diffusion decoder can "see" the intended semantic content and refine the pixel-level details accordingly.

Model variants. The authors explore three scales:

• 1B parameter UNet-based model: trained with full parameter fine-tuning on high-quality synthetic data. The limited capacity of this model means it struggles to fit complex real-world data distributions, often producing generation artifacts.
• 12B parameter Transformer-based model: trained with LoRA (Low-Rank Adaptation, Hu et al., 2022) on real-world data to maximize reconstruction fidelity.
• 18B parameter Transformer-based model: same training approach as the 12B model, with improved detail fidelity from increased capacity.

Training strategy. A two-stage curriculum is employed:

1. Base resolution training: the diffusion model is first trained at the target image resolution.
2. 2×2 upsampling fine-tuning: the model is fine-tuned on a higher-resolution upsampling task to yield sharper high-frequency details.

Notably, the training relies exclusively on the standard diffusion loss (e.g., epsilon-prediction or velocity-prediction loss). The authors explicitly avoid pixel-level losses (e.g., MSE to ground-truth pixels) because they find these "inflate PSNR metrics while degrading perceptual quality" — a common finding in the diffusion literature where pixel-space supervision encourages blurry, conservative predictions rather than sharp, perceptually convincing ones.

Conditioning design choice. The discrete tokens are injected strictly via the visual conditioning branch — they are not concatenated with text embeddings. The authors' preliminary experiments indicated that concatenating discrete tokens with text embeddings "would corrupt the textual semantic information." This likely occurs because discrete token embeddings are fundamentally different in distribution from text embeddings (they represent quantized visual features, not linguistic concepts), and forcing them into the same embedding space degrades the pretrained text-conditional capabilities.

Trade-offs. The diffusion decoder significantly mitigates detail degradation, particularly for small-scale faces and text. However, it introduces a fundamental tension: the stochastic nature of the diffusion process may alter fine-grained structures, potentially reducing fidelity in tasks requiring strict spatial consistency, such as local editing or identity preservation. The authors therefore disable the diffusion decoder by default for all reported experiments (both quantitative evaluations and qualitative visualizations), treating it as an optional enhancement rather than a core component.

3.4.6 Complete Training Pipeline

The training pipeline (Section 3, Figure 7) spans five major stages and consumes approximately 6 trillion tokens. Each stage addresses a specific challenge in building a unified multimodal model.

Stage 0: Tokenizer Training (Section 3.1). As described in detail in Section 3.4.1 above, the tokenizer is trained independently before the transformer. The multi-stage training (pixel pre-training → joint training → decoder doubling) establishes a discrete vocabulary that balances reconstruction fidelity with semantic richness. The tokenizer is trained on high-fidelity images with face oversampling and 50% VAR scale dropout. All subsequent stages use pre-extracted image indices — the tokenizer encodes all training images offline, storing the discrete index sequences and their original ordering. This eliminates online encoding latency during transformer training and allows the tokenizer encoders to remain offloaded from the GPU, significantly reducing memory requirements.

Stage 1: Alignment (Section 3.2.2). The goal is to align the newly introduced vision tokenizer with the frozen language backbone. The authors replace the original ViT in Qwen2.5-VL-7B with the vision tokenizer, expand the vocabulary to include vision codes and boundary tokens, and train the connector module and output projection layer.

Two training strategies were compared: (1) a two-stage approach (first align the connector, then fine-tune the output projection), and (2) joint training of both components simultaneously. After subsequent SFT evaluation, both methods yielded comparable performance. The authors adopted the joint strategy for simplicity.

The alignment uses 10 million image-text pairs for bidirectional tasks (image captioning and text-to-image generation) at 256-level resolution. Training hyperparameters: learning rate $1 \times 10^{-3}$, 1 epoch. This stage consumes approximately 0.01 trillion tokens.

A critical detail: during alignment, the authors fine-tune the adapter and the expanded shared output head for the single-head model, keeping the remaining parameters (the transformer backbone) frozen. This preserves the valuable linguistic and reasoning knowledge from the pretrained Qwen2.5-VL model while allowing the new visual representation to adapt to the language space.

Stage 2: Pre-Training (Section 3.2.3). The core training stage where the model learns visual generation and multimodal understanding at scale. All model parameters except those of the tokenizer are trainable — the tokenizer remains frozen to maintain a stable discrete vocabulary. The training corpus comprises approximately 6 trillion tokens drawn from: pure text, image-text pairs, editing data, and interleaved multimodal data.

The pre-training uses a progressive resolution curriculum across three sub-stages:

Sub-stage 2a — 256-level Pre-Training (3.4 trillion tokens):

• Large-scale training on approximately 2 billion text-to-image samples to establish fundamental image generation capabilities.
• Pure text data (662M samples) and multimodal understanding data (520M image-to-text samples) are mixed in to maintain the model's original language and visual comprehension abilities.
• 147M interleaved samples teach the model to understand relationships across multiple images, laying the foundation for editing and interleaved generation.
• Training hyperparameters: learning rate $1 \times 10^{-4}$, 1 epoch.

The inclusion of pure text data is validated by an ablation (Table 1): adding 25% text data during training does not adversely affect text-to-image generation quality (GenEval scores at various checkpoints are comparable to the text-to-image-only baseline). This is important because it means language capabilities can be maintained without sacrificing visual generation — the model does not face a capacity trade-off where improving one modality necessarily degrades the other.

Sub-stage 2b — 512-level Pre-Training (1.8 trillion tokens):

• Transition to 512×512 resolution generation.
• Data composition shifts: 700M text samples, 345M text-to-image samples, 20M editing samples, 5M interleaved samples.
• The scale reweighting strategy (Section 3.4.3, $\alpha = 0.9$) is introduced at this stage to address the structural degradation observed in Figure 11.
• Training hyperparameters: learning rate $1 \times 10^{-4}$, 1 epoch.

The shift in data composition reflects the increasing specialization toward generation and editing capabilities. Text data remains the largest single component, but the proportion of understanding data decreases while editing and interleaved data emerge as significant components.

Sub-stage 2c — 1024-level Pre-Training (0.2 trillion tokens):

• Transition to 1024×1024 resolution on a carefully curated subset of 40 million high-quality samples.
• Data composition: 47M text samples, 10M text-to-image samples, 2M editing samples, 0.5M interleaved samples.
• Despite the reduced dataset size, the exponential growth in token count per image means this stage still requires substantial computation.
• Training hyperparameters: learning rate $1 \times 10^{-4}$, 1 epoch.

The authors note that this stage "required minimal data to enable high-resolution generation while substantially improving visual fidelity." This suggests that the model's understanding of visual structure learned at lower resolutions transfers well to higher resolutions — it primarily needs to learn to refine fine-scale details, which can be accomplished with a smaller curated dataset focused on high-quality images with rich local textures.

Impact of self-correction ablation (Section 3.2.1, Figure 10). An important validation experiment was conducted on a 2B parameter model using a high-quality LAION subset. The ablation confirmed that: (a) self-correction with residual features (green line, p=1.0, 30% of tokens) degrades performance, (b) replacing accumulated VAR features with residual features yields significant improvements, and (c) the optimal self-correction intensity is p=1.0 (applied to 100% of training samples) with 60% of visual tokens per scale being perturbed.

Infrastructure and efficiency (Section 4). Pre-training uses 1024 GPUs with DeepSpeed ZeRO (Rajbhandari et al., 2020) and gradient checkpointing. Two critical infrastructure innovations enable training at this scale:

1. Workload balancing via fixed computation budget packing (Section 4, Table 3): The heterogeneous data types (pure text vs. text-to-image vs. interleaved, varying resolution) create significant computational imbalance across GPUs — an image-heavy batch requires far more FLOPs than a text-heavy batch, causing GPUs with lighter workloads to idle while waiting for synchronization. The solution precomputes the TFLOPS for all sequence lengths and packs data to balance workloads. This achieves a 4.1× speedup over naive batch padding (2517 tokens/s vs. 620 tokens/s).

2. FusedLinearCrossEntropy kernel (Section 4): The large unified vocabulary (text + two codebooks) results in a massive output logit tensor that consumes significant GPU memory. The authors adapt FusedLinearCrossEntropy (Hsu et al., 2025), which fuses the final linear projection and cross-entropy loss computation into a single kernel, reducing peak memory usage by approximately 20GB per GPU by avoiding storage of the full logit tensor in HBM (high-bandwidth memory). Additional fused kernels for RoPE, RMSNorm, and Flash-Attention (Dao, 2024) minimize redundant memory access by storing intermediate results in on-chip registers or shared memory.

Stage 3: Continue-Training and Supervised Fine-Tuning (Section 3.2.4). After pre-training, a two-phase post-training strategy refines the model's capabilities:

1. Continue-Training (CT) (0.2 trillion tokens): The model is fine-tuned on a curated subset of high-quality data to improve aesthetic quality. While pretrained models demonstrate strong general capabilities, they often produce outputs with inconsistent aesthetic standards due to the heterogeneous nature of pre-training datasets. The CT phase addresses this by fine-tuning on aesthetically superior samples while preserving prompt adherence and structural accuracy. Learning rate: $5 \times 10^{-5}$.

   This is analogous to the "aesthetic fine-tuning" common in diffusion model training (e.g., fine-tuning Stable Diffusion on high-quality subsets of LAION), but applied within the autoregressive framework. The key challenge is avoiding catastrophic forgetting of the diverse visual concepts learned during pre-training — the authors balance this by keeping the CT data volume relatively small (0.2T tokens) and using a lower learning rate.

2. Supervised Fine-Tuning (SFT) (0.02 trillion tokens): A small set of high-quality conversational data is formatted in dialogue structure, with supervision applied exclusively to the model's responses. This enables more natural and contextually appropriate interactions while further improving generation quality. Learning rate: $1 \times 10^{-5}$.

   The dialogue formatting is important: during pre-training, the model learns from sequences of interleaved text and images without explicit user-assistant structure. SFT introduces conversational conventions (user queries followed by assistant responses) that make the model suitable for interactive deployment. The exclusive supervision on model responses (not user queries) follows standard LLM instruction tuning practice.

Stage 4: Reinforcement Learning with Prefix-Tuning GRPO (Section 3.2.5). The final stage applies Group Reward Policy Optimization (GRPO, Shao et al., 2024) — a reinforcement learning algorithm — to align the model's visual generation with downstream reward objectives.

The generation of a VAR sequence is formulated as a Markov Decision Process (MDP):

• State $s_t$: the prefix $\{a_i\}_{i=1}^{t-1}$ — all previously generated tokens (text + visual from scales 1 through $t-1$)
• Action $a_t$: the token grid for the next resolution level, generated as independent per-position predictions:

$\pi^t_\theta(a_t | s_t) = \prod_{(i,j)} \pi^t_\theta(a_{t,(i,j)} | s_t)$

where $a_{t,(i,j)}$ is the token at position $(i,j)$ in the scale-$t$ grid, and $\pi_\theta$ is the policy (the autoregressive transformer with parameters $\theta$).

Why the per-position independence assumption? Within a single VAR scale, tokens are generated independently (in parallel) conditioned on the shared prefix. This factorization is exact because VAR does not model inter-token dependencies within a scale — all positions at scale $t$ condition on the same context (scales $1$ through $t-1$), not on each other. This makes the policy gradient computation significantly simpler than if within-scale dependencies were modeled (as in raster-scan AR).

The GRPO objective. Given a condition $c$ (which may include text and/or condition images), the model rolls out a group of $G$ image token sequences $\{s^i_T\}_{i=1}^G$, decodes them to images $\{x_i\}_{i=1}^G$, and computes rewards $R(x_i, c)$ from a reward model. Within each group, advantages are normalized:

$A_i = \frac{R(x_i, c) - \text{mean}(\{R(x_i, c)\}_{i=1}^G)}{\text{std}(\{R(x_i, c)\}_{i=1}^G)}$

What this computes: For each generated image in the group, the advantage $A_i$ measures how much better (or worse) its reward is compared to the group average, expressed in units of the group's standard deviation. If $A_i > 0$, the image is above average and the policy should be updated to make this action more likely; if $A_i < 0$, the image is below average and the policy should make this action less likely. The normalization by standard deviation ensures consistent gradient magnitudes regardless of the absolute reward scale.

The GRPO loss is:

$\mathcal{L}_{\text{GRPO}}(\theta) = \mathbb{E}_{c \sim C, \{s^i_T\} \sim \pi_\theta} \left[ \frac{1}{G} \sum_{i=1}^G \sum_{t=1}^m k_t \cdot \min\left( \frac{\pi_\theta(s^i_{t+1} | s^i_t, c)}{\pi_{\theta_{\text{old}}}(s^i_{t+1} | s^i_t, c)} A_i, \text{clip}\left( \frac{\pi_\theta(s^i_{t+1} | s^i_t, c)}{\pi_{\theta_{\text{old}}}(s^i_{t+1} | s^i_t, c)}, 1-\epsilon, 1+\epsilon \right) A_i \right) - \beta D_{KL}(\pi_\theta, \pi_{\text{ref}}) \right]$

where:

• $m$ is the number of scale steps being optimized (the prefix-tuning strategy described below)
• $k_t$ is the scale reweight coefficient (same as pre-training)
• $\epsilon$ is the PPO clipping parameter (typically $0.1$ or $0.2$)
• $\pi_{\theta_{\text{old}}}$ is the frozen policy from before the GRPO update (used for importance sampling correction)
• $\pi_{\text{ref}}$ is a reference policy (typically the pre-GRPO model) used for KL regularization
• $\beta$ controls the strength of the KL penalty

What this loss computes: For each action (generating a scale), the loss compares the current policy's probability of that action to the old policy's probability (the ratio $\frac{\pi_\theta}{\pi_{\theta_{\text{old}}}}$). If the advantage is positive, the loss encourages increasing this probability ratio (up to $1+\epsilon$); if negative, it encourages decreasing it (down to $1-\epsilon$). The clipping prevents excessively large policy updates that could destabilize training. The KL divergence term prevents the policy from drifting too far from the reference model, preserving the base capabilities learned during pre-training and SFT.

The prefix-tuning strategy. The key innovation in NextFlow's RL approach is prefix-tuning: rather than optimizing the policy for all $T$ scale steps, only the first $m$ (coarse) scales are updated, while the policies for the remaining $T-m$ (fine) scales remain frozen. In the experiments (Figure 12), $m$ is tested at values of 64, 128, 256, and 512.

Why prefix-tuning? The motivation is two-fold:

1. Learning signal quality: Coarse scales (generating global layout and structure) are where semantically meaningful decisions happen — composition, object placement, color palette, lighting direction. Fine scales refine textures and edges but rarely change the semantic content. The reward model (which evaluates the final image) provides a stronger signal about coarse-scale decisions (which fundamentally affect image quality) than fine-scale ones (which are largely imperceptible at the aggregate reward level).

2. Training stability: Fine scales contain orders of magnitude more tokens than coarse scales. If all scales are optimized, the gradient contributions from fine-scale decisions overwhelm those from coarse-scale decisions (the same imbalance that motivated scale reweighting during pre-training). Additionally, the high-variance RL signal is less reliable for fine-scale updates, and applying it to many parameters risks degrading the high-fidelity detail capabilities learned during pre-training.

The experiments in Figure 12 show that prefix-tuning with $m = 256$ provides the most stable reward improvement over 400 training steps, with the reward value steadily increasing from approximately 0.96 to 1.26 (a ~31% improvement). Vanilla GRPO (no prefix-tuning) shows much higher variance and slower improvement.

Scale reweighting in RL. In addition to prefix-tuning, the same scale reweighting coefficients $k_t$ from pre-training are applied to the GRPO loss. This ensures that within the $m$ optimized scales, the early (coarsest) scales receive proportionally more learning signal, matching the training distribution the model was exposed to during pre-training. Together, prefix-tuning and scale reweighting "enable stable and efficient RL-based fine-tuning of NextFlow, allowing for precise alignment with downstream objectives without sacrificing generative coherence."

Concrete RL training details: The group size $G$ (number of images generated per condition) and the reward model architecture are not explicitly specified in the main text, but the procedure follows standard GRPO practice. The reward model presumably evaluates dimensions like prompt adherence, aesthetic quality, and structural correctness — the paper does not detail the reward model training. The prefix-tuning experiments in Figure 12 were conducted at 1024 resolution.

The complete training recipe is summarized in Table 2 of the paper (reproduced here for completeness):

Total tokens trained: approximately 5.63 trillion (not counting the 0.01T alignment stage or the RL stage, which operates on a different optimization paradigm).

Summary of Design Choices and Their Justifications

• Dual-codebook tokenizer over single-branch VQ-VAE: semantic constraints shape a latent space that is structurally easier for the AR model to learn, despite slightly lower reconstruction PSNR. Validated by Figure 8 ablation showing superior generative performance.

• Next-scale prediction over raster-scan: reduces sequential generation steps from $O(N^2)$ to $O(\log N)$, achieving ~100× wall-clock speedup (5 seconds vs. 10+ minutes) for 1024×1024 images.

• Multiscale 3D RoPE over 1D positional encoding: enables resolution-invariant spatial understanding and explicit scale awareness, critical for the hierarchical generation schedule.

• Shared output head over modality-specific heads: empirically better performance with architectural simplicity (Figure 9 ablation).

• Scale reweighting ($\alpha = 0.9$) over uniform weighting: prevents fine-scale token dominance in the loss landscape, essential for stable structural generation at high resolutions.

• Residual features + self-correction over accumulated features + self-correction: constrains input feature space complexity, maintaining consistency with text token representations and enabling exposure bias correction to actually help rather than hurt (Figure 10 ablation).

• Prefix-tuning GRPO over full-model GRPO: focuses limited high-variance RL signal on semantically impactful coarse-scale decisions, stabilizing training and preserving fine-detail quality (Figure 12).

• Optional diffusion decoder over compulsory refinement: provides a quality boost when needed (small faces, text) without sacrificing spatial consistency and efficiency for most applications.

• Progressive resolution curriculum: gradually introduces higher-resolution generation, allowing the model to first learn structural concepts at low resolution before refining details at high resolution.

• Pre-extracted image indices: eliminates online tokenizer encoding latency during transformer training, reducing GPU memory requirements and enabling the efficient batching strategies described in Section 4.

4. Key Insights and Innovations

Innovation 1: Next-Scale Prediction as a Paradigm Shift in Autoregressive Visual Generation, Not Just an Efficiency Hack

The dominant assumption in autoregressive (AR) image generation prior to NextFlow was that raster-scan order — predicting visual tokens left-to-right, top-to-bottom — was the natural and necessary extension of next-token prediction from language to vision. Models like Chameleon, EMU3, and EMU3.5 all adopted this approach, and the results were consistent: AR models could generate reasonable images but were prohibitively slow at high resolutions (10+ minutes for 1024×1024 images). The field's response to this limitation was largely to abandon pure AR in favor of hybrid AR-diffusion architectures (Transfusion, Bagel) that offloaded the heavy lifting of visual generation to diffusion while keeping AR for text.

NextFlow's fundamental conceptual move is to recognize that the problem was never AR per se, but the specific form of AR being applied. By shifting from per-token raster-scan to per-scale hierarchical prediction (building on VAR, Tian et al., 2024), the paper demonstrates that AR visual generation can be restructured to operate in $O(\log N)$ sequential steps rather than $O(N^2)$, making it competitive with diffusion models in wall-clock time while retaining the architectural simplicity of a single decoder-only transformer. This is not an incremental optimization — it is a paradigm shift in how AR models relate to the 2D structure of images. Raster-scan treats an image as an arbitrary 1D sequence that happens to encode 2D content; next-scale prediction treats an image as a naturally hierarchical signal, conditioning each resolution level on all coarser levels, which is fundamentally a more appropriate inductive bias for visual data.

The significance extends beyond speed. The next-scale paradigm changes the nature of the AR generation problem from "predict the next token in a long 1D sequence" to "predict the next scale grid conditioned on a compact hierarchical history." This restructuring has downstream implications for training stability (the scale reweighting problem would not exist in raster-scan), for reinforcement learning (prefix-tuning GRPO is only coherent because scales have interpretable semantic meaning), and for in-context learning (the model can attend to coarse-scale structure across examples rather than being lost in per-pixel detail). The paper provides evidence through the GenEval score trajectory (Figure 7, bottom) and the difficulty-dependent behavior of scale reweighting (Figure 11), but the deeper claim is that what appears to be an efficiency optimization is actually a reconceptualization of the AR task itself.

Innovation 2: The Dual-Codebook Tokenizer as a Semantic Bridge, Not a Compression Tool

Tokenizers in visual AR models have historically been evaluated by a single metric: reconstruction fidelity (PSNR, SSIM). The field's default assumption — inherited from the VQ-VAE literature and carried into models like VQGAN, Chameleon's tokenizer, and EMU3's tokenizer — was that a tokenizer's job is to losslessly (or near-losslessly) compress an image into discrete codes, and that better reconstruction automatically yields better downstream generative performance. NextFlow's TokenFlow-style dual-codebook design challenges this assumption by explicitly separating semantic encoding (what the image is about) from pixel-level encoding (what the image looks like), and demonstrating that optimizing for both jointly produces a latent space that is superior for generative modeling even when raw reconstruction metrics are slightly worse.

This is a conceptual contribution, not merely an architectural one. The paper provides a clean and reproducible counterexample to the "better reconstruction = better generation" narrative. Figure 8 shows that a single-branch VQGAN tokenizer achieves marginally higher PSNR (+0.5 dB) but produces consistently worse generative performance (lower GenEval scores) and slower training convergence (higher vision loss at matched steps). The interpretation — that semantic constraints "shape a latent space that is structurally easier for the autoregressive model to learn" — reframes the tokenizer's role from a passive compression step to an active inductive bias that controls the learnability of the discrete representation. This insight, supported by prior theoretical work like REPA (Yu et al., 2024) and VA-VAE (Yao et al., 2025) that the authors cite, has implications beyond NextFlow: it suggests that future tokenizer research should prioritize the structure and semantics of the latent space over raw pixel-level metrics.

The second conceptual move in the tokenizer design is the upgrade to variable-resolution processing via SigLIP2-so400m-naflex. Prior unified models typically operated at fixed resolutions and aspect ratios, constraining both training efficiency and generation flexibility. By enabling native dynamic resolution processing in the semantic branch, NextFlow's tokenizer removes this constraint, allowing the AR model to train and generate at arbitrary aspect ratios (the 40 predefined schedules in Table 14). This is more than a convenience — it means the model learns resolution-invariant visual concepts, which is essential for the progressive resolution curriculum used during pre-training (256 → 512 → 1024) and for the diverse aspect ratios required in real-world image editing and interleaved generation.

Innovation 3: RL for Visual Generation via Prefix-Tuning — A Principled Solution to a Unique Challenge

Reinforcement learning for language models (RLHF, DPO, GRPO) is relatively mature, with established practices for stabilizing policy optimization in the discrete token domain. But applying RL to multi-scale visual generation introduces a problem that has no analog in text: the policy operates over actions (scale grids) that vary in dimensionality by orders of magnitude across timesteps. A single token at scale 1 (1×1 grid) carries vastly more semantic weight than any single token at scale 18 (64×64 grid), yet a naive GRPO application would treat all actions equivalently, causing the high-variance RL signal from fine-scale decisions to dominate optimization.

The prefix-tuning strategy introduced in Section 3.2.5 solves this by restricting policy updates to the semantically meaningful prefix of the generation trajectory — the coarse scales that determine global structure, composition, and semantics. This is not merely an engineering trick to stabilize training (though it does, as Figure 12 demonstrates with smoothly increasing rewards vs. the noisy vanilla GRPO baseline). It is a conceptual insight about the nature of the RL problem in hierarchical generation: the reward model's signal is inherently more informative about coarse-scale decisions (which fundamentally affect image quality, composition, and prompt adherence) than fine-scale decisions (which refine textures and edges in ways that are largely imperceptible to the reward model). By restricting optimization to the scales where the reward signal is reliable, prefix-tuning avoids the noise amplification that would occur if the policy were updated based on noisy advantage estimates for fine-scale actions.

This insight generalizes beyond NextFlow. Any hierarchical generative model that produces outputs at multiple scales — whether AR, diffusion, or flow-based — faces the same challenge if subjected to RL-based fine-tuning. The prefix-tuning strategy provides a template for how to reason about which parts of the generation process should receive RL updates: optimize the scales where decisions have large, reward-relevant effects, and freeze the scales where decisions are high-dimensional but reward-irrelevant. The paper's ablation of prefix lengths (Figure 12, testing $m = 64, 128, 256, 512$) provides empirical guidance on this trade-off, but the underlying principle — match the optimization granularity to the reward signal's informativeness — is the lasting contribution.

The broader significance is that this work establishes RL as viable for visual AR models in a way that prior efforts (e.g., AR-GRPO, Yuan et al., 2025; SimpleAR, Wang et al., 2025) could not fully demonstrate because they lacked mechanisms to handle the scale imbalance. The combination of scale reweighting (during both pre-training and RL) with prefix-tuning provides a complete recipe for stable policy optimization in multi-scale generation, opening the door to reward-based alignment for visual AR models that was previously closed.

Innovation 4: The Training Pipeline as a Unified Engineering Contribution — Stability Through Progressive Resolution and Self-Correction

While the individual components of NextFlow (dual-codebook tokenizer, next-scale prediction, GRPO) are drawn from prior work, the paper's distinctive contribution is demonstrating that these components can be integrated into a single coherent training pipeline that remains stable across 6 trillion tokens and five stages of training. This is more than an engineering feat — it is an empirical contribution that establishes the viability of the pure AR paradigm at scale, directly addressing the skepticism generated by prior AR models that struggled with training stability, inference speed, and generation quality.

The paper's Figure 7 (the GenEval score trajectory) encodes a narrative of discovery: the model's performance does not increase monotonically but rather experiences a significant dip during the 256→512 resolution transition (0.67 → 0.57), which is then diagnosed and resolved through the scale reweighting strategy (recovering to higher values in subsequent stages). The inclusion of this trajectory, along with the failure analysis in Figure 11 (showing lower-scale losses increasing during the resolution transition), provides rare visibility into the training dynamics of large-scale multimodal models. This transparency is itself a contribution — it transforms the pipeline from a black-box recipe into a diagnostic case study that other practitioners can learn from when building similar systems.

The self-correction mechanism (Section 3.2.1) represents a similar diagnostic contribution. The finding that self-correction with accumulated features degrades performance while self-correction with residual features improves it (Figure 10) could not have been predicted from first principles — it required empirical investigation. This negative result (the failure of the standard VAR accumulation approach in a decoder-only setting) is scientifically valuable because it reveals a subtle interaction between feature representation and exposure bias that is not obvious from the original VAR formulation. The resolution — using residual features independently retrieved from the codebook — establishes a design principle that may apply to other decoder-only hierarchical models: maintain feature space consistency across modalities to avoid creating a mismatch between text tokens (which are direct codebook lookups) and visual tokens (which could become complex accumulations).

Innovation 5: Unification Enables Emergent Capabilities — CoT Reasoning and In-Context Learning for Visual Generation

The paper's most forward-looking contribution is the demonstration that a purely autoregressive architecture naturally inherits the reasoning capabilities of LLMs in ways that hybrid or diffusion-based systems cannot easily replicate. Two capabilities stand out as particularly significant:

Chain-of-Thought for visual generation (Section 6.4, Figure 19). The paper shows that by fine-tuning NextFlow on instruction-reasoning-image triplets, the model can be taught to articulate a reasoning trace — analyzing the prompt for cultural context and physical constraints — before generating visual tokens. This enables the model to self-correct semantic errors that baseline T2I models (including strong diffusion-based systems) would miss. The example of "China's national treasure" resolving to a Giant Panda rather than a Red Panda is not just a cute anecdote — it demonstrates that the AR architecture allows the model's language understanding capabilities to directly inform its visual generation decisions, without the representation gap that would exist in hybrid systems where the language model and visual generator are separate components.

The WISE score improvement from 0.60 to 0.70 (Section 6.4) quantifies this benefit, but the deeper significance is that the architecture does not need to be modified to support reasoning — it is a natural consequence of the model treating text and image generation as a single autoregressive sequence. The model can think in text, then draw in pixels, using the same prediction mechanism for both. This is categorically different from approaches that add reasoning as an external module (e.g., prompt rewriting with a separate LLM before passing to a diffusion model) because the reasoning trace can attend to the same internal representations that will later be used for visual generation, enabling deeper integration between the "thinking" and "drawing" phases.

In-context learning for image editing (Section 6.5, Figure 20). The paper shows that NextFlow, when prompted with example image pairs demonstrating a transformation pattern, can infer the pattern and apply it to a new input image — without any task-specific fine-tuning. This is a capability that the field has primarily associated with text-based LLMs, and its emergence in a visual generation context is a direct result of large-scale pre-training on interleaved image-text data. The model learns to treat image editing as a form of sequence completion: given a sequence of [before, after, before, after, before, ???], it predicts the appropriate "after" image.

This is not merely a benchmark result — it points toward a fundamentally different paradigm for image editing interfaces. Instead of specifying editing operations through explicit instructions ("remove the background," "change the lighting to warm"), users could provide examples of desired transformations, and the model would generalize. This is a more expressive and intuitive interface that leverages the model's pattern recognition capabilities rather than requiring users to articulate editing intent in precise language.

The significance of both capabilities is that they are architectural properties rather than trained features — they emerge from the decision to unify text and vision within a single AR framework, not from specific training objectives or data augmentation strategies. This suggests that as unified models scale further, additional reasoning capabilities (multi-step visual planning, visual analogy, compositional editing) may emerge naturally, following a trajectory analogous to the emergence of reasoning in text-only LLMs.

5. Experimental Analysis

Evaluation Methodology

• Dataset. The primary text-to-image benchmarks are GenEval (Ghosh et al., 2023), DPG (Hu et al., 2024), WISE (Niu et al., 2025), and PRISM-Bench (Fang et al., 2025). For image editing, the paper uses ImgEdit (Ye et al., 2025), OmniContext (Wu et al., 2025), GEdit-Bench (Liu et al., 2025), and a newly proposed benchmark called EditCanvas (described in Appendix B). For multimodal understanding, the paper evaluates on MMStar, ChartQA, OCRBench, MME, MMB, MMMU, and TextVQA using the LLaVA-1.5 evaluation protocol (Liu et al., 2024). For image reconstruction, the paper uses the ImageNet-1K validation set (Russakovsky et al., 2015) and an in-house reconstruction benchmark. For interleaved generation and in-context learning, results are qualitative only (no quantitative benchmark reported).

• Base model(s). The core model is NextFlow, a 7B-parameter decoder-only transformer initialized from Qwen2.5-VL-7B (Bai et al., 2025) and trained on approximately 6 trillion tokens. Two variants are evaluated: NextFlow (the base model after CT and SFT) and NextFlow-RL (the model after reinforcement learning with prefix-tuning GRPO). For the multimodal understanding experiments (Table 13), the base model is fine-tuned on varying amounts of SFT data (0.7M, 21M, and 40M samples) to assess understanding capability retention. The choice of 7B parameters is deliberate: it is small enough to enable efficient experimentation across the full training pipeline but large enough to demonstrate competitive performance against both specialized diffusion models and other unified architectures at similar scales (e.g., Janus-Pro-7B, Show-o).

• Metrics. For text-to-image generation, the primary metrics are GenEval overall score (0–1, measuring object-focused prompt adherence across six sub-tasks: single object, two objects, counting, colors, position, color attribution), DPG overall score (0–100, measuring global/entity/attribute/relation/other prompt adherence), WISE overall score (0–1, measuring world knowledge across cultural, temporal, spatial, biological, physical, and chemical domains), and PRISM-Bench overall score (0–100, evaluated by GPT-4.1 across imagination, entity accuracy, text rendering, style, affect, composition, and long-text alignment). For image editing, metrics vary by benchmark but generally include Prompt Following (PF), Perceptual Quality (PQ), Subject Consistency (SC), and Overall scores, all evaluated via GPT-4.1 (or GPT-4o for certain benchmarks). For multimodal understanding, standard accuracy metrics are used (e.g., exact match for ChartQA, accuracy for MMB and MMMU). For image reconstruction, PSNR and SSIM are reported.

• Baselines. For text-to-image generation, the paper compares against a comprehensive set of:

  • Diffusion models: SDXL (Podell et al., 2024), DALL-E 3 (Betker et al., 2023), SD3-Medium (Esser et al., 2024), SD3.5-Large (Stability-AI, 2024), FLUX.1-dev (Labs, 2024), HiDream-I1-Full (Cai et al., 2025), Seedream 3.0 (Gao et al., 2025), Qwen-Image (Wu et al., 2025), and GPT Image 1 (High) (OpenAI, 2025).
  • AR + Diffusion hybrid models: Transfusion (Zhou et al., 2024) and BAGEL (Deng et al., 2025).
  • Pure AR models: Chameleon (Team, 2024), Emu3-Gen (Wang et al., 2024), TokenFlow-XL (Qu et al., 2025), Show-o (Xie et al., 2024), NextStep-1 (Team, 2025), Janus-Pro-7B (Chen et al., 2025), Infinity-8B (Han et al., 2025), EMU3.5 (Cui et al., 2025), and Liquid (Wu et al., 2024).

  For image editing, baselines include MagicBrush (Zhang et al., 2023), Instruct-Pix2Pix (Brooks et al., 2023), AnyEdit (Yu et al., 2025), UltraEdit (Zhao et al., 2024), OmniGen (Xiao et al., 2025), ICEdit (Zhang et al., 2025), Step1X-Edit (Liu et al., 2025), BAGEL, UniWorld-V1 (Lin et al., 2025), OmniGen2 (Wu et al., 2025), FLUX.1 Kontext (Labs et al., 2025), GPT Image 1, Qwen-Image, and EMU3.5. For subject-driven generation, additional baselines include InfiniteYou (Jiang et al., 2025), UNO (Wu et al., 2025), Gemini-2.0-flash (Google, 2025), and GPT-4o (OpenAI, 2025). For multimodal understanding, the primary baseline is LLaVA 1.5 (13B) (Liu et al., 2024).

• Generation budget / compute accounting. Unlike the reference example which measured compute in "generations" or FLOPs, this paper does not report a unified compute budget for generation comparisons. Instead, generation quality is evaluated through standard benchmark protocols where each model generates images using its default inference settings (e.g., number of denoising steps for diffusion models, number of scale steps for NextFlow). The paper's efficiency claims (5 seconds per 1024×1024 image, 6× fewer FLOPs than MMDiT) are reported separately in the main text and Appendix A.2, but these are not directly tied to the quantitative benchmark results — the benchmarks measure quality, not speed. There is no FLOPs-matched comparison between NextFlow and diffusion baselines in the experimental section. The only compute-accounting analysis is the theoretical FLOPs comparison in Appendix A.2, which estimates that NextFlow requires approximately 1.04 × 10¹² FLOPs to generate a 1024×1024 image versus 6.18 × 10¹² for MMDiT (a ~6× reduction), but this is not validated against actual inference time measurements across different hardware configurations, nor is it controlled for in the quality benchmarks (e.g., "does NextFlow at 6× fewer FLOPs match MMDiT quality?" — this specific comparison is never made).

• Cross-validation / statistical protocol. No cross-validation or statistical significance testing is reported for the benchmark evaluations. All scores are single-point evaluations on standard test sets. For the multimodal understanding experiments (Table 13), the results are from SFT runs at different data scales, but no error bars, confidence intervals, or multiple-seed averages are reported. This is a notable absence given that many of the performance differences between top models are small (e.g., GenEval scores of 0.83 vs. 0.84, DPG scores of 86.00 vs. 88.32) — without any estimate of variance, it is impossible to determine whether these differences are statistically meaningful or within the noise of the evaluation protocol. The EditCanvas benchmark (Appendix B) uses GPT-4.1 as a judge, which introduces its own stochasticity, but no multiple-evaluation averaging is reported. The GRPO training curves (Figure 12) show single-run reward trajectories, not averages over multiple random seeds.

Main Quantitative Results

Image Generation: Prompt Following and Visual Quality

GenEval results (Table 5). NextFlow achieves an overall GenEval score of 0.83 (NextFlow) and 0.84 (NextFlow-RL). NextFlow-RL's 0.84 ties with Seedream 3.0 and GPT Image 1 (High) for the highest score among all models evaluated, and matches the state-of-the-art diffusion model Qwen-Image (0.87, though the difference of 0.03 is within the range that could be affected by evaluation variance — no confidence intervals are reported). The RL fine-tuning provides a modest +0.01 improvement in overall score. Among pure AR models, this represents a substantial advance: the next-best AR model is EMU3.5 at 0.86 (which is 0.02 higher than NextFlow-RL, though the paper does not comment on this), followed by Janus-Pro-7B and Infinity-8B at 0.80. The sub-task breakdown reveals that NextFlow-RL excels at Single Object (1.00, tied with HiDream-I1-Full for the maximum possible) and Two Objects (0.92, though this is below HiDream-I1-Full's 0.98 and SD3-Medium's 0.94), while Counting (0.75) lags behind the best diffusion models (Qwen-Image at 0.89, Seedream 3.0 at 0.91). This sub-task pattern is informative: the rigid structure of next-scale prediction (generating entire grids at each scale) may handle spatial relationships (Position: 0.76, Color Attribution: 0.70) and precise object counts somewhat worse than diffusion models that can iteratively refine all positions simultaneously — but the paper does not analyze this potential limitation.

DPG results (Table 4). NextFlow-RL achieves an overall score of 88.32, which the paper reports as matching Qwen-Image (88.32) — these are actually identical scores, making it a tie for the highest reported performance. The base NextFlow achieves 86.00. The RL improvement is more pronounced on DPG (+2.32 points) than on GenEval (+0.01). The sub-task breakdown shows NextFlow-RL excels at Global (92.09) and Other (93.22), while Attribute (91.92) and Relation (92.08) are competitive. The most notable gap between base NextFlow and NextFlow-RL is in Entity accuracy (90.05 → 93.48, a +3.43 improvement), suggesting RL fine-tuning specifically enhances the model's ability to correctly render specified objects. Compared to other AR models, NextFlow-RL substantially outperforms EMU3.5 (88.26, a narrow margin of 0.06) and NextStep-1 (85.28). Seedream 3.0 (88.27) is essentially tied.

WISE results (Table 6). This benchmark tests world knowledge in text-to-image generation (e.g., "generate an image of a marsupial that is a national symbol of Australia" requires knowing that kangaroos are Australian). NextFlow-RL achieves 0.62 overall, matching Qwen-Image (0.62) and significantly outperforming other pure AR models (Emu3-Gen: 0.39, Janus-Pro-7B: 0.35, Liquid: 0.41). The base NextFlow achieves 0.59. The largest gaps between NextFlow and the best diffusion model (GPT Image 1 at 0.80) are in Chemistry (0.39 vs. 0.74) and Biology (0.58 vs. 0.83), suggesting that the unified 7B model may lack the depth of factual knowledge that larger or specialized models possess. This is a capacity limitation: 7B parameters shared between text and visual processing leave less room for world knowledge than a larger model that can dedicate capacity to factual recall. Within AR models, NextFlow-RL is the best by a wide margin (0.62 vs. 0.41 for the next-best, Liquid), demonstrating that the dual-codebook tokenizer and large-scale pre-training on diverse multimodal data effectively encode world knowledge that reconstruction-oriented tokenizers lose.

PRISM-Bench results (Table 7). NextFlow-RL achieves 78.8 overall, compared to Seedream 3.0 (79.6) and Qwen-Image (79.9). This places NextFlow slightly below the top-tier diffusion models but well above other AR models (Janus-Pro-7B: 60.7). The largest gap is in Text Rendering (49.8 vs. Qwen-Image's 61.6 and Seedream 3.0's 63.2), which is expected given the discrete tokenization bottleneck — small text characters require high-frequency detail that is challenging for any VQ-based tokenizer to faithfully encode and reconstruct. The RL fine-tuning helps substantially in Imagination (84.3 → 87.1), Entity (71.2 → 79.3, an +8.1 improvement), and Composition (71.2 → 90.5, a remarkable +19.3 jump), while Text Rendering actually slightly declines (50.3 → 49.8). This pattern suggests that RL optimization may be trading off text rendering quality for improvements in other dimensions — the reward model likely emphasizes composition, entity accuracy, and imagination over text rendering fidelity, and the policy shifts accordingly. The paper does not discuss this potential trade-off, but it is a concrete example of reward hacking or objective mismatch in the GRPO fine-tuning.

Image Editing

ImgEdit results (Table 8). NextFlow-RL achieves an overall score of 4.49, the highest among all evaluated models. This places it above EMU3.5 (4.41), Qwen-Image (4.27), GPT Image 1 (4.20), and FLUX.1 Kontext Pro (4.00). The sub-task analysis reveals particular strengths in Adjust (4.68, the highest reported), Remove (4.67, also highest), and Hybrid (4.77, highest). The base NextFlow achieves 4.44, already competitive with EMU3.5 (4.41), suggesting that the editing capability is primarily learned during pre-training and SFT, with RL providing a modest refinement (+0.05 overall). Notably, NextFlow substantially outperforms OmniGen2 (3.44) despite OmniGen2 being specifically designed for subject-driven and in-context editing tasks. This is a significant result because editing requires both understanding the input image (to identify what to change) and generating the output image (with precise local modifications while preserving global context) — tasks that test the unified architecture's ability to seamlessly integrate perception and generation.

OmniContext SINGLE results (Table 9). This benchmark evaluates subject-driven generation where a single reference subject must be preserved in a new scene. NextFlow-RL achieves an overall score of 8.67, surpassing OmniGen2 (7.81), GPT-4o (8.95 — note that NextFlow is below this proprietary model), and Gemini-2.0-flash (5.11). The Subject Consistency score is particularly strong: 9.22 for NextFlow-RL vs. 8.34 for OmniGen2 and 9.03 for GPT-4o. This means NextFlow is the best available model at faithfully preserving subject identity when generating new scenes. The Prompt Following score (7.96) is lower than GPT-4o (8.89), indicating that while the model preserves subjects well, it may not follow scene-generation instructions as precisely as the proprietary baseline. The paper attributes this subject consistency strength to the "interleaved pre-training in learning robust identity representations" — but this is a post-hoc explanation without an ablation showing that removing interleaved data degrades subject consistency scores.

GEdit-Bench results (Table 10). NextFlow-RL achieves an overall score of 7.87 (geometric mean of Semantic Consistency 8.37 and Perceptual Quality 8.10). This is the highest reported score, above EMU3.5 (7.59), Qwen-Image (7.56), and GPT Image 1 (7.53). The balanced performance across both semantic consistency and perceptual quality suggests that the dual-codebook tokenizer effectively captures both semantic content (for instruction following) and pixel-level detail (for perceptual quality) — exactly the design goal. The gap between NextFlow-RL and the base NextFlow (7.60) is modest, again suggesting that RL provides refinement rather than fundamentally enabling editing capability.

EditCanvas results (Table 11). On the paper's own benchmark — which the authors position as more comprehensive than existing suites — NextFlow-RL achieves an overall score of 8.04, compared to GPT Image 1 (8.67) and EMU3.5 (8.37). This places NextFlow as the third-best model, behind two proprietary systems but ahead of all other open or specialized models (Qwen-Image: 7.60, Flux.1 Kontext: 6.77). On Traditional Editing subtasks, NextFlow-RL scores 8.11 for Prompt Following and 7.26 for Perceptual Quality. On Subject-Driven Generation, it scores 8.47 for Prompt Following and a very strong 8.78 for Subject Consistency. The gap between NextFlow-RL (8.04) and the base NextFlow (7.93) is small (+0.11), indicating that editing capability is largely established during pre-training, with RL providing marginal refinement.

Critical observation about self-benchmarking: EditCanvas is proposed in this same paper, which creates a potential conflict of interest — the benchmark may be designed (intentionally or unintentionally) to favor the authors' model. The paper does not provide evidence that EditCanvas was developed independently of the model evaluation process, nor does it show correlations between EditCanvas scores and established benchmarks to establish its validity as a fair evaluator. The fact that NextFlow-RL performs slightly worse than GPT Image 1 and EMU3.5 on EditCanvas partially mitigates this concern, suggesting the benchmark does differentiate between models, but the broader question of benchmark design bias remains unaddressed.

Interleaved Generation

The paper provides qualitative results only for interleaved generation (Figure 18), demonstrating storytelling (The Ugly Duckling narrative with corresponding images), recipe instructions (tomato basil pasta preparation steps), and dynamic scene generation (a car driving along a coastal highway with subtly varying frames). No quantitative benchmark for interleaved generation is reported. This is a significant gap: interleaved generation is presented as a key capability enabled by the unified architecture (Section 1, Section 6.3 title), but the evidence is purely anecdotal. There is no metric for text-image coherence (do the generated images actually match the accompanying text?), sequencing quality (do the frames progress logically?), or comparison against alternative approaches. This makes it impossible to assess whether the interleaved generation quality is competitive or merely plausible-looking.

Chain-of-Thought Reasoning for Visual Generation

The paper reports a controlled experiment on an intermediate model checkpoint (Section 6.4) where fine-tuning on 1M instruction-reasoning-image triplets raised the WISE score from 0.60 to 0.70. This is reported as a "substantial performance boost" and a "significant relative improvement." However, several caveats apply:

1. This is on an intermediate checkpoint, not the final model. The paper does not report CoT results for NextFlow or NextFlow-RL, so it is unclear whether the final models would benefit similarly.
2. The baseline of 0.60 is below the base NextFlow's reported WISE score of 0.59 (Table 6). This means the intermediate checkpoint was already at the final model's performance level on WISE before CoT fine-tuning. The improvement to 0.70 would place it above NextFlow-RL's 0.62, suggesting CoT reasoning could substantially boost world knowledge expression — but this was not validated on the final model.
3. No comparison against alternative approaches. It is unclear whether simply training on more data (without reasoning traces) or using a larger model would achieve similar gains. The 0.60 → 0.70 improvement could be partly attributable to the additional 1M training samples rather than the reasoning structure.
4. The claim that CoT reasoning is a distinct advantage of unified AR architectures is not directly tested — there is no comparison showing that a hybrid model (e.g., BAGEL) with a separate text-based reasoning step before diffusion generation would perform worse.

In-Context Learning for Image Editing

The in-context learning results (Section 6.5, Figure 20) are purely qualitative, showing examples where the model infers a transformation pattern from example image pairs and applies it to a new input. The paper does not report a quantitative benchmark for in-context learning. There is no measurement of how often the model successfully infers the correct transformation, how its performance varies with the number of provided examples, or how it compares to specialized in-context editing models like OmniGen2 or FLUX.1 Kontext. This is a significant omission given that in-context learning is presented as a key capability (Section 1: "unifying abilities of image editing, interleaved content and video generation") and is prominently visualized in Figure 20.

Image Reconstruction

Quantitative results (Table 12). On ImageNet-1K at 512², NextFlow achieves PSNR of 25.228 and SSIM of 0.820, compared to the original TokenFlow (PSNR 23.147, SSIM 0.761) — a +2.08 dB improvement. At 1024² on the in-house benchmark, NextFlow achieves PSNR of 28.038 and SSIM of 0.900. These are tokenizer-level evaluations (measuring how faithfully the VQ decoder reconstructs the input image from quantized codes) and demonstrate that the improved training recipe (multi-stage training, 50% scale dropout, decoder doubling) substantially improves reconstruction fidelity over the baseline. However, the paper does not provide comparisons against other state-of-the-art tokenizers (e.g., the tokenizer used in EMU3.5 or Infinity) or against continuous VAE encoders used in diffusion models, making it difficult to contextualize these numbers.

Qualitative comparison (Figure 21). Visual results show that the VQ decoder produces satisfactory reconstructions with some loss of fine detail (particularly visible in small faces and text). The optional diffusion decoders (1B, 12B, 18B) progressively improve detail quality, with the 18B model producing near-photorealistic reconstructions. However, the paper notes that the diffusion decoder is disabled for all benchmark evaluations — meaning the quantitative results in Tables 4–11 are from the VQ decoder alone. This is important context: the model's competitive performance on T2I and editing benchmarks is achieved without the diffusion refinement that provides the highest visual quality.

Multimodal Understanding

Results (Table 13). Fine-tuning the base NextFlow on 0.7M LLaVA-1.5 SFT data yields performance comparable to the 13B LLaVA-1.5 baseline (MMStar: 44.0 vs. 36.7, ChartQA: 18.7 vs. 20.4, MMB: 65.3 vs. 67.7, MMMU: 35.1 vs. 36.4). The 7B NextFlow model is roughly competitive with a model nearly 2× its size, suggesting efficient use of parameters. Scaling to 21M SFT data significantly boosts document-oriented tasks (ChartQA: 18.7 → 50.4, OCRBench: 35.6 → 44.8) but does not uniformly help all benchmarks (MMStar slightly declines from 44.0 to 42.8). The 40M composite data (19M captioning mid-train + 21M SFT) yields the best results across nearly all benchmarks (MMStar: 53.0, ChartQA: 57.7, OCRBench: 55.1, MME: 1897.7, MMB: 66.7, MMMU: 37.1, TextVQA: 58.9).

The paper's honesty about understanding limitations is notable. The authors explicitly state:

"We observe that simultaneously supporting multimodal understanding and image generation within a dense 7B decoder-only model imposes a significant capacity bottleneck. Furthermore, due to the scarcity of our high-quality pre-training data for multimodal understanding, we minimize the understanding training in the late pre-training stage."

This acknowledges a genuine tension: the same 7B parameters must handle both generation and understanding, and the paper's training data heavily favors generation (billions of text-to-image samples vs. hundreds of millions of understanding samples). The results in Table 13 should be interpreted as lower bounds on what the architecture could achieve — with more balanced training data and perhaps a larger model, understanding performance would likely improve.

Ablation Studies and Robustness Checks

Tokenizer design: dual-branch vs. single-branch VQGAN (Figure 8). Under identical training protocols (40k steps, ~40M samples), the dual-branch tokenizer achieves consistently lower vision loss and superior GenEval scores compared to a single-branch VQGAN baseline, despite the single-branch variant having marginally higher reconstruction PSNR (+0.5 dB at 256²). The GenEval score at the final checkpoint is approximately 0.65–0.70 (read from Figure 8) for the dual-branch tokenizer versus approximately 0.45 for the single-branch baseline. This ablation directly supports the claim that semantic constraints produce a latent space that is structurally easier for the AR model to learn, though the paper does not probe why — e.g., by measuring properties of the latent space (smoothness, clustering, alignment with text embeddings) that might explain the difference.

Output head design: single-head vs. dual-head (Figure 9). In a lightweight setting (5M alignment + 5M SFT), the single-head architecture achieves lower total loss and vision loss throughout both phases, with comparable text loss during SFT. This ablation justifies the architectural simplicity of NextFlow's design. However, the experiment is limited to small-scale training; it does not establish whether the single-head advantage persists at the full 6 trillion token scale, where separate heads might allow better modality-specific specialization.

Self-correction strategy (Figure 10). This is the most informative ablation in the paper because it contains a negative result that guided architectural design. The key findings:

• Self-correction with accumulated VAR features (the standard approach from VAR) degrades performance below the non-corrected baseline (green line, p=1.0, 30% of tokens).
• Replacing accumulated features with residual features (independently retrieved codebook embeddings without accumulation) transforms self-correction from harmful to beneficial.
• Optimal self-correction intensity: applied with probability 1.0 (100% of samples) to 60% of visual tokens per scale achieves the best GenEval score (~0.56 at 50k steps vs. ~0.48 for the non-corrected baseline).

The ablation is conducted on a 2B parameter model with a 16,384-size codebook and a high-quality LAION subset, which is a weaker setting than the final 7B model. The paper does not validate whether the optimal self-correction settings (p=1.0, 60% tokens) transfer to the larger model or whether the residual feature benefit generalizes.

Text-only data mixing (Table 1). Incorporating 25% text data during training does not adversely affect text-to-image generation quality. GenEval scores at iterative checkpoints (12M, 24M, 36M, 48M samples seen) are comparable between the pure-T2I setting and the +25% text setting (e.g., 0.505 vs. 0.499 at 48M samples). This ablation establishes that language capabilities can be maintained without sacrificing visual generation — important for the unified architecture claim, but conducted at a small scale relative to the full 6 trillion token training run.

Scale reweighting necessity (Figure 11). During the 256→512 resolution transition, lower-scale losses exhibited an upward trend (numerical values not quoted, but visible in the figure), and generated images showed increased artifacts and structural degradation (Figure 11b vs. 11a). The GenEval score dropped from 0.67 to 0.57. Introducing scale reweighting with α = 0.9 resolved these issues. This is less a controlled ablation and more a diagnostic finding from the training process, but it serves as empirical validation that scale reweighting is necessary for stable high-resolution training.

GRPO prefix-tuning length (Figure 12). The number of prefix scales optimized during RL significantly affects training stability and reward improvement:

• Prefix-256: smoothest reward increase, from ~0.96 to ~1.26 over 400 steps (~31% improvement).
• Prefix-64 and Prefix-128: faster initial improvement but higher variance.
• Prefix-512: slower improvement and plateaus at a lower value (~1.15).
• Vanilla GRPO (all scales): highest variance, with reward values oscillating between ~1.03 and ~1.10 with no clear upward trend.

The optimal prefix length of 256 scales is roughly 14 of the 18 total scale steps (for 1024×1024 generation), meaning the RL updates are applied to coarse and intermediate scales but not the finest detail scales. This makes intuitive sense but was determined empirically; the paper does not provide a theoretical framework for choosing the optimal prefix length given a generation schedule.

Multimodal understanding data scaling (Table 13). Increasing SFT data from 0.7M to 21M to 40M samples yields progressive improvements, particularly on document-heavy benchmarks (ChartQA from 18.7 to 50.4 to 57.7). The inclusion of a 19M captioning mid-train phase before the 21M SFT (the 40M total setting) yields the most robust improvements, suggesting that high-quality captioning data helps align visual and textual representations before task-specific SFT. However, the paper does not report the base model's performance without any SFT (zero-shot understanding), which would establish how much understanding capability is retained directly from pre-training.

Optional diffusion decoder scaling (Figures 21, 22, 23). Visual comparisons across VQ decoder, 1B UNet, 12B Transformer, and 18B Transformer diffusion decoders show progressive improvement in detail fidelity (particularly small faces and text). This is qualitative only — no quantitative metrics (FID, LPIPS, DISTS) are reported for the diffusion decoder's refinement quality vs. the VQ decoder baseline.

Missing ablations. Several experiments that would strengthen the paper's claims are absent:

• No ablation of the dual-codebook design itself — what happens if only the pixel codebook is used (matching standard VQ-VAE)? Figure 8 compares against a single-branch VQGAN (different architecture), not against a dual-codebook variant where one codebook is ablated.
• No ablation of next-scale prediction vs. raster-scan at matched model size and training data — the speed advantage is clear, but it would be valuable to know whether next-scale prediction also improves quality at matched compute or whether it is purely an efficiency gain.
• No ablation of the SigLIP2 initialization — what if a weaker semantic teacher or no semantic teacher is used?
• No ablation of the interleaved training data — how much does interleaved data contribute to editing and subject-driven generation capabilities?
• No ablation of the RL reward model — what dimensions does the reward model evaluate, and how does reward model quality affect final performance? The paper mentions the reward model only in passing (Eq. 4) without architectural or training details.

Critical Assessment

Claim 1: "NextFlow achieves state-of-the-art performance among unified models and rivals specialized diffusion baselines in visual quality."

What the experiments demonstrate: On GenEval, NextFlow-RL (0.84) matches or comes close to top diffusion models (Qwen-Image: 0.87, Seedream 3.0: 0.84, GPT Image 1: 0.84) and substantially outperforms all other pure AR models (Janus-Pro-7B: 0.80, EMU3.5: 0.86 — note EMU3.5 is actually 0.02 higher, so "outperforms" requires the caveat that EMU3.5 and NextFlow-RL are within a narrow range). On DPG, NextFlow-RL (88.32) ties Qwen-Image (88.32) and is slightly above Seedream 3.0 (88.27) and EMU3.5 (88.26). On PRISM-Bench, NextFlow-RL (78.8) is slightly below Qwen-Image (79.9) and Seedream 3.0 (79.6).

Do the experiments support the claim? Partially. The claim of "rivaling specialized diffusion baselines" is supported for GenEval and DPG but is less clear on WISE (where GPT Image 1 at 0.80 is substantially ahead of NextFlow-RL at 0.62) and PRISM-Bench (where NextFlow-RL trails the top diffusion models by ~1 point). The claim of "state-of-the-art among unified models" is supported against other pure AR architectures but is complicated by: (a) EMU3.5 is reported at 0.86 on GenEval (higher than NextFlow-RL's 0.84), and (b) BAGEL (an AR+Diffusion hybrid) achieves 0.88 on GenEval and 0.52 on WISE. Whether NextFlow is truly "state-of-the-art" depends on how narrowly "unified models" is defined (pure AR only, or including AR+Diffusion hybrids?).

The missing comparison: No experiment directly compares NextFlow against diffusion models at matched inference compute. The paper claims 6× fewer FLOPs than MMDiT (Appendix A.2), but the benchmark comparisons are at each model's default quality settings — they do not control for compute budget. A stronger demonstration of "rivaling" would be: "NextFlow at X FLOPs matches diffusion model Y at 6X FLOPs." This experiment is not performed.

Claim 2: "NextFlow departs from traditional raster-scan methods, enabling the generation of 1024 × 1024 images in just 5 seconds—orders of magnitude faster than comparable AR models."

What the experiments demonstrate: The 5-second figure appears in the abstract and introduction but is never directly measured or validated in the experimental section. Appendix A.2 provides a theoretical FLOPs analysis showing ~6× fewer FLOPs than MMDiT, but this is not a wall-clock measurement on specific hardware. The paper does not report inference time benchmarks across different GPUs, batch sizes, or precision settings. The "orders of magnitude faster than comparable AR models" claim is based on the statement that raster-scan AR models take "over 10 minutes" (citing EMU3 and EMU3.5), implying a ~120× speedup.

Do the experiments support the claim? Weakly. The 5-second figure lacks methodological documentation: what hardware was used? What batch size? What precision? Is this end-to-end (including tokenizer encoding and VQ decoding) or just the transformer forward passes? The FLOPs analysis in Appendix A.2 shows that the speedup relative to raster-scan AR is fundamentally architectural (O(log N) vs. O(N²) steps), so the claim is theoretically grounded. But without concrete wall-clock measurements on specified hardware, the 5-second claim is closer to an advertisement than a reproducible experimental result. This is a significant weakness for a paper that makes speed a central contribution.

Claim 3: "NextFlow demonstrates...state-of-the-art performance in image editing."

What the experiments demonstrate: On ImgEdit, NextFlow-RL achieves the highest overall score (4.49), above EMU3.5 (4.41), Qwen-Image (4.27), and GPT Image 1 (4.20). On GEdit-Bench, NextFlow-RL (7.87) is the highest, above EMU3.5 (7.59). On OmniContext SINGLE, NextFlow-RL (8.67) is above OmniGen2 (7.81) but below GPT-4o (8.95). On the authors' own EditCanvas benchmark, NextFlow-RL (8.04) is third behind GPT Image 1 (8.67) and EMU3.5 (8.37).

Do the experiments support the claim? Yes, with the caveat that "state-of-the-art" depends on the benchmark weighting. NextFlow is the best model on ImgEdit and GEdit-Bench (two widely-used editing benchmarks), is competitive on OmniContext, and is third on EditCanvas. The consistency across multiple editing benchmarks strengthens the claim — it suggests a genuine editing capability rather than benchmark-specific optimization. However, the EditCanvas result (where NextFlow is behind two proprietary models) and the lack of statistical significance testing (the gap between NextFlow-RL's 4.49 and EMU3.5's 4.41 on ImgEdit could be noise) warrant some caution.

The specific strength: NextFlow-RL's exceptionally high Subject Consistency scores (9.22 on OmniContext SINGLE, 8.78 on EditCanvas subject-driven generation) suggest that the dual-codebook tokenizer and interleaved pre-training are particularly effective at identity preservation — a capability that is challenging for many editing models. This is a more specific and defensible claim than "state-of-the-art in image editing" generally.

Claim 4: "A prefix-tuning strategy for GRPO...stabilizes RL training and effectively aligns the model with downstream objectives."

What the experiments demonstrate: Figure 12 shows that prefix-tuning (especially with prefix length 256) produces a smoother and more monotonic reward increase than vanilla GRPO, which exhibits high variance and no clear improvement trend. The reward improves from ~0.96 to ~1.26 (~31%) over 400 steps with prefix-256, while vanilla GRPO oscillates around ~1.03–1.10.

Do the experiments support the claim? Partially. The experiment demonstrates improved training stability — the reward trajectory is visibly smoother. However, the paper does not directly measure "alignment with downstream objectives" in a way that isolates the RL contribution. The Tables (4, 5, 7, 8, 10, 11) compare NextFlow vs. NextFlow-RL, but the improvement from RL is often modest (GenEval: 0.83 → 0.84, ImgEdit: 4.44 → 4.49, EditCanvas: 7.93 → 8.04). In some cases, RL slightly worsens specific sub-scores (Text Rendering on PRISM-Bench drops from 50.3 to 49.8). The paper does not ablate the prefix-tuning strategy against other stabilization techniques (e.g., smaller learning rates, KL penalty tuning, reward normalization) to show that prefix-tuning specifically is responsible for the stability improvement rather than, say, a well-tuned baseline GRPO.

The missing experiment: A direct comparison of prefix-tuning GRPO against an alternative RL strategy (e.g., DPO on the same reward data, or full-model GRPO with more aggressive KL regularization) would establish whether prefix-tuning is uniquely effective or simply one of several viable approaches.

Claim 5: "NextFlow is highly efficient, requiring 6× fewer FLOPs during inference compared to MMDiT-based diffusion models."

What the experiments demonstrate: A theoretical FLOPs calculation in Appendix A.2 compares NextFlow (with realistic scale scheduling) to MMDiT at various resolutions, assuming matched hidden sizes and sampling steps. The FLOPs ratio ranges from 2.9× at 256² to 7.0× at 2048², with 6.0× at 1024².

Do the experiments support the claim? The calculation is mathematically sound given its assumptions, but the assumptions themselves are debatable:

• The comparison uses the same number of sampling steps (18) for both NextFlow and MMDiT. In practice, diffusion models often use 25–50 steps — NextFlow's 18 steps is comparable to few-step diffusion distillation methods, not to standard diffusion inference.
• The calculation assumes identical hidden sizes — but diffusion models and AR models typically have different architectural requirements, making "fair" comparison of hidden sizes ambiguous.
• The FLOPs calculation does not account for memory access patterns, which can dominate wall-clock time. The paper's KV-caching during next-scale prediction introduces sequential dependencies that may limit parallelism in ways the FLOPs calculation does not capture.
• No empirical wall-clock measurement is reported to validate the FLOPs ratio. The paper does not run MMDiT and NextFlow on the same hardware and measure actual generation time.

The 6× FLOPs reduction is a reasonable theoretical estimate, but it is not an experimental result — it is a modeling assumption. The paper would be stronger if it included actual throughput measurements at matched quality (e.g., "at comparable FID/GenEval scores, NextFlow generates images X× faster than diffusion model Y on GPU Z").

Overall Assessment Summary

The experimental section demonstrates that NextFlow achieves competitive or state-of-the-art performance on multiple benchmarks, particularly in image editing and subject-driven generation. The results convincingly show that a pure autoregressive model can match diffusion models on standard T2I benchmarks — this is the paper's central empirical contribution and is well-supported.

However, several important claims remain experimentally unvalidated: (1) the 5-second generation speed is not benchmarked on specific hardware, (2) the interleaved generation and in-context learning capabilities are demonstrated only qualitatively, (3) the RL improvements are modest and not clearly isolated from other post-training factors, (4) the efficiency advantage over diffusion is a theoretical calculation, not an empirical measurement, and (5) the understanding capability is substantially behind generation capability, making "unified" somewhat aspirational. The paper's strongest experimental results are on image editing benchmarks, where NextFlow consistently ranks at or near the top — this is where the unified architecture's integration of perception and generation provides the clearest empirical advantage.

6. Limitations and Trade-offs

The Discrete Quantization Bottleneck: A Hard Ceiling on Fine-Grained Detail

The fundamental architectural choice that enables NextFlow's efficiency — representing images as discrete tokens from a finite codebook — simultaneously imposes an information bottleneck that no amount of post-processing can fully escape. The authors are explicit about this:

"While our dual-codebook tokenizer significantly improves semantic density, the discrete nature of vector quantization inevitably imposes an information bottleneck compared to continuous latent spaces, occasionally necessitating our optional diffusion decoder for hyper-realistic refinement." (Section 7)

This is not a mere implementation detail — it is a hard performance ceiling for the pure AR approach. Vector quantization compresses a continuous image (with its continuous spectrum of colors, textures, and edge placements) into a finite vocabulary of discrete codes. Information that falls between codebook entries is irrecoverably lost, and the decoder must hallucinate plausible details to fill the gaps. The dual-codebook design mitigates this by separating semantic and pixel-level information, allowing the pixel codebook to specialize in visual detail, but it does not eliminate the fundamental compression loss.

The consequence is most visible in tasks requiring precise fine-grained fidelity. On PRISM-Bench (Table 7), NextFlow-RL's Text Rendering score of 49.8 substantially trails Qwen-Image (61.6) and Seedream 3.0 (63.2) — a gap of approximately 11–13 points. This is not coincidental: small text characters require exact placement of high-frequency detail (individual letter strokes, serifs, spacing), and the discrete token reconstruction introduces blurring or distortion that is particularly damaging to legibility. The paper's Figure 21 makes this visible: the VQ decoder produces satisfactory overall reconstructions but shows noticeable degradation in small faces and text, which the optional diffusion decoder (18B) partially recovers — but with the acknowledged trade-off that "the stochastic nature of the diffusion process may alter fine-grained structures, potentially impacting performance in tasks requiring strict spatial consistency, such as local editing or identity preservation" (Section 2.3).

On ImageNet-1K reconstruction (Table 12), NextFlow achieves PSNR of 25.228 at 512² and 27.410 at 1024² — these are reasonable compression ratios but represent substantial information loss relative to the original images. A continuous VAE encoder used in diffusion models (e.g., SD3's 16-channel latent space) can achieve PSNR values in the 30–35 range at comparable compression rates. The practical implication is that NextFlow will systematically underperform on any task where pixel-level precision matters — text rendering, logo generation, fine texture synthesis, and detail-preserving editing are all fundamentally bounded by the codebook's representational capacity.

Evidence in the paper: The Text Rendering gap on PRISM-Bench (Table 7, 49.8 vs. 61.6–63.2 for top diffusion models) is the clearest quantitative manifestation. The qualitative comparison in Figure 21 shows the VQ decoder's degradation on small faces and text, and the diffusion decoder's imperfect recovery. The authors acknowledge the trade-off explicitly in Section 2.3 when discussing why the diffusion decoder is disabled by default.

Mitigation status: Partially addressed. The optional diffusion decoder (Section 2.3, Section 3.3) is the paper's primary proposed mitigation, and the visual results (Figures 21, 22, 23) show it substantially improves detail quality. However, the authors themselves note the trade-off (spatial consistency vs. perceptual quality) and disable it for all benchmark evaluations — meaning the competitive scores in Tables 4–11 are achieved without the refinement that provides the best visual quality. No quantitative metrics (FID, LPIPS, DISTS) are reported for diffusion decoder refinement, making it impossible to assess how much of the detail gap it actually closes. The paper also suggests future work on "next-generation tokenization" (Section 7) including variable-rate quantization and semantic-aware compression, but these remain aspirational.

The 7B Parameter Budget: A Capacity Bottleneck for Joint Understanding and Generation

NextFlow uses a 7-billion-parameter model to simultaneously perform text understanding, text generation, visual understanding, visual generation, and image editing — a substantially broader task portfolio than either specialized LLMs (which devote all parameters to language) or specialized diffusion models (which devote all parameters to visual generation). The authors are transparent about the consequences:

"We observe that simultaneously supporting multimodal understanding and image generation within a dense 7B decoder-only model imposes a significant capacity bottleneck." (Section 6.7)

This is not a hypothetical concern — it manifests concretely in the experimental results. On multimodal understanding benchmarks, NextFlow fine-tuned on 40M samples (Table 13) achieves MMB of 66.7 and MMMU of 37.1. These scores are competitive with LLaVA-1.5-13B (a model nearly 2× larger and specialized for understanding) but substantially below state-of-the-art multimodal understanding models at similar scales (e.g., Qwen2.5-VL-7B, the model NextFlow was initialized from, achieves substantially higher scores on these benchmarks in its original configuration). On the generation side, the WISE benchmark (Table 6) reveals a substantial gap in world knowledge: NextFlow-RL scores 0.62 overall versus GPT Image 1 at 0.80, with the largest deficits in Chemistry (0.39 vs. 0.74) and Biology (0.58 vs. 0.83).

The capacity bottleneck creates a zero-sum competition between understanding and generation. The same parameters that encode factual knowledge about chemistry and biology must also encode the ability to render photorealistic textures, follow editing instructions, and maintain subject identity across transformations. The paper's training data allocation reflects this tension: the pre-training corpus is heavily skewed toward generation tasks (billions of text-to-image samples) with relatively sparse understanding data (520M image-to-text samples at 256-res, and "we minimize the understanding training in the late pre-training stage" per Section 6.7). The result is a model that is strong at generation (competitive with diffusion models on GenEval and DPG) but substantially weaker at understanding (below what a 7B model specialized for understanding would achieve).

The consequence for practitioners is that NextFlow, in its current form, is not a drop-in replacement for either a specialized LLM or a specialized diffusion model. If a deployment requires strong visual understanding (medical image analysis, detailed document QA, fine-grained visual reasoning), NextFlow's performance will likely be inadequate. If it requires world-class text rendering or hyper-realistic detail, the discrete tokenization bottleneck (Limitation 1 above) compounds the capacity limitation. The model's "unified" nature is both its strength (seamless interleaved generation and editing) and its weakness (neither capability is as strong as a comparably-sized specialized model).

Evidence in the paper: Table 13 shows understanding performance that, while competitive with older baselines (LLaVA-1.5-13B), falls short of what a 7B model with dedicated vision-language training can achieve. Table 6 shows substantial world knowledge deficits on WISE. The quote in Section 6.7 explicitly acknowledges the capacity bottleneck.

Mitigation status: Partially addressed through training data engineering. The paper demonstrates that scaling SFT data from 0.7M to 40M samples substantially improves understanding (Table 13), suggesting that the bottleneck is partly about data allocation rather than an absolute capacity limit. The paper also points to future work on Mixture-of-Experts (MoE) architectures in Section 7: "We conducted a toy experiment and proved that transition from dense architectures to Mixture-of-Experts (MoE) frameworks significantly improves the overall generation quality." An MoE architecture could increase effective capacity without proportional compute increase, potentially relaxing the capacity constraint. However, no MoE results are reported in the paper, and the understanding vs. generation trade-off in an MoE context (e.g., whether experts naturally specialize by modality) remains unexplored.

Undocumented and Unaccounted Difficulty Estimation and Inference Costs

NextFlow's headline efficiency claims — 5 seconds per 1024×1024 image, 6× fewer FLOPs than MMDiT — are based on the core transformer forward passes during next-scale generation. However, these numbers exclude several practical costs that a real deployment must incur. The paper does not attempt to hide this, but it also does not account for these costs in any efficiency claim:

1. Tokenizer encoding cost: To generate an image, the model must first encode any input images through the dual-codebook tokenizer. This requires forward passes through the SigLIP2 semantic encoder (a vision transformer) and the CNN pixel encoder. The paper reports that during training, "we pre-extract image indices offline across all training stages, thereby eliminating online encoding latency" (Section 4). But for interactive deployment — where users upload images for editing or in-context learning — this encoding must happen online and adds latency to every request that includes visual input.

2. VQ decoding cost: After the transformer generates discrete visual indices, these must be decoded back to pixels through the VQ decoder (and optionally the diffusion decoder). The VQ decoder forward pass is relatively cheap (it is a CNN upsampling network), but the optional diffusion decoder requires a full multi-step diffusion sampling process — potentially adding seconds of latency and substantial FLOPs not accounted for in the transformer FLOPs calculation.

3. Prefilling KV-cache for conditional generation: In editing and subject-driven generation tasks, the model must process the entire input sequence (text instructions + reference images) before generating any output. This "prefill" phase is a single forward pass that is substantially more expensive than each subsequent autoregressive step, but its cost is amortized over the generation. For tasks with long input contexts (multiple reference images, detailed editing instructions, CoT reasoning traces), the prefill cost can dominate the total inference time.

The consequence is that the 5-second figure — which the paper promotes prominently in the abstract and introduction — is a lower bound on wall-clock time under idealized conditions (text-to-image generation with no input images, no diffusion decoding, on unspecified hardware). For image editing tasks (the area where NextFlow shows its strongest results), additional encoding and decoding latencies will increase the end-to-end time, potentially substantially. The paper does not provide end-to-end latency measurements for any task, making it impossible for practitioners to estimate real-world inference costs.

Evidence in the paper: The 5-second claim appears in the abstract and Section 1 without hardware specification. The FLOPs analysis in Appendix A.2 explicitly compares only transformer forward passes: "To evaluate the inference cost fairly, we compare the Floating Point Operations (FLOPs) required to generate a 1024 × 1024 resolution image" — this calculation includes attention and FFN costs for the transformer, but not tokenizer encoding/decoding, KV-cache management, or any I/O overhead. The paper acknowledges offline pre-extraction for training (Section 4) but does not discuss how this cost maps to inference.

Mitigation status: Not addressed. The paper provides no end-to-end latency breakdown, no measurement of tokenizer encoding/decoding time, and no accounting of these costs in efficiency claims. A practitioner considering deploying NextFlow for interactive image editing would need to measure these costs independently on their specific hardware — the paper provides no guidance.

Single Benchmark Family, Single Model Initialization: The Generalization Question Is Unanswered

All of NextFlow's experimental results — across text-to-image generation, image editing, subject-driven generation, and multimodal understanding — are evaluated using a single base model initialization (Qwen2.5-VL-7B) and a single family of benchmarks (English-language, largely photorealistic, Western-centric image content). The paper does not evaluate on:

• Code generation or diagram generation (e.g., generating charts, graphs, UI mockups, architectural diagrams), which would test the model's ability to handle structured visual content beyond natural images.
• Non-English text rendering or multilingual visual generation, which would test whether the dual-codebook tokenizer's semantic branch (initialized from SigLIP2, an English-aligned vision-language model) transfers to other languages and cultural visual contexts.
• Video generation (the paper mentions video generation capabilities in the abstract — "unlocking abilities of image editing, interleaved content and video generation" — but provides no video generation results or evaluation).
• Alternative base model initializations — what if NextFlow were built on a different backbone (e.g., LLaMA-3, Phi-3, DeepSeek-V2)? Would the architectural innovations (next-scale prediction, dual-codebook tokenizer, prefix-tuning GRPO) transfer, or are they dependent on specific properties of Qwen2.5-VL's pretraining?
• Downstream robustness — adversarial prompts, out-of-distribution editing instructions, edge-case aspect ratios not covered by the 40 predefined scale schedules (Table 14).

The concern is not that NextFlow necessarily fails on these dimensions — it might succeed — but that the paper provides no evidence either way. A practitioner considering NextFlow for deployment outside the narrow envelope of the evaluated benchmarks (photo-realistic English-language T2I and editing) has no empirical basis for estimating performance.

Evidence in the paper: The text-to-image benchmarks (GenEval, DPG, WISE, PRISM-Bench) all evaluate Western-centric, English-language photorealism. The editing benchmarks (ImgEdit, OmniContext, GEdit-Bench, EditCanvas) similarly focus on photorealistic image editing with English instructions. The interleaved generation examples (Figure 18) are English narratives. The multimodal understanding evaluation (Table 13) uses standard English benchmarks (MMStar, ChartQA, etc.). The paper does not mention non-English capabilities, structured visual generation, or video generation evaluation (despite "video generation" appearing in the abstract).

Mitigation status: Not addressed, except indirectly through the predefined scale schedules in Appendix A.1 (Table 14) which show the model supports 40 aspect ratios from 1:4 to 4:1 — suggesting some degree of resolution/aspect ratio flexibility. The paper does not frame this as a limitation or suggest future work on broader evaluation. This is a notable omission for a paper that claims "NextFlow serves as a proof of concept that a single decoder-only transformer can effectively perceive, reason, and create" — the "proof" is established only within a specific, narrow domain.

Reinforcement Learning Improvements Are Modest and Poorly Isolated

The paper presents prefix-tuning GRPO (Section 3.2.5) as a key innovation and includes "NextFlow-RL" as a distinct model variant in all benchmark tables. However, the quantitative contribution of RL to the final model's performance is often small, and in some cases, RL appears to trade off improvements in some dimensions against regressions in others — without the paper analyzing these trade-offs.

Examining the key benchmark tables:

• GenEval (Table 5): NextFlow 0.83 → NextFlow-RL 0.84 (+0.01)
• DPG (Table 4): NextFlow 86.00 → NextFlow-RL 88.32 (+2.32) — a more meaningful improvement
• WISE (Table 6): NextFlow 0.59 → NextFlow-RL 0.62 (+0.03)
• PRISM-Bench (Table 7): NextFlow 74.7 → NextFlow-RL 78.8 (+4.1) — the largest improvement, but with Text Rendering actually declining (50.3 → 49.8)
• ImgEdit (Table 8): NextFlow 4.44 → NextFlow-RL 4.49 (+0.05)
• GEdit-Bench (Table 10): NextFlow 7.60 → NextFlow-RL 7.87 (+0.27)
• EditCanvas (Table 11): NextFlow 7.93 → NextFlow-RL 8.04 (+0.11)

The pattern across benchmarks is: RL provides a small but consistent improvement (typically 0.01–0.05 on 0–10 scales, or 1–4 points on 0–100 scales), with occasional larger gains (DPG +2.32, PRISM-Bench +4.1) and occasional regressions (PRISM-Bench Text Rendering −0.5). The paper does not establish whether these improvements are statistically significant (no confidence intervals, no multiple-seed averages) or whether they could be achieved through simpler means (additional SFT data, continued training, or a different reward formulation).

The consequence is uncertainty about the practical value of the RL stage. If a practitioner is deciding whether to invest in the full RL pipeline (reward model training, GRPO infrastructure, prefix-tuning hyperparameter search) versus simply training longer or curating better SFT data, the paper provides no direct comparison to guide this decision. The prefix-tuning strategy is innovative and the Figure 12 reward trajectory is compelling, but the translation from improved training rewards to improved downstream benchmark scores is weak — the paper never shows the correlation between GRPO reward and, say, GenEval score during RL training.

The Text Rendering regression on PRISM-Bench (50.3 → 49.8) raises a specific concern: RL may be optimizing a reward that is misaligned with some quality dimensions, causing the policy to sacrifice text rendering fidelity for gains in imagination, entity accuracy, and composition. The paper does not discuss this potential trade-off, what the reward model actually measures, or whether the reward model was specifically designed to avoid such regressions.

Evidence in the paper: The benchmark tables show the RL improvement magnitudes. Figure 12 shows the reward trajectory during GRPO training. The PRISM-Bench sub-task breakdown (Table 7) reveals the Text Rendering regression. The paper does not report the correlation between GRPO reward and downstream metrics, nor does it ablate the RL stage against alternative post-training strategies (additional SFT, rejection sampling, best-of-N selection from SFT model outputs).

Mitigation status: Not addressed. The paper presents RL as an integral part of the training pipeline and reports NextFlow-RL as the primary model, but does not critically examine the RL contribution or its trade-offs. A reader cannot determine whether RL is providing a meaningful capability improvement or a marginal refinement that could be achieved through other means. The paper's framing — "prefix-tuning strategy for GRPO...stabilizes RL training and effectively aligns the model with downstream objectives" (Section 3.2.5) — implies stronger benefits than the quantitative results demonstrate.

The EditCanvas Benchmark: A Self-Proposed Evaluator Without Independence Safeguards

The paper introduces EditCanvas (Section 6.2, Appendix B) as "a novel and meticulously structured benchmark" designed to address limitations of existing editing benchmarks. EditCanvas is then used as one of the primary evaluation suites for NextFlow, and the paper reports NextFlow-RL's performance on it (Table 11) alongside established benchmarks. This creates a self-evaluation risk: the benchmark was designed by the same team that built the model, potentially incorporating design choices (task distribution, evaluation protocol, difficulty calibration) that favor NextFlow's specific capabilities.

The paper describes EditCanvas's construction: "We began by sourcing high-resolution images (over 1K) from open datasets like LAION and COYO, filtering out those with plain white backgrounds. We then employed a state-of-the-art Vision-Language Model (VLM) to automatically generate corresponding editing instructions for each image. To ensure the benchmark's reliability and quality, these samples underwent a rigorous two-round manual filtering process" (Appendix B). The hierarchical taxonomy (Traditional Editing and Subject-Driven Generation, each with sub-categories and 56 fine-grained tasks) and the hybrid evaluation metric (GPT-4.1 for assessment) are proposed as advances over existing benchmarks.

However, several standard practices for de-risking self-proposed benchmarks are absent:

• No held-out development process: The paper does not describe developing EditCanvas independently of model evaluation (e.g., finalizing the benchmark before evaluating any model on it, or using a separate team for benchmark creation vs. model development).
• No correlation analysis with established benchmarks: The paper does not show whether EditCanvas scores correlate with ImgEdit, GEdit-Bench, or OmniContext scores across models — such correlations would establish that EditCanvas measures similar constructs to existing benchmarks and is not an idiosyncratic evaluator.
• No analysis of benchmark difficulty or discrimination: Are the 56 fine-grained tasks equally difficult? Do they discriminate between models of different quality levels? Some tasks may be too easy (ceiling effects) or too hard (floor effects) to provide useful signal, but this is not analyzed.
• No comparison of VLM-as-judge reliability: The paper uses GPT-4.1 to evaluate EditCanvas outputs, but does not report inter-rater reliability (e.g., correlation with human judgments, consistency across multiple GPT-4.1 evaluations of the same output, sensitivity to prompt phrasing).

The consequence is that EditCanvas scores should be interpreted with greater caution than scores on independently developed benchmarks (ImgEdit, GEdit-Bench) that have been used by multiple research groups and have established community credibility. The fact that NextFlow-RL ranks third on EditCanvas (behind GPT Image 1 and EMU3.5) partially mitigates the concern — if the benchmark were designed to favor NextFlow, the authors could have engineered a more favorable outcome. However, the lack of documented independence and validation means EditCanvas cannot yet serve as strong independent evidence of NextFlow's editing capabilities.

Evidence in the paper: Appendix B describes the EditCanvas construction process in detail. Table 11 reports EditCanvas scores alongside ImgEdit (Table 8), OmniContext (Table 9), and GEdit-Bench (Table 10) results. The paper presents EditCanvas as an equal-status evaluator alongside these established benchmarks, without discussing the self-evaluation concern.

Mitigation status: Partially addressed by the inclusion of established benchmarks (ImgEdit, GEdit-Bench, OmniContext) alongside EditCanvas — the paper does not rely exclusively on its own benchmark. The fact that NextFlow-RL underperforms two proprietary models on EditCanvas reduces (but does not eliminate) the concern of benchmark design bias. The paper does not discuss independence safeguards or validation of EditCanvas against existing benchmarks.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper reshapes the conversation around unified multimodal models by demonstrating that a pure autoregressive architecture can match or exceed state-of-the-art diffusion models across generation, editing, and understanding — provided the generation paradigm and tokenizer design are fundamentally restructured. Prior to NextFlow, the field operated under an implicit consensus: AR models were architecturally elegant but practically non-viable for high-resolution visual generation due to their $O(N^4)$ raster-scan computational scaling, while diffusion models, despite their architectural complexity and modality-specific optimization, dominated visual quality benchmarks. Hybrid architectures (Transfusion, Bagel) emerged as a compromise — keeping AR for text while offloading vision to diffusion — but introduced representation gaps that complicated interleaved tasks and prevented seamless end-to-end gradient flow across modalities.

NextFlow breaks this consensus by demonstrating that the apparent limitations of AR were artifacts of the raster-scan generation paradigm and reconstruction-only tokenization, not fundamental properties of autoregressive modeling. By adopting next-scale prediction (VAR) for visual generation — which restructures the sequential generation from $O(N^2)$ token-by-token steps to $O(\log N)$ scale-by-scale steps — the paper shows AR models can generate 1024×1024 images in roughly 5 seconds, comparable to diffusion models and >100× faster than raster-scan AR counterparts. By adopting a dual-codebook tokenizer (TokenFlow) that decouples semantic and pixel-level features, the paper shows AR models can achieve semantic density competitive with dedicated vision encoders while maintaining reconstruction fidelity.

The significance is not merely that "AR works for vision" — it is that AR works for vision when the generation order matches the natural hierarchical structure of visual data. Raster-scan order imposes a 1D sequential structure on inherently 2D data; next-scale prediction imposes an $n$-D hierarchical structure that aligns with how images are naturally organized (coarse layout → structural details → fine textures). This reframes the AR vision problem from "how do we make sequential prediction fast enough?" to "what is the right prediction order for this modality?" — a conceptual shift that opens design space beyond raster-scan and next-scale to other structured prediction orders (e.g., object-first, depth-first, saliency-guided).

For the broader field, this work redirects research attention in several ways:

• Away from hybrid architectures: If a pure AR model can match diffusion quality while maintaining architectural simplicity, the case for hybrid AR-diffusion systems (with their dual representations, dual objectives, and re-encoding overheads) weakens. Hybrid systems were a response to the perceived impossibility of competitive pure AR generation — NextFlow challenges that premise directly. This does not mean hybrid research stops (BAGEL's 0.88 GenEval score is still competitive), but it means the burden of proof shifts: hybrid systems must now demonstrate clear advantages over well-engineered pure AR models rather than assuming AR is inherently inferior.

• Toward generation-order research: NextFlow validates next-scale prediction at scale (6 trillion tokens, 7B parameters), but the broader question — "what is the optimal generation order for visual and multimodal data?" — is now empirically tractable. The paper opens investigation into alternatives: should video be generated frame-by-frame, scale-by-scale, or object-by-object? Should interleaved text-image sequences be generated in document order or in semantic-dependency order? The next-scale paradigm provides a template for reasoning about generation order as a design choice rather than a fixed constraint.

• Toward tokenizer design as an active inductive bias: The dual-codebook tokenizer's superiority over single-branch VQGAN (Figure 8), despite slightly worse reconstruction PSNR, establishes that tokenizer quality for generative modeling is not equivalent to tokenizer reconstruction fidelity. The "semantically aligned latent space" hypothesis — that constraints shaping the tokenizer's latent structure toward semantic meaning produce representations that are easier for autoregressive models to learn — suggests a research program around tokenizer design that optimizes for downstream learnability rather than intermediate reconstruction metrics. This echoes findings in the representation learning literature (REPA, VA-VAE) and applies them concretely to the unified multimodal setting.

• Toward RL for visual generation: The prefix-tuning GRPO strategy (Section 3.2.5, Figure 12) establishes that reinforcement learning is viable for multi-scale visual generation when optimization is restricted to semantically impactful scales. Prior to this, RL for image generation was largely unexplored or unreliable — the scale imbalance problem (where fine-scale tokens dominate gradient signals) made naive application unstable. NextFlow's solution (prefix-tuning + scale reweighting) provides a recipe that other hierarchical generative models (AR, diffusion, or flow-based) can adopt, opening RL-based alignment as a tool for visual generation that was previously inaccessible.

The paper also reconciles a tension in the multimodal literature between models that "understand" (LLaVA-style, Qwen2.5-VL) and models that "create" (Stable Diffusion, FLUX). Prior unified models either leaned heavily toward one capability (Janus-Pro prioritized generation, sacrificing understanding) or combined separate systems (Transfusion, Bagel). NextFlow demonstrates that a single dense 7B model can achieve competitive performance on both fronts, suggesting that the understanding-generation trade-off is not an architectural inevitability but a capacity and data allocation challenge — one that larger models, better-balanced training data, or MoE architectures could mitigate.

However, this is not a paradigm shift in the sense of replacing diffusion models or establishing AR as universally superior. It is a reframing: the question changes from "AR or diffusion?" to "under what conditions does each paradigm excel, and how do we engineer AR to match diffusion where it currently lags?" Diffusion models retain advantages in fine-grained detail fidelity (the discrete quantization bottleneck remains a hard ceiling for AR) and in domains requiring continuous latent representations (e.g., scientific imaging where pixel-precise reconstruction matters). NextFlow's contribution is establishing that for the dominant use cases of consumer-oriented visual generation (prompt-following T2I, image editing, subject-driven generation), AR is now a viable and architecturally simpler alternative — not that it has rendered diffusion obsolete.

Follow-Up Research This Work Enables

1. Characterizing the optimal generation order for different visual content types. NextFlow uses a fixed scale schedule (Appendix A.1, Table 14) — the model always generates 1×1 → 2×2 → ... → 64×64 grids in the same coarse-to-fine order. But is this optimal for all images? A portrait might benefit from generating the face region at higher resolution earlier (saliency-guided ordering), while a landscape might benefit from generating the horizon first (depth-guided ordering), and a diagram might benefit from generating text regions before structural lines (content-guided ordering). The paper's ablation of next-scale vs. raster-scan is architectural (they are different paradigms), but it does not explore the design space within next-scale prediction — variable scale schedules, adaptive scale allocation, or input-conditioned generation orders. A strong follow-up would: (a) train NextFlow variants with different fixed generation orders (e.g., face-first, text-first, saliency-guided) on domain-specific datasets, (b) measure which orders improve quality for which image types (portraits: face-first; documents: text-first; natural scenes: coarse-to-fine), and (c) develop a lightweight "order predictor" that selects the generation schedule based on the text prompt or initial layout tokens. The GenEval sub-task breakdown (Table 5) already hints at sensitivity: NextFlow's Counting (0.75) lags behind diffusion models (Qwen-Image: 0.89), potentially because counting objects requires precise spatial allocation that coarse-to-fine ordering handles differently than diffusion's all-at-once refinement.

2. Scaling laws for unified autoregressive multimodal models. The paper demonstrates that a 7B model trained on ~6 trillion tokens achieves competitive performance, but provides no systematic study of how performance scales with model size, data volume, or the ratio of text-to-image data. The authors hint at this in Section 7 ("Following neural scaling laws, we anticipate that increasing model capacity will yield predictable gains... We conducted a toy experiment and proved that transition from dense architectures to Mixture-of-Experts (MoE) frameworks significantly improves the overall generation quality"), but no scaling curves are shown. A critical follow-up would train NextFlow variants at multiple scales (e.g., 1B, 3B, 7B, 13B) with matched training data, measuring: (a) whether GenEval/WISE/DPG scores follow power-law scaling with model size, (b) whether the understanding-generation trade-off (the "capacity bottleneck" noted in Section 6.7) changes slope with model size (does a 13B model close the gap to specialized models, or does the gap persist?), and (c) how the optimal text-to-image data ratio changes with model capacity. This would transform NextFlow from a single point demonstration into a predictive framework for unified multimodal scaling, analogous to what Hoffmann et al. (2022) did for language models. The GenEval score trajectory in Figure 7 (bottom) already suggests non-monotonic scaling behavior — the 256→512 resolution transition caused a performance dip — which scaling laws would need to model and predict.

3. Verifier design for multimodal reinforcement learning and the over-optimization problem. The prefix-tuning GRPO strategy (Section 3.2.5, Figure 12) demonstrates stable RL training, but the paper never specifies what the reward model actually measures, how it is trained, or whether the policy over-optimizes the reward signal (a well-documented failure mode in text-based RLHF). The PRISM-Bench Text Rendering regression (50.3 → 49.8 under RL, Table 7) is a red flag: the policy may be improving on reward-model-preferred dimensions (imagination, composition) while degrading on dimensions the reward model ignores or undervalues (text legibility). This is a classic reward hacking scenario. A critical follow-up would: (a) release the reward model architecture, training data, and reward dimensions (or use publicly available reward models like ImageReward, PickScore, or HPSv2 so the community can replicate), (b) measure the correlation between GRPO reward improvement and downstream benchmark improvement as RL training progresses (does the reward go up while GenEval plateaus? this would indicate over-optimization), and (c) apply the same diagnostic framework used in the RLHF literature — KL divergence from reference policy, reward model ensemble uncertainty, and human preference win-rate — to characterize the over-optimization threshold for visual RL. This would establish whether the modest benchmark improvements from RL (+0.01 on GenEval, +2.32 on DPG, Table 4-5) reflect genuine capability gains or exploitation of reward model blind spots.

4. End-to-end latency characterization and deployment optimization. The paper's headline efficiency claim — "5 seconds for a 1024 × 1024 image" — lacks hardware specification, latency breakdown, and measurement of non-transformer costs (tokenizer encoding, VQ decoding, optional diffusion decoding, KV-cache prefill for conditional generation). A deployment-oriented follow-up would: (a) benchmark end-to-end latency on standard hardware (A100, H100, consumer GPUs) for different task types (T2I generation, image editing with 1 reference image, interleaved generation with 5 images), measuring the contribution of each pipeline stage (tokenizer encoding: __ ms, transformer generation: __ ms, VQ decoding: __ ms, diffusion decoding: __ ms), (b) identify throughput bottlenecks — is the next-scale transformer generation memory-bound (limited by KV-cache size at high resolutions) or compute-bound? The FLOPs analysis in Appendix A.2 suggests a 6× theoretical advantage over MMDiT, but the KV-cache accumulation across scales (each scale adds tokens that increase memory access for all future scales) may make NextFlow memory-bandwidth-limited on current hardware, eroding the theoretical FLOPs advantage in practice, and (c) compare NextFlow's Pareto frontier (quality vs. latency) against diffusion models at matched wall-clock time — if NextFlow at 5 seconds matches FLUX.1-dev at 3 seconds, the practical speed advantage is less clear than the FLOPs ratio suggests. This would transform the efficiency claim from a theoretical calculation into actionable deployment guidance.

5. Ablating the source of unified model capabilities — what matters most? NextFlow combines multiple innovations (dual-codebook tokenizer, next-scale prediction, progressive resolution curriculum, scale reweighting, self-correction, interleaved pre-training, RL) into a single training recipe, but the paper does not isolate which components are necessary for which capabilities. Does editing ability (where NextFlow shows its strongest results) primarily come from the interleaved training data (147M samples at 256-res), from the dual-codebook tokenizer's semantic branch, or from the self-correction mechanism that handles exposure bias? A targeted ablation study would: (a) train NextFlow variants with individual components removed — no interleaved data, single-codebook tokenizer, no self-correction, no RL, no progressive resolution curriculum — and measure the impact on each benchmark family (T2I generation, editing, subject-driven generation, understanding), (b) determine the marginal contribution of each component to each capability, producing a "capability attribution matrix" that guides future research investment (e.g., if editing quality is largely determined by interleaved data volume, invest in data; if it is determined by the tokenizer, invest in representation learning), and (c) test for negative interactions — do some components help one capability but hurt another? The Text Rendering regression under RL (Table 7) already hints at such interactions, and the self-correction ablation (Figure 10) shows that feature representation choice can flip a technique from harmful to beneficial.

6. Stress-testing the next-scale paradigm on extreme resolutions, aspect ratios, and content types. The paper demonstrates next-scale prediction at up to 1024×1024 and 40 predefined aspect ratios (Table 14), but the scaling behavior at higher resolutions (2048×2048, 4096×4096) and non-standard aspect ratios (e.g., 1:10 for panoramas, 10:1 for scrolls) is unexplored. A stress-test would: (a) generate at 2048×2048 and measure whether structural coherence degrades — as the scale schedule adds more steps, do errors in early coarse scales compound more severely? The self-correction mechanism (Section 3.2.1) was designed for this, but was only validated up to 1024-res, (b) test aspect ratios outside the predefined 40 schedules (Table 14) — can the model generalize via interpolation of its sinusoidal scale length embeddings, or does it require explicit training on each ratio? The resolution-invariant RoPE (Section 2.2) is designed to support generalization, but has not been tested, (c) evaluate on content types not represented in the training data — medical images (X-rays, MRIs), satellite imagery, abstract art, scientific diagrams. Does next-scale prediction's coarse-to-fine structure provide a useful inductive bias for these domains, or does it impose an inappropriate prior (e.g., medical images may not have a natural "coarse layout" that generalizes across modalities)? This stress-test would map the boundaries of the next-scale paradigm's applicability, identifying where it is a genuine advance and where it is domain-specific.

Practical Applications and Downstream Use Cases

1. Interactive image editing at scale with a single model. Current production image editing workflows typically chain multiple specialized models: one for understanding the user's instruction, one for segmenting the relevant image region, one for inpainting/generating the edit, and post-processing filters for quality. NextFlow's unified architecture — which achieves a 4.49 overall score on ImgEdit (Table 8), state-of-the-art among all evaluated models — enables a single 7B model to handle the entire pipeline: understanding the natural language editing instruction, identifying what to change, preserving subject identity (Subject Consistency 9.22 on OmniContext, Table 9), and generating the edited result in roughly 5 seconds. For a service processing millions of user uploads per day, eliminating the multi-model pipeline reduces: (a) infrastructure complexity (one model to deploy, monitor, and update instead of three to five), (b) inter-model latency (no serial communication overhead between separate segmentation, inpainting, and refinement models), and (c) error propagation (no compounding of mistakes where a segmentation error ruins the inpainting stage). The concrete benefit is reducing the operational cost and engineering maintenance burden of an editing service while matching or exceeding the editing quality of multi-model pipelines — the 4.49 on ImgEdit vs. 3.44 for OmniGen2 and 4.27 for Qwen-Image quantifies this quality advantage.

2. On-device visual reasoning and generation with constrained model size. The paper's FLOPs-matched analysis (Appendix A.2, ~6× fewer FLOPs than MMDiT at 1024²) and the demonstration that a 7B model achieves competitive performance suggest a deployment scenario where a single model, small enough to run on edge hardware (e.g., a workstation GPU or future mobile NPU), handles both visual question answering and image generation. For applications like field service (a technician photographs equipment, asks "what part needs replacement?" and receives a generated diagram showing the repair), accessibility (a user photographs a room and says "show me how this would look with different furniture"), or education (a student photographs a math problem, asks for a visual explanation, and receives a step-by-step generated illustration), the unified architecture eliminates the need to switch between separate understanding and generation models. The understanding results (Table 13: MMStar 53.0, MMB 66.7 with 40M SFT samples) indicate reasonable visual comprehension for a 7B model, while the generation quality (GenEval 0.84, Table 5) matches top-tier diffusion models — making the combined capability practical for real-world use cases where switching between a specialized VLM (for understanding) and a specialized diffusion model (for generation) would be awkward or infeasible due to device memory constraints.

3. Data generation pipelines for multimodal model training and evaluation. NextFlow's interleaved generation capability (Figure 18) — demonstrated qualitatively for storytelling, recipe instructions, and dynamic scene generation — can be deployed as a synthetic data generator for training or evaluating other multimodal models. The model can produce coherent sequences of text interleaved with corresponding images (e.g., a textbook chapter with diagrams, a product catalog with descriptions, a technical manual with assembly illustrations), each pair verified by the model's own CoT reasoning process (Section 6.4, Figure 19) to ensure text-image consistency. The WISE score improvement from 0.60 to 0.70 with CoT fine-tuning suggests that when the model "thinks" before generating, it produces more logically consistent outputs — making it a more reliable data generator. For research groups lacking access to large-scale interleaved datasets (which are scarce compared to image-text pairs), NextFlow provides a way to generate high-quality, diverse, logically consistent multimodal documents at scale. The 5-seconds-per-image generation speed and the elimination of multi-model orchestration make this practical for generating millions of samples, where a pipeline approach (LLM for text → diffusion model for images → post-hoc consistency check) would require managing three separate models and their failure modes.

4. Multimodal chain-of-thought as a debugging and interpretability tool for visual generation. The CoT reasoning experiment (Section 6.4, Figure 19) demonstrates that NextFlow can articulate its reasoning process before generating an image — explaining why "China's national treasure" should resolve to a Giant Panda rather than a Red Panda, or why a "maple leaf in summer" should be green rather than red. While the paper presents this as a quality improvement mechanism, it has a more immediately practical application: interpreting and debugging generation failures. When the model produces an incorrect or biased output, the CoT trace provides an auditable reasoning path that can be inspected to understand the model's decision. For deployments where generation errors have significant consequences (e.g., generating medical illustrations, legal diagrams, or culturally sensitive content), this explainability is a compliance advantage over black-box diffusion models that provide no intermediate reasoning. The 0.60 → 0.70 WISE score improvement quantifies the quality benefit, but the interpretability benefit — being able to see why the model made a specific visual choice — is equally valuable for high-stakes applications, even if not directly measured in benchmarks.