Moebius vs ByG: A 0.22B Inpainter and Paired-Data-Free Editing Training

The shared premise

Image and video editing is expensive in two different currencies. Serving is expensive: industrial inpainters like FLUX.1-Fill-Dev carry 11.9B parameters, and at 161.01 ms per sampling step over 50 steps, most products cannot afford to run them at scale. Data is expensive: instruction editors normally train on paired before/after examples, which is costly to build for images and close to impossible for video, where you would need the same clip rendered twice with one controlled change.

Moebius attacks the compute bill. Bootstrap Your Generator (ByG) attacks the data bill. They are not rivals; they answer different questions, and a team could in principle use both. But anyone building an editing feature in 2026 has to price both bills, so the two papers belong in one comparison.

Key numbers

Dimension	Moebius	ByG	Same harness?
What it trains	A mask-based inpainting diffusion model	Instruction-based image and video editing models	Different tasks, never compared head-to-head
Size / base	0.22B parameters, own latent U-Net	Frozen bases: FLUX.1-dev (image), Wan2.2 (video)	No
Training signal	Latent-space distillation from a 0.86B PixelHacker teacher, four stacked losses	Cues from the frozen base model itself, zero paired examples, no reward model	No
Headline quality number	FID 5.39 vs FLUX.1-Fill-Dev 10.13 on CelebA-HQ 512 portraits	75.3% (±2.2) human win rate vs Ditto on video editing	Different metrics, not comparable
Where it loses	Places2 Test natural split: 9.48 vs FLUX 8.02	General GEdit-Bench: competitive, not dominant	n/a
Cost claim	26.01 ms/step × 20 steps ≈ 15x less total inference time than FLUX	~2.9s vs 0.97s per training step, about 3x slower than supervised	Different cost axes
Data requirement	Standard paired inpainting training data	~330 unlabeled image tuples; 328 generated clips for video	n/a
Generalization check	Zero-shot LVIS / DeepFakeFace FID 17.81 / 15.32, near FLUX (14.52 / 12.24)	85.0% win vs Ditto’s 15.0% on unseen 3D-CGI video conversions	n/a

Read the table as two self-contained claims, not one ranking. Every row pairs a number from the Moebius paper with a number from the ByG paper, and no experiment puts both methods on one harness; they do different tasks, use different metrics, and report against different baselines.

How Moebius works: shrink the backbone, then refill it with a teacher

Moebius’s problem is the representation bottleneck. Cut a diffusion backbone from 11.9B parameters to 0.22B and it loses the capacity to represent context; quality falls off a cliff. The paper’s Table 2 quantifies the cliff: the same compact backbone scores FID 33.21 trained plain, versus 24.73 with the distillation recipe. The small architecture is necessary but nowhere near sufficient.

The backbone is rebuilt around one repeating unit, the Local-lambda Mix Interaction block. Local-lambda compresses nearby spatial context into a fixed-size linear matrix, so context mixing costs a flat amount instead of attention’s quadratic growth; Interactive-lambda does the same for the global semantic prior; Mix-FFN handles the feed-forward stage. That swap is what shrinks the model: a standard global-attention backbone at 526M parameters matches the 485M lambda design with essentially even FID (33.21 vs 32.75 without distillation), and the shipped design lands at 226M parameters and 154 GFLOPs, giving up about 1.7 FID for a 53% parameter cut from the 485M variant.

The lift that makes 0.22B competitive is distillation, not the block. The teacher is PixelHacker at 0.86B, and the student is trained to match its internal representations entirely in latent space, skipping the expensive pixel decode. The four-loss ablation shows every term earning its place: coarse KD alone sits at a useless FID 74.20, adding fine-grained KD drops it to 36.17, the task loss takes it to 32.59, and the perceptual term lands the final 26.43. The block makes the model small; the teacher signal fills the hole that compression opens.

How ByG works: the base model supervises itself

ByG asks a different question: what if the frozen base generator already knows what an edit should look like, and you only need to extract that knowledge? Instead of paired data, it pulls instruction-following cues from the frozen base model, and instead of a reward model, it enforces cycle consistency (edit forward, invert, recover the original) to protect structure. The supervision is the base model disagreeing with itself until the edit both follows the instruction and preserves identity.

The engineering piece that makes this trainable is gradient routing over clean predictions. Flow-matching models train on noisy states, but the losses ByG cares about (does the edit follow the instruction, is structure preserved) only make sense on a sharp image. Scoring a one-step clean guess gives a blurry estimate and bad gradients; denoising fully breaks backpropagation because the multi-step sampler is not usefully differentiable. ByG splits the two: the forward pass conditions the losses on a multi-step clean estimate, while the backward pass routes the gradient through the one-step prediction. It is straight-through estimation adapted to flow matching, and it closes the train-versus-inference gap that on-policy distillation methods like Flow-OPD attack from a different angle.

The ablation is blunt about which piece carries the result, on a 0–10 scale for edit success and source preservation. Remove the directional regularization loss and the model collapses into a copy machine: edit success 0.633, source preservation 9.767. Remove bootstrapping and edit success falls to 5.517. Gradient routing and the cycle loss matter less individually (8.917 and 8.983, versus 8.317 for the full model, both slightly above the full model’s edit success, meaning they trade success for preservation rather than carry it). The regularizer and the self-improvement loop are what keep training from degenerating; a builder copying only the clever gradient routing would likely watch the model collapse. The formulation builds on the flow-matching setup popularized by Stable Diffusion 3.

