Images, video, sound, and motion as four faces of the same thing

Understanding why FLUX 3 looks the way it does means starting with its premise, which has nothing to do with technical detail. It's a claim about the world: no single modality describes reality completely.

An image captures spatial structure at one instant — what is where, next to what. Video hands time back, so you can see how things move, how heavy they are, what happens when something hits them. Sound reveals the causal link between a mechanical event and the noise it makes, a relationship invisible in pixels. Language connects all of that perception to goals, abstractions, and instructions.

Each is one projection of the same reality, captured by a different sensor, and each capture loses something. Learn only one and you get a good model of that projection. Learn all four and their mutual constraints tell you more: the sound has to match the impact, the motion has to obey mass, each moment has to follow from the last. Pile on enough constraints and the model can no longer get by on surface appearance. It has to infer whatever underlying thing satisfies all of them at once.

You cannot fool reality. A model trained only on images can only ever generate images. But the world isn't made of still frames — it moves, it makes noise, it changes, it responds.

Robin Rombach, co-founder and CEO of Black Forest Labs, in a written statement to VentureBeat ahead of the launch

One backbone model branching out into images, video, audio, and action prediction.Source: Black Forest Labs

Video eats 95% of training compute, and sound comes along for the ride

Any company can say what's written above. Where it gets specific is the compute bill.

FLUX 3 was jointly trained on images, video, and audio from the start, and the most resource-hungry piece by far is video prediction, at more than 95% of total training compute. The reason is simple enough: to generate video that looks right, the model has no choice but to learn contact, motion, weight, and causality. Get any one of them wrong and a human spots the fake instantly. Learning to render the world accurately amounts to learning how the world works.

Sound turns out to be the cheapest piece of the set. It's low-dimensional and carries far less detail than video — in a 720p clip with audio, sound accounts for under 0.5% of tokens. Once the model has cleared the video bar, it picks up the causal link between video and audio on its own: speech matched to lip movement, sound effects matched to the physical event that produced them.

Action has the same shape. Robot state is a low-dimensional representation tightly bound to visual observation. Pixels, sound, and motion are all partial representations of one physical reality. Once the model has learned the physics behind video and audio, predicting action isn't starting over — it's one more view of the same thing.

They ran a training experiment to test the claim

If the framework holds, teaching FLUX 3 to predict action shouldn't carry a lasting cost. The model should go through a brief disrupted stretch while it works out the structure of action space and aligns its internal world representation to it, then return to where it was.

So they added action prediction to the curriculum during a large-scale training run and watched video generation quality. Human preference scores for text-to-video and image-to-video dropped by up to 10% at first. After 3,500 steps, video quality was back to its pre-action level — and by then the model could also predict action.

Human preference for video generation dips, then climbs back, after action prediction enters training. Each curve is normalized to its own pre-action quality; higher is better.Source: the FLUX 3 × mimic companion write-up, not the main launch post

The model does have to wire action into its inputs and outputs, but doing so doesn't permanently consume capacity. It just needs to work out how the new modality relates to the world model it already has. Once it does, the loss in existing capability disappears.

Self-Flow: the model teaches itself instead of borrowing an understanding model

The training method under FLUX 3 is called Self-Flow, published by Black Forest Labs in March 2026 with MIT's Antonio Torralba among the authors. To see what it changes, you need to know where things were stuck.

The old fix: bolt on a model that already gets it

Generative models for images and video — diffusion models, flow models, that family — show a well-replicated pattern: the stronger the model's internal semantic representation, the faster it converges and the better it generates. The catch is that this representation doesn't emerge on its own. The training objective is denoising, walking a blob of noise step by step toward a clean picture, and each step only has to predict which way to move. Denoising barely requires knowing what's in the picture, so the model has no incentive to learn semantics.

The standard fix is to borrow from outside: bolt on a pretrained understanding model as a reference — DINOv2 most often — and push the generative model's internal representation to match it. The approach is called REPA. It works, but it drags along three problems: the external model has to be trained separately, its objective doesn't line up with the generative one, and it underdelivers at scale.

Self-Flow: manufacture an information gap inside the model

Self-Flow's central move is dual-timestep scheduling. Take a piece of clean data, sample two timesteps and a random mask, then noise each token according to the timestep it drew. Now parts of the same data are badly blurred while other parts stay relatively clear.

Here's the key step. One path — the teacher — is noised with the smaller of the two timesteps, so it sees more clearly. The other path — the student — sees a version mixing different noise levels. The student is asked to do two things at once: denoise what it's holding, and reconstruct the teacher's features from that degraded view.

The information asymmetry is what drives it. To fill in what it's missing, the student can't stare at its own little patch. It has to look at what's left elsewhere and understand the structure in the picture and the sound. Patching the holes is itself how semantic representation grows. Generation and understanding come out of one training run, with no external model and no extra supervision.

The official method diagram: sample two timesteps and a random mask for clean input, noise each accordingly, and give the teacher path the smaller noise level to open an information gap with the student.Source: the Self-Flow research page, not the main launch post

Why this matters for multimodal work

Two sets of results from the research explain why the bolt-on route can't carry a model meant to handle three modalities at once.

