Show, Don't Tell: Morphing Latent Reasoning into Image Generation

Give a text-to-image model a prompt like this: “A person confidently walks on the surface of the sea, keeping their feet dry, while the water supports them like a transparent solid.” Many models may produce an image that looks locally plausible, but whose overall semantics drift away from the stated constraints: the person may be half-submerged, the water surface may lose realistic texture, or the scene may slide into vague magical effects.

Failures like this show that breaking through the bottlenecks of complex text-to-image generation requires more than stronger prompt rewriting. Models also need the ability to monitor and correct themselves during generation: to judge whether object relationships remain stable, whether local attributes deviate from textual constraints, and whether new control should be applied in subsequent image-token prediction.

LatentMorph starts from this question. Deeply involving ZODA, this work aims to move autoregressive text-to-image models away from the traditional path of explicitly writing reasoning in text, and instead enables an implicit reasoning mechanism in continuous latent space: generating, checking, and correcting along the way. The paper has now been accepted by ICML 2026.

As an international open-source community for AI data and evaluation, ZODA has long focused on key questions in the next phase of AI: on one hand, making evaluations truly reveal the boundaries of model capability; on the other, advancing mechanism-level improvements in alignment, controllability, and reasoning efficiency for generative models. LatentMorph is a step in this direction. The difficulty of complex prompts lies not only in the input text, but also in whether the model can decide during generation when it needs to “think,” what it should think about, and how to write that thinking back into the image.

Under complex constraints involving object relationships, counting, and attribute binding, LatentMorph preserves key constraints more completely than the base model and explicit reasoning baselines.

1. The Bottleneck of Explicit CoT: Visual States Forced into Text

Asking a model to “say out loud” its visual judgments has become a mainstream approach in reasoning-enhanced methods. Chain-of-Thought, or CoT, in large language models offers an apparently natural reference point: the reasoning process and the final output share the same representation space, namely text. The model first writes intermediate steps and then gives the answer, without a fundamental shift in information format.

Text-to-image generation is fundamentally different. Autoregressive models generate discrete image tokens, while their internal states are continuous high-dimensional vectors. Many judgments, such as whether object proportions have drifted, whether spatial relationships remain stable, or whether attribute bindings conflict, do not naturally correspond to a sentence in natural language.

Most existing reasoning-augmented T2I methods still make reasoning explicit: asking a language model to rewrite the prompt before generation, using a vision-language model to inspect the result after generation and retry, or decoding partial images at fixed intermediate steps during generation, writing textual reasoning, and then re-encoding it back into the generator. These methods can work, but their costs are clear: continuous visual states are compressed into discrete text, the generation process is interrupted by a decode-reason-encode loop, and reasoning is triggered by fixed steps rather than by the generation state itself.

Explicit reasoning before, after, and during generation all require text or image decoding as an intermediary step. LatentMorph is designed to bypass this bottleneck.

2. LatentMorph’s Core Mechanism: Reading States, Reasoning Implicitly, and Writing Back into the Generation Stream

LatentMorph’s method can be summarized as a “read-reason-write” loop. Its core idea is not to make the model “speak out” its intermediate representations, but to use an understanding branch to generate a form of “latent thought” in latent space, and then convert this continuous representation into control signals executable by the generation branch.

To do this, we introduce four lightweight modules: Condenser, Reasoning Invoker, Translator, and Shaper.

Condenser is responsible for state reading. The short-term Condenser monitors hidden states from the recent generation history and compresses them into local visual memory. The long-term Condenser summarizes the full generation history when reasoning is triggered, providing global context for the understanding branch.

Reasoning Invoker determines when reasoning should be triggered. It combines signals such as semantic consistency, prediction uncertainty, temporal trends, and stability to decide whether the model should continue generating or trigger reasoning.

Translator converts latent thought into control signals. Rather than relying only on the reasoning vector itself, it also combines long-term visual memory and the original prompt embedding, helping prevent the reasoning process from drifting away from the user’s intent.

Shaper writes the control signal back into the generation stream. It converts the control signal into control tokens and injects them as additional context into the generation branch’s KV cache, the “memory area” where the model stores contextual information during generation. Compared with directly replacing the prompt embedding, this approach allows reasoning signals to influence subsequent generation while preserving the semantic target of the original prompt as much as possible.

During generation, the model reads hidden states, triggers latent reasoning as needed, and injects control tokens into the KV cache to influence subsequent generation.

3. Training Strategy: Establish the Control Path First, Then Learn When to Trigger It

Training is divided into two stages, SFT and RL. The core idea is to decouple “how to intervene” from “when to intervene.”

Stage 1: Supervised Fine-Tuning. This stage trains the long-term Condenser, Translator, and Shaper. The paper uses around 20,000 text-image pairs from the midjourney-prompts dataset and adopts a random injection strategy: a random position is selected during generation, and the model is trained to convert visual history and latent thought into effective control signals. This stage first ensures that the control path itself is usable.