What you are actually buying in each case

Moebius buys serving economics, with a quality caveat per split. Against FLUX.1-Fill-Dev it scores FID 5.39 versus 10.13 on CelebA-HQ 512 portraits and 8.15 versus 11.19 on FFHQ 256, while on the harder natural-scene Places2 Test split the ordering flips: FLUX 8.02, Moebius 9.48. The user study points the same direction: raters preferred Moebius over the 10B generalists especially on faces, while it merely matched its own teacher. The honest claim is “rivals or surpasses depending on the split, at under 2% of the parameters,” not “beats FLUX everywhere.” The ~15x total-time advantage mixes two legitimate factors (26.01 vs 161.01 ms per step, and 20 sampling steps vs FLUX’s default 50), so a like-for-like step count would shrink the multiplier, though the per-step win alone is over 6x. This is the same compression lever as classic work like DistilBERT, applied to a diffusion backbone instead of a transformer encoder.

ByG buys data independence, paid for in training compute and fragility. The headline is that base-model semantics can stand in for both paired data and an external reward model: the image model trains in 30,000 steps on 8 H100s from roughly 330 unlabeled tuples, the video model in 750 steps from 328 generated clips. The trade is real: training runs about 3x slower per step than supervised editing (~2.9s vs 0.97s), and the optimization is delicate, hinged on a regularization loss whose removal collapses edit success to near zero. The ceiling is the base model: ByG extracts cues, it does not teach the frozen generator anything new, so edits requiring knowledge the base lacks are out of reach.

Limits and open questions

Moebius is a specialist. It is trained for mask-based inpainting on natural and portrait scenes, not text-prompted editing, so the FLUX comparison holds only on the inpainting task both can do. Its ceiling is its teacher: it can lose fine detail in extremely tiny background regions where context is thin, exactly where a 0.22B capacity budget bites, and the Places2 Test split confirms the gap on hard general scenes has not fully closed. The 15x figure mixes step-latency and step-count wins. And there is no public training-cost figure for the distillation stage, with results confined to two domains at fixed resolutions.

ByG’s “beats supervised models trained on millions of samples” claim deserves the careful reading its own page gives it. The user study is small: 8 raters, 238 votes, moderate agreement (Fleiss κ = 0.44), and for video the authors sampled 4 outputs per method and manually picked the best before showing raters, a protocol that favors high-variance methods. The firmer evidence is structural: DINO structure similarity 0.718 vs Ditto’s 0.536, CLIP directional 0.104 vs 0.091, motion fidelity 0.715 vs 0.616, and the 85.0% to 15.0% margin on out-of-distribution 3D-CGI conversions. The video test set is 119 author-assembled tasks, there is no FID-scale automatic eval against the supervised baselines’ home turf, and the collapse-prone regularizer suggests a narrow hyperparameter window. For the broader controllable-video-editing neighborhood, see LoomVideo and the instruction benchmark in CoVE-Bench.

When to use which

The choice is a resource question. If your product does mask-based inpainting (removing objects, filling holes in portraits or natural scenes) and the serving bill is the problem, Moebius is the direct answer: near-FLUX quality on its home splits at under 2% of the parameters and roughly 15x less inference time, with the caveat that hard natural scenes still favor the 10B generalist. If your problem is that paired edit data does not exist for your domain, especially video, where controlled before/after pairs are nearly impossible to build, ByG is the direct answer: zero paired examples, no reward model, gains concentrated in long-tail styles and motion edits, at 3x per-step training cost and a fragile optimization you must babysit. If both bills hurt, nothing in either paper prevents combining them; the lambda-block backbone is a serving optimization and the bootstrap training loop is a data optimization, and they touch different parts of the stack. But that combination is an inference, not a published result.

FAQ

Is Moebius better than FLUX.1-Fill-Dev?

Not across the board. Moebius wins decisively on portraits (CelebA-HQ 512 FID 5.39 vs 10.13, FFHQ 256 8.15 vs 11.19) and on small-hole and large-hole natural splits, while FLUX.1-Fill-Dev keeps the lead on the harder Places2 Test split (8.02 vs 9.48) and the 256 split. The accurate summary is “rivals or surpasses depending on the split, at under 2% of the parameters and roughly 15x less inference time.”

Does ByG use any paired training data or a reward model?

No. ByG trains with zero paired before/after edits and no external reward model. Its only supervision comes from the frozen base generator: instruction-following cues extracted from that model, plus a cycle-consistency loss for structure. The image model learns from ~330 unlabeled tuples and the video model from 328 generated clips, with FLUX.1-dev and Wan2.2 as the frozen bases.

Which component matters most in each method?

In Moebius, the distillation matters most: the same compact backbone scores FID 33.21 without it and 24.73 with it, and the four-loss latent-space stack (coarse KD, fine-grained KD, task loss, perceptual) is what fills the representation bottleneck the small architecture creates. In ByG, the directional regularization loss matters most: removing it drops edit success to 0.633 out of 10 while source preservation climbs to 9.767, meaning the model learns to copy the input and ignore the instruction.

Can Moebius and ByG be combined?

Nothing in either paper rules it out. Moebius replaces the attention-heavy backbone with lambda blocks to cut serving cost; ByG replaces paired data with self-extracted cues from a frozen base. One optimizes inference, the other optimizes training data, so a lambda-backbone editor trained with bootstrap supervision is a plausible design. But no published result trains that combination, so treat it as a hypothesis worth prototyping, not a recommendation with evidence behind it.