Daily AI Paper

This paper is about a very specific bottleneck in multimodal AI: why unified models that can both reason in language and generate images still do not benefit from chain-of-thought-style reasoning the way large language models do. That matters because, in language models, giving the model more time to think at test time often improves performance. You can sample more reasoning steps, use more compute, and get better answers. For image generation, we would like the same thing: a model that can plan, decompose a prompt, keep track of attributes, and then generate a more faithful image. But the authors argue that current unified multimodal models do not really get that benefit. They can improve a bit on simple prompt-following, but once the task requires deeper semantic planning, the gains flatten out. More importantly, increasing the reasoning budget at inference does not produce the smooth scaling behavior people see in language models. The paper’s central diagnosis is a modality mismatch. Reasoning in current systems is done in discrete text tokens, but image generation happens in a continuous latent space. That creates a bottleneck. A chain of text tokens is good for explicit language, but it is not necessarily the best medium for storing dense, spatial, and visually grounded information. The authors suggest that if the image generator lives in continuous space, then the reasoning process should live there too. To understand the landscape, it helps to think about what unified multimodal models are trying to do. These systems embed an image-generation module inside a language model, so the model can interpret prompts, plan, and then produce images. This is different from a pure text-to-image model that only maps text to pixels or latent codes. The unified approach is attractive because the language model already contains rich semantics and world knowledge. But prior reasoning-augmented versions still largely reason in discrete token space, which means the “thinking” part and the “drawing” part speak different representational languages. The method in this paper, called LARC, short for Latent Reasoning in Continuous space, tries to close that gap. The key idea is to make reasoning itself happen through continuous hidden states rather than only through emitted text tokens. In other words, instead of forcing every thought into a word or token, the model can alternate between normal language tokens and latent reasoning steps that are directly represented by internal vectors. The trajectory format is interleaved. The model takes an input context, which can be a text prompt and optionally a source image, and then generates a sequence that alternates between language-mode spans and latent-mode steps. When it emits a special latent marker, the next step is not a token but the model’s own hidden state from the last transformer layer. After some fixed latent steps, it returns to language mode, and eventually the full latent trajectory is passed to the image module through cross-attention to generate the target image. This is important because it preserves the model’s internal semantic richness while avoiding the token bottleneck. The latent steps are not just compressed summaries of text; they are continuous states that can carry information in a form more naturally aligned with image synthesis. Training happens in two stages. The first stage is curriculum supervised fine-tuning. The authors note that if you simply introduce all latent steps from the start, training becomes unstable, because the latent stream has no direct supervision and the model has not yet learned the basic interleaved format. So they use a curriculum that gradually converts token-level reasoning into latent reasoning. Concretely, they collect one million interleaved chain-of-thought samples. Each sample contains the input context, a step-by-step reasoning chain, and the target image. They insert special latent markers at step boundaries. Then they train in phases. First, they suppress all latent steps and train on the text-only trajectory, which establishes the reasoning format using standard next-token prediction. Then, in later phases, they progressively activate more latent steps, always building on a stable prefix. The learning rate is reduced at each phase transition. The training objective combines normal text prediction loss with a flow-matching loss for the target image. The latent steps themselves do not have explicit ground-truth targets; instead, the gradient flows through them implicitly, encouraging the model to learn useful latent representations on its own. The second stage is reinforcement learning, and this is where the paper becomes especially interesting. The authors want to refine the latent reasoning trace so that it becomes not just plausible, but genuinely useful for image generation. But they face two problems. First, latent reasoning in the Coconut-style setup is deterministic, while policy-gradient methods need stochastic rollouts. Second, there is no obvious external evaluator for whether a latent trace is good. Their solution is a self-evolving RL loop. Stage 1 already gives the model latent reasoning capability. Stage 2 then improves it using an intrinsic reward based on information gain. The idea is simple: a latent reasoning trace should be rewarded if it helps a frozen reference model predict the target image better than the same model could from the context alone. In effect, the reward measures how much information the trace adds about the image. This is a nice fit for the problem, because it avoids needing ground-truth latent chains or a separate critic. The reward is derived from the model itself. Since direct log-likelihood is not always available in the image module, they estimate this information gain using a paired difference of conditional flow-matching losses under shared noise. That detail is technical, but the intuition is straightforward: compare how well the reference model predicts the image with and without the latent trace, and reward the trace when it reduces uncertainty. They also add a collapse-prevention term. Without it, all latent steps in a trajectory could converge to nearly identical vectors, which would defeat the purpose of having multiple reasoning steps. So the total reward includes both usefulness and diversity. For optimization, they use GRPO, a policy optimization method that estimates advantages from group rollouts and does not require an explicit value model, which makes the training simpler and more stable. For experiments, the authors instantiate LARC on BAGEL and train with one million interleaved samples drawn from FLUX-Reason, WEAVE, and ScaleEdit. They evaluate on several benchmarks. For text-to-image generation, they use GenEval, DPG-Bench, and OneIG-Bench. They also look at image editing with CompBench, and they include multimodal understanding benchmarks such as MME, MMB, MMMU, and MIRA to check that the method does not harm broader capabilities. The paper asks three main questions: does LARC improve performance across tasks, does it enable test-time scaling, and which components matter most? The headline result is that LARC consistently improves generation quality, prompt following, and compositional fidelity across the text-to-image benchmarks. The abstract reports state-of-the-art performance on GenEval, with a seven-point gain over BAGEL, and the main text highlights a strong improvement on OneIG-Bench over Uni-CoT. The important point is not just that the scores go up, but that the gains show up on tasks where fine-grained attribute binding and compositional correctness matter. That supports the authors’ claim that latent reasoning helps with the kind of dense planning image generation needs. Even more notable is the test-time scaling behavior. The authors say LARC is the first reasoning-augmented unified multimodal model in their setting to show clear scaling with more inference compute. Under budget forcing, doubling latent reasoning compute gives monotonic gains across all three text-to-image benchmarks. They also report that LARC outperforms token-based generation under both parallel and sequential test-time scaling strategies. This is a strong sign that moving reasoning into continuous space is not just a training trick; it changes how the model benefits from extra thinking time. The paper also studies components of the method. While the excerpt does not give all the ablation numbers, the design itself suggests the key ingredients are the curriculum that makes latent reasoning trainable, the information-gain reward that makes it useful, and the diversity regularizer that prevents collapse. The broader message is that both stages matter: supervised curriculum learning gets the model into the right representational regime, and RL then sharpens the latent thoughts toward actual image utility. What should we take away from this? First, the paper makes a compelling argument that reasoning for image generation should not be trapped in discrete text if the final task lives in continuous latent space. Second, it shows a practical way to train such a system without needing explicit latent annotations. Third, it provides evidence that this alignment unlocks test-time scaling, which is one of the most attractive properties of modern language models. There are also limitations to keep in mind. The method depends on a fairly elaborate training pipeline, including a large interleaved dataset, curriculum scheduling, and RL with carefully designed rewards. The excerpt also suggests that the image-module reward must be estimated indirectly, rather than read off from a clean likelihood signal, which adds complexity. And while the paper reports improvements on several benchmarks, the broader question remains how well this approach generalizes to other multimodal tasks, other model families, or even more open-ended image reasoning settings. Still, the core idea is elegant: if we want multimodal models to reason like language models and generate like image models, the reasoning itself may need to live in the same continuous space as generation. LARC is an important step in that direction.