The first is cross-modal failure. On video, the strongest external encoder is still DINOv2, an image model — beating video-specific encoders like V-JEPA 2 and spatial learners like Depth Anything 3. On audio, aligning to MERT gave no benefit at all over aligning to nothing. External alignment never escaped image-centric tasks.

The second is scale. Going from 290 million to 420 million to 625 million to 1 billion parameters, the gap between Self-Flow and REPA widens: Self-Flow absorbs the added compute while REPA hits diminishing returns. That single result decides whether the method can serve as the foundation for a model the size of FLUX 3.

Left: generation error by modality, normalized so plain flow matching is 100 — lower is better. Right: success rate on manipulation tasks — higher is better.Source: Black Forest Labs

FVD, FID, and FAD are the standard error metrics for how far generated output sits from real data — for video, images, and audio respectively — and they read the same way: under a fixed setup, lower usually means closer to the real distribution. The right-hand column measures something else entirely: whether that internal representation is usable by a downstream action module. A higher success rate says it's good for more than looking right — it's good for doing things.

Video is the only line you can use today

Two hard facts about it: single generations run up to 20 seconds, and every output ships with native audio.

"Native" is worth unpacking. Most video models produce silent footage first and generate sound in a second pass to be matched up afterward. In a FLUX 3 output, picture and sound come from the same generation. Twenty seconds puts it in today's longest tier, matching the now-retired Sora from OpenAI.

The company lists nine capabilities. Grouping them by what you feed in makes them easier to read:

The last capability targets the real problem

The ninth is agentic chaining: stitching short clips into longer multi-shot sequences. Combined, these capabilities can produce sequences several minutes long, using visual references to keep a character recognizable across every scene.

What has kept generated video out of commercial pipelines was never whether a single clip looks good. The blocker is continuity across shots: the person in shot one has to still be that person in shot two. This is also where competition is most direct right now. HappyHorse 1.1's headline upgrade is R2V — reference-to-video — which accepts multiple character reference images to lock identity, solving the same problem from the input side. Both companies know where the fight is.

The image line doesn't count yet

On images, BFL says the model both synthesizes from scratch and edits existing pictures, covers a wider range of styles, aspect ratios, and resolutions, and handles complex prompts and multilingual text rendering markedly better than previous FLUX versions.

But those are preliminary evaluations from mid-training, with no absolute numbers attached and no image benchmarks or win rates published. Early access is still a few weeks out.

Official sample images, meant to show off style range and text rendering.Source: Black Forest Labs

In the preference numbers, the two ties matter more than the wins

BFL ran a round of head-to-head human preference tests: 10-second, 720p text-to-video with audio, with people picking which clip they preferred. The chart is labeled a preliminary evaluation of an early FLUX 3 candidate, meaning the numbers describe a pre-release checkpoint, not the model now entering early access. 50% means neither side wins.

Reordered by how much each result actually tells you, these eight fall into three tiers:

One name the main post never explains: Happy Horse is a video model launched in April 2026, running up to 15 seconds at 1080p with native synchronized audio, and it took first place in both text-to-video and image-to-video on the third-party Artificial Analysis video arena that month. Knowing that is what gives those 59% and 57% bars their weight.

The original preference chart: head-to-head comparisons on 10-second 720p text-to-video with audio, labeled a preliminary evaluation of an early candidate.Source: Black Forest Labs

Against the price list, the empty column stands out

Also missing: how many raters took part, whether the test was blind, which prompts were used. The entire methodology section is blank. Full benchmark results and methodology are promised for the wider release.

The robotics side gives the claim its hardest evidence

Turning "content generation and robotics share one foundation" into something testable is what FLUX-mimic does. It's a video-action model built by BFL with the Swiss company mimic robotics, running on the FLUX 3 backbone, already tested and deployed at Audi.

The approach isn't training a separate robotics model. Their argument: for FLUX 3 to generate video at all, it must already have learned a representation of the world internally. So take the intermediate features from the FLUX video prediction path and train a lightweight action decoder on top, reading action out of that existing representation.

The most telling result: with the FLUX backbone frozen entirely, training only that action decoder on top already beats previous vision-language-action models (VLAs) — models that can't do this at all under a frozen setup. Fine-tuning backbone and decoder together, FLUX-mimic reaches state-of-the-art success rates. Two things hold at once: scale training packed enough world knowledge into the backbone, and Self-Flow made that knowledge readable straight out of the features.

Data efficiency gets one more result from the method itself: in the Self-Flow experiments, reaching the same action-prediction success rate took half the training steps of a video model trained without it.

What Audi is testing is work conventional automation can't touch

Audi's production network is among the most automated in the auto industry, which means it has firsthand accounting of exactly where conventional automation stops. Flexible parts and fine manipulation have stayed with human hands mostly for economic reasons: premium models come in too many variants, and a conventionally programmed robot station has to be re-engineered for every new case, which never pencils out.

The jobs FLUX-mimic has run on real production and logistics lines include placing parts into structured trays, inserting electronic control units into tight-fit fixtures, assembling components, and handling soft deformable materials like seals and cable harnesses. That last category is the one conventional automation never managed.

