A 1.6B Model Stopped Translating Images Into Tokens, and Beat the Architectures That Do

A team at Huazhong University of Science and Technology, working with Horizon Robotics, published a paper this month on a multimodal architecture that takes neither of the two roads everyone else has been walking. The model is called MF-1. It has 1.6 billion parameters, was trained from scratch on 150 billion tokens, and outperforms both established approaches in a controlled comparison with identical data and compute budgets.
The result matters less for the benchmark numbers than for what it says about how much of multimodal training is currently being wasted on architecture.
The two roads, and what each one costs
For a few years there have been two ways to put language and images in the same model.
The fully discrete road, taken by Chameleon and Emu3, quantizes images into discrete tokens so that everything becomes one long sequence of integers and one autoregressive objective. It is elegant and it has a hard ceiling: the visual tokenizer throws away high-frequency detail during quantization. Fine texture, small text and subtle gradients get flattened before the model ever sees them. You can make the tokenizer better, and people have, but the ceiling is structural.
The hybrid road, taken by Transfusion and JanusFlow, keeps text discrete and images continuous. Text goes through next-token prediction. Images go through a diffusion process. This avoids the quantization bottleneck entirely, and it creates a different problem: the model now maintains two objective functions and two sampling pipelines, and getting them to optimize jointly is an engineering project rather than a research question. Every ablation becomes twice as expensive.
Both roads involve translating one modality into the other's format. That is the compromise Multimodal Flow refuses.
One objective, two native formats
The design keeps language in its continuous embedding space and images in theirs, and shares a single Flow Matching objective across both.

Concretely: text is split into chunks of eight tokens, each chunk encoded by a frozen T5-small into a continuous text hyperchunk. Images go through a frozen SigLIP2 encoder and come out as a 16 by 16 spatial grid, forming a visual hyperchunk. Hyperchunks are strung into one sequence in whatever order the task demands, and fed into a shared Chunk-Causal Flow backbone.
The attention mask is the clever part. When predicting the k-th hyperchunk, all earlier hyperchunks are fully visible, positions inside the current chunk are modeled jointly, and later chunks are masked. Causality holds at chunk granularity, and information flows freely within a chunk. That is what lets a 256-cell visual hyperchunk be generated as a coherent image instead of 256 independent decisions.
The second design choice is a hybrid inside the transformer. Attention layers are shared, so language and vision can attend to each other. FFN layers stay modality-specific, because the representation statistics of the two are different enough that forcing them through one feedforward block hurts. The paper's ablations reportedly confirm this, which is the kind of detail that saves everyone else three months.
Text chunks are eight tokens long, which is a deliberate compromise. Smaller chunks give finer control and more sequence positions. Larger chunks make the causal mask cheaper. Eight is where the tradeoff landed.
The numbers
Text to image: GenEval overall 0.821, DPG-Bench long-prompt alignment 83.44. On GenEval's counting sub-task, MF-1 hits 0.73, which is well ahead of unified models at the same scale. Counting has been an embarrassment for unified architectures because it requires binding a number to multiple instances, and jointly modeling a visual chunk turns out to help.
Understanding: VQAv2 72.6, MMBench 67.2, POPE 86.1, averaging 75.3. That average beats some same-size models initialized from a pretrained language model, which is the surprising one. Starting from a pretrained LLM is usually free performance.
The controlled comparison is the part that makes the paper worth reading. Same data, same parameter budget, same optimizer, and Multimodal Flow beats both the Transfusion-style hybrid and the Chameleon-style discrete architecture on GenEval, GQA, VQAv2 and MMBench. Not by a point on one benchmark. Across the set.
Why counting is the test that matters
Of all the GenEval sub-tasks, counting is the one that most cleanly separates architectures.
Asking a model for three red apples requires two things at once. It has to represent the number three, and it has to bind that number to three distinct instances of an object, each of which needs to be red and apple-shaped. Discrete-token models tend to produce two or four. Diffusion models tend to produce a plausible cluster and hope nobody counts. Hybrid systems get closer because the image side is continuous, but the text side still has to hand over a cardinality that survives the handoff.
MF-1 scoring 0.73 on that sub-task is a bigger deal than the 0.821 overall figure, because the overall number is partly carried by easy prompts about colors and simple objects.
Why 150 billion tokens is the real claim
Frontier multimodal models are trained on token counts in the trillions. MF-1 used 150 billion, on 1.6 billion parameters, and reached GenEval 0.821.
If that scales, it changes an assumption. The current consensus is that unified multimodal models are expensive because they need enormous data to learn both modalities well. This paper suggests a large part of that expense was the architecture paying for the compromise: quantizing images costs quality, so you buy it back with more data; maintaining two objectives costs optimization efficiency, so you buy that back with more compute.
Remove the compromise and the same budget goes further. Whether that holds at 10 billion or 100 billion parameters is unanswered, and the paper does not claim it does. The team is explicit that this is one scale with one data mixture.
There is a second-order implication that connects to other work this year. A separate line of research has been trying to remove the VAE from image generation entirely, on the grounds that compressing an image into a latent and back out again loses information nobody asked to lose. Multimodal Flow keeps the encoder and stops treating its output as something that must be re-expressed as language-like tokens. The visual hyperchunk stays visual all the way through. That is the same instinct.
What this does not solve
Three limits worth stating.
The encoders are frozen. T5-small and SigLIP2 were not trained jointly with the flow backbone, which means the representation quality ceiling is set elsewhere. A jointly trained encoder would probably do better, and would cost much more.
The image resolution is 16 by 16 in latent grid terms, which is fine for GenEval and inadequate for anything involving text rendering or fine detail. Generation quality at high resolution is not what this paper is about.
And this is a research artifact. The code is on GitHub at hustvl/Multimodal-Flow, the weights are a starting point rather than a product, and there is no hosted API. Nobody is going to replace their image pipeline with it next week.
What it does is narrow the space of plausible futures. If a 1.6B fully continuous model can beat both established unified architectures on the same budget, then the next round of multimodal foundation models has a third design option that did not exist in the conversation six months ago. For a field that has spent a lot of compute arguing about tokenizers, that is a useful thing to have on the table.
Related articles
The Jensen Discount: What Nvidia Loses When Its Founder Walks Out
Nvidia lost roughly $600 billion in market value when its founder stepped down. The earnings did not change. The multiple did, and that says where the value really lived.
Chinese text in video always turns to mush. Dreamina handed the typesetting to code
Dreamina launched Motion Studio on November 10. It no longer generates frames; the model writes code that lays out text, shapes and pacing. Chinese titles stop blurring, but whether the content is right is still on you.
A community spreadsheet of taps that turns off the ads inside Chinese Android builds
A no-root tool that switches off the ads Chinese phone makers ship inside the system UI. Its method is a hand-written tap script per phone model, maintained by volunteers every time a ROM moves. It works, and the maintenance is the point.
GPT Image 2.6 held the token price and raised the bill
GPT Image 2.6 kept every token rate from 2.5 and still costs more per image, because more of the work now happens in output tokens. Eleven days into the ramp, the pricing structure says more than the leaderboard does.