Stage 2: GRPO reinforcement learning. This stage trains the Reasoning Invoker and short-term Condenser. The control modules obtained in the first stage are frozen, and optimization shifts toward the triggering strategy. The reward consists of signals such as CLIP score and HPS-v2.1, with an added trigger-frequency penalty to prevent the model from triggering reasoning at every inspection window simply to improve quality. In other words, LatentMorph learns not only “how reasoning affects generation,” but also “when reasoning is worth doing.”

4. Experimental Results: Improvements in Alignment Quality, Complex Reasoning, and Efficiency

The evaluation covers five types of benchmarks: GenEval for general text-image alignment; T2I-CompBench and T2I-CompBench++ for compositional generation; WISE for world knowledge and abstract prompts; and IPV-Txt for counterintuitive physical scenes and impossible prompt following. This setup shifts the focus of evaluation from “whether the image looks good” to “whether the model truly follows the semantic constraints.”

Main results: LatentMorph outperforms the base model and multiple explicit reasoning baselines across general alignment, compositional generation, and complex semantic tasks. GenEval tests execution accuracy for object number, position, and color attributes. T2I-CompBench covers fine-grained dimensions including color, shape, texture, spatial relationships, and complex composition. LatentMorph leads the base model and multiple reasoning-enhanced baselines on overall metrics, and achieves the best or near-best results on most subcategories. Looking more closely at the subcategories, Spatial improves from 20.61 to 50.93, one of the most notable gains, indicating that the mechanism is especially helpful for spatial-relation constraints.

Effectiveness analysis: By comparing latent reasoning with its explicit variants, the paper verifies the role of continuous latent representations in preserving counterintuitive semantics and fine-grained visual cues. WISE and IPV-Txt both involve world knowledge, abstract semantics, and counterintuitive physical constraints, making them suitable for testing the bottlenecks of explicit textual reasoning. These are precisely the kinds of scenarios where explicit reasoning methods are most likely to lose information. LatentMorph reaches 72.98 on WISE and 49.42 on IPV-Txt, outperforming TwiG-ZS by 15.6 and 11.3 percentage points, respectively. Keeping reasoning in continuous latent space, rather than translating it into text and re-encoding it, preserves more visual-semantic details that are difficult to verbalize.

Efficiency and triggering-strategy analysis: LatentMorph reduces reasoning time and token consumption while showing an on-demand triggering pattern closer to human judgment. LatentMorph runs through a single streaming generation process. Compared with explicit reasoning methods such as MILR and TwiG, it reduces reasoning time by about 44% and token consumption by about 51%. The number of Invoker triggers adapts to task complexity: general tasks such as GenEval trigger less often, while complex tasks such as WISE trigger more often. In a user study with 10 reviewers and 20 complex prompts, its consistency with the majority of human judgments reaches 71.8%.

5. ZODA’s Perspective: Making Complex Generation Capabilities Visible Through Evaluation

In participating in the LatentMorph project, we focused on one concrete question: where and why text-to-image models fail under complex semantic constraints.

LatentMorph uses multi-level benchmarks such as GenEval, T2I-CompBench, WISE, and IPV-Txt, moving evaluation from “whether the generated result is reasonable” to “whether the model truly completes the semantic constraints specified by the prompt.” This choice of evaluation framework aligns closely with the direction ZODA has continued to promote: using more fine-grained and interpretable task design to expose systematic biases beneath fluent outputs, and in turn drive improvements in model mechanisms.

Open-source collaboration is indispensable. Evaluating complex generation capabilities cannot be reduced to a single closed score. It requires open task definitions, reproducible baselines, inspectable failure cases, and evaluation dimensions that can be discussed. LatentMorph proposes a method around implicit reasoning, while also building a complete chain of evidence across alignment, complex semantics, efficiency, and human judgment. It provides a reusable research path for the community to understand the evolution of text-to-image models.

6. Conclusion: Reasoning During Generation as the Next Step for Text-to-Image Models

LatentMorph’s core contribution lies in a shift of generation paradigm: autoregressive text-to-image models should not only understand text before generation, but also continuously read their own states during generation and write reasoning results back into the generation stream when needed.

When a model faces a scene that is “impossible but semantically clear,” the real difficulty is not whether the image is detailed enough, but whether the model can determine where it needs to pause, where it needs to correct itself, and how to translate these implicit judgments into subsequent image-token choices. LatentMorph attempts to move reasoning in autoregressive text-to-image generation from explicit textual expression to latent-space control.

This direction ultimately points to a more fundamental proposition: the next-stage breakthroughs of generative models will depend not only on larger datasets and more compute, but also on continued open-community collaboration around evaluation methods, failure cases, and mechanism design. ZODA will continue advancing this process with the community toward more reliable and controllable generative models. We also look forward to working with more researchers, developers, and industry partners to build more reliable, interpretable, and reproducible AI evaluation infrastructure. Thank you for following along.