Audi has been testing and deploying FLUX-mimic during our collaboration with mimic. We've seen these robots complete complex soft-material manipulation work that simply isn't possible with traditional robotics approaches. This can have a major impact on assisting employees, improving efficiency, and extending flexible automation into production and logistics.

Christoph Schneider, Audi Production Lab

Nobody taught it how to recover

One behavior deserves its own note: FLUX-mimic recovers from failure on its own. When the robot grabs at empty air, it corrects, grabs again, and finishes the task.

No demonstration dataset can cover every way a task might go wrong. Since nobody demonstrated it, the recovery has to come from somewhere else — a model that already knows how the world works.

The hardest part of robotics is data. Every new task usually means hours of having the robot repeat itself. Because FLUX-mimic is built on a frontier video model that already understands how the physical world works, it learns a new task in minutes rather than days. That lets us leapfrog the current state of the art in robot learning.

Elvis Nava, CTO of mimic Robotics

What's confirmed, and what hasn't been published at all

Open weights coming last is unusual for FLUX

FLUX's standing in the industry over the past two years was bought largely with open weights. FLUX.1 Dev and FLUX.1 Kontext Dev shipped right alongside their launches, letting researchers and creative-tool developers download checkpoints, run inference locally, and plug into Hugging Face Diffusers and ComfyUI. FLUX.2 Dev, from late 2025, is a 32-billion-parameter open-weights image model.

This time, FLUX 3 Dev is described as a multimodal backbone spanning video, audio, images, and action prediction — a broader promise than any previous Dev release — and it sits last among the four lines. Developers used to getting a locally runnable version at or shortly after a major launch will be waiting a while. A license will decide whether a company can deploy, on its own hardware, a model that touches both content production and physical machinery — and the license, parameter count, quantization, and hardware requirements are all still unknown.

Two companies are now telling the "world model" story

BFL's argument: a model trained only on images cannot understand a world that moves, makes noise, changes, and responds — and understanding physics is precisely what makes generated footage believable.

Google says nearly the same thing about Gemini Omni. Its developer documentation talks about "world knowledge," putting physical understanding alongside Gemini's grasp of historical, scientific, and cultural context. A June statement went further, saying the model has an "intuitive understanding of forces like gravity, momentum, and fluid dynamics, so its motion follows real-world logic."

Two of the three leading video systems now pitch physical understanding as a core advantage, and neither company has published a benchmark that measures it. No standard test today can judge whether generated water looks like water, whether a falling object drops at a plausible rate, or whether an impact sound lands when it should. Human preference scores capture a slice of it indirectly. Beyond that, there's nothing.

The launch rests on a claim about the world: no single kind of record describes reality completely. An image captures space at one instant. Video hands time back — how things move, how heavy they are. Sound reveals the causal link between an impact and the noise it makes. Action is what happens if you reach in. Learn all four together and they constrain each other: sound has to match the impact, motion has to obey mass, each moment has to follow from the last. Surface appearance no longer gets the model through.

Where the claim gets specific is the compute bill. Generating video that looks right means learning contact, motion, weight, and causality — get one wrong and a human spots it instantly — so nearly all the compute goes into clearing the video bar. Clear it, and sound comes along for the ride. All figures below were published by Black Forest Labs itself, including its companion technical write-up with mimic. None have been independently reproduced.

Generative models show a well-replicated pattern: the better a model understands its content internally, the better it generates. But its training objective is only denoising — walking a blob of noise step by step toward a clean picture — which barely requires knowing what's in the picture, so understanding doesn't emerge on its own. The old fix was to borrow it. FLUX 3 does something else.

Why this is a prerequisite for multimodal work: the bolt-on route never leaves images. On video the strongest external reference is still DINOv2, an image model, beating video-specific V-JEPA 2. On audio, attaching MERT gives no benefit over attaching nothing. Scale points the same way: from 290 million to 1 billion parameters, Self-Flow absorbs the added compute while REPA starts hitting diminishing returns.

FLUX-mimic is a video-action model built by Black Forest Labs with the Swiss company mimic robotics, running on the FLUX 3 backbone and already tested and deployed at Audi. It doesn't start over: freeze the backbone entirely, train a lightweight action decoder on the intermediate features it produces, and the result already beats previous vision-language-action models — the kind that take pixels and instructions together and output motion directly — which can't do this at all under a frozen setup. What that saves is data.

One behavior nobody taught it: when it grabs at empty air, it corrects itself, grabs again, and finishes the task. No demonstration dataset can cover every way a task goes wrong, so that recovery has to come from a model that already knows how the world works.

Black Forest Labs ran its own round of head-to-head human preference tests: 10-second, 720p text-to-video with audio, with people picking the clip they preferred; 50% means neither wins. The biggest wins, Luma Ray 3.2 (93%) and Runway Gen-4.5 (77%), came against the two softest names on the list. The informative results are the two ties.

Gemini Omni Flash is the big-platform model closest to what FLUX 3 is trying to be, and it's the other one telling the "our model understands physics" story. By Black Forest Labs' own measurement the two are indistinguishable, and the difference lies elsewhere: one can be called today at a published price, the other is waiting on approval.