Every few months the arXiv feed lines up around a single problem. This week it's efficiency. Nine papers landed in the same cluster covering 3D reasoning in multimodal LLMs, video MoE scaling, expert pruning, one-step 4K refinement, streaming super-resolution, and joint text-image sampling. Different subfields, same underlying claim: generating a convincing image or video is no longer the hard part. Generating one fast enough, small enough, and consistent enough to sit in a real product is where the fight is.

The cluster splits into four threads: making video models scale without wasting compute, making super-resolution real-time, keeping text and pixels in agreement, and moving 3D editing out of the 2D-stitching era. We'll look at each in turn.

Reasoning in 3D: imagine the scene before you answer

Multimodal LLMs read a single image well. Give them several views of the same scene and they struggle to fuse the evidence into coherent 3D understanding. Existing fixes go one of two ways: finer pixel-level cross-view correspondence, or fusing features from 3D geometry foundation models. The gap to human reasoning stays wide.

Imagine3D-LLM starts from how humans actually do this. We don't compute correspondences. We roughly identify the same objects across views, infer the relative geometry between viewpoints, assemble a coarse layout, then reason over it. The model does the same: it appends a small set of learnable summary tokens after the image tokens, decodes them into a compact 3D Gaussian Splatting representation supervised by a photometric reconstruction loss, and trains jointly with the standard next-token prediction objective.

The key result: only the summary tokens receive direct reconstruction supervision, yet this objective also induces stronger cross-frame correspondence inside the LLM's underlying image features. Supervising a coarse 3D sketch propagates 3D-aware signals through the whole model. The paper's phrase for it: imagining the scene beats being told its pixel-wise geometry.

The practical angle is refreshing. You don't bolt on a heavy 3D geometry pipeline. A small set of learnable tokens plus a Gaussian decoder changes how the LLM organizes multi-view evidence, which suggests the 3D awareness comes from the learning signal, not from the size of the 3D machinery.

Video scaling: MoE without the uniformity trap

Mixture-of-experts looked like the obvious way to scale visual models, since it worked in LLMs. But token-wise MoE routes each token independently across a homogeneous expert pool, and standard regularization pushes expert usage toward uniformity. Video data is spatiotemporally redundant and semantically long-tailed. Force those tokens into a uniform distribution and coherent patches scatter across unrelated experts. The paper calls this the uniformity trap, and the symptoms are routing fragmentation and structural distortion.

SplitMoE splits the expert pool into two roles. Semantic experts capture high-level abstraction; generic experts preserve residual visual information and stay flexible during generation. Prototype-guided routing plus a pull-push regularizer lets tokens cluster by semantic attribute instead of arbitrary balancing constraints. Under an equal activated-parameter budget, SplitMoE beats load-balanced MoE on convergence speed, routing coherence, and generation quality, and the authors report an emergent coarse-to-fine denoising logic across the two expert types.

Storage is the second half of the MoE cost problem. Even if only a few experts activate, you still store all of them. DIET prunes video DiT experts without any fine-tuning, using deletion responses. A single all-expert calibration pass caches outputs and router states for matched conditional and unconditional tokens, then candidate deletions are replayed from those cached tensors. No extra model forward passes. Experts are kept or dropped by minimizing an overall diversity loss over their deletion-response signatures, with a layer-level budget search on top.

DIET's numbers translate directly to hardware decisions. On LingBot-Video 30B-A3B, pruning half the experts (6,144 to 3,072) shrinks the checkpoint from 57 GB to 30 GB. That's the difference between a multi-GPU node and a single 48 GB card. VBench Total goes from 0.7941 to 0.8115 after pruning, so removing half the experts doesn't just hold quality, it slightly improves it.

Key numbers 54: downstream models inherited distilled capabilities from LongLive-Plug without per-target retraining. 50%: experts DIET pruned from a 30B video DiT (6,144 to 3,072), cutting the checkpoint from 57 GB to 30 GB. 8.91x: the refinement latency speedup SoL-Refiner gets over the three-step LTX-2.3 Refiner at 2K. 29.29 FPS: RelayVSR's throughput at 1080p on a single A100 80GB, versus 7.80 FPS for FlashVSR-Tiny.

Distill once, deploy everywhere

Every specialized video model goes through its own distillation stage, for faster sampling or longer generation. That stage repeats per model, which is a lot of repeated work. LongLive-Plug treats capability distillation as a one-time investment per backbone family. It learns reusable behaviors as LoRAs on a base model, then deploys them training-free to any compatible downstream model.

The adapters cover three capabilities: single-pass classifier-free guidance, few-step sampling, and long-context error correction for autoregressive generation. The CFG LoRA is trained at a fixed guidance scale, but at inference its weight controls the guidance strength, which is a neat trick. Stack it with a few-step LoRA and you keep both fast sampling and guidance control on downstream tasks. The authors verified training-free deployment across 54 downstream models, three backbone families, and eight task categories, from world modeling to robotics to editing. Distill once per backbone, reuse everywhere.

Quick Take: the biggest quality lifts this week come from fixing how we route, prune, and distill existing architectures, not from inventing new ones.

Real-time super-resolution: the streaming bottleneck

Generating high-resolution video directly is expensive, because cost grows with spatiotemporal tokens. The standard workaround is generate low, refine high, but multi-step refinement re-introduces a sampling bottleneck. Three papers this week attack that bottleneck from different angles.

SoL-Refiner collapses refinement to one denoising step. The recipe is three stages: continual training at high resolution, RL post-training, then one-step distillation. They also ship Refiner-Bench, a benchmark built from outputs of different video generators, with a shared-input protocol so refiners are compared fairly at around 2K. The one-step model beats all external refiners on VBench and UniPercept averages at 2K, and at 3840x2176 it beats the three-step LTX-2.3 Refiner on both metrics. The full acceleration stack gets 8.91x lower refinement latency.

RelayVSR and ReCaVSR go after streaming directly. RelayVSR pairs a large generative model with a lightweight one: the big model writes reference latents for sparse keyframes, and a Dual-Memory Video Transformer uses those references to super-resolve every frame at 29.29 FPS at 1080p on a single A100. ReCaVSR, built on Wan2.2, uses recycled SR latents so each new block conditions on the model's own previous predictions, which cuts the need for full historical KV caches. It runs at 21.20 FPS with 15.16 GB peak memory.

The numbers matter for deployment choices:

Method	Output res	FPS	Peak memory	First-frame latency	vs FlashVSR-Tiny
RelayVSR (dual-endpoint, 15-frame interval)	1080p	29.29	13.82 GB	0.327 s	3.75x FPS, ~44% less memory
ReCaVSR	1080x1920	21.20	15.16 GB	not reported	2.72x faster, 38% less memory
FlashVSR-Tiny	N/A	7.80	24.45 GB	2.83 s	baseline

29 FPS at 1080p on one A100 with 13.82 GB of memory is live-stream territory, and 0.327 s first-frame latency means a viewer lands in the stream almost immediately. The trade-off RelayVSR surfaces is subtle: keyframe errors propagate across output frames, so the paper stops optimizing keyframe quality in isolation. Video-Aware Reference Optimization (VARO) uses RL with two reward levels, one evaluating final videos from the fixed lightweight network, one evaluating decoded keyframe quality, and the dual-level reward beats system-level alone.

Adversarial post-training for pixel diffusion

Pixel diffusion models generate RGB directly, which skips the autoencoder bottleneck, but their outputs systematically underproduce fine-scale natural-image statistics. The fix in this paper is almost absurdly simple: keep the original diffusion or flow-matching objective, add an adversarial loss to the predicted output at non-high-noise timesteps, leave architecture and sampling untouched.

It works, and it works across two pixel backbones. Distribution fidelity, coverage, prompt alignment, and perceptual quality all improve jointly. The frequency analysis explains why: original models underproduce high-frequency content, and adversarial post-training restores the missing spectral power. Perceptual loss also adds high-frequency detail, but it sacrifices distribution fidelity and prompt alignment while doing so. Nearest-neighbor, recall, and matched no-GAN controls rule out memorization, mode dropping, and plain extra optimization.

The boundary case is the important one for anyone on latent diffusion: the same procedure, under the tested latent configurations, produces no joint gains and adds almost no decoded high-frequency power. Direct output access to the image statistics being corrected is the deciding factor. If your model writes pixels, this is a cheap post-training correction, one extra loss term and no sampling change. If it goes through a VAE decoder, expect the spectral signal to die in the decode path.

3D editing without the 2D middleman

Inpainting a masked region of a 3D Gaussian Splatting scene is a core 3D-editing operation, and most methods handle it by calling a 2D diffusion model to paint one or several reference views. Those views then have to be reconciled into a consistent 3D result, which is slow and fragile. WINGS drops the reference views entirely: it operates in the learned embedding space of a large, pretrained 3D prior, with a structure completion network feeding a generative prior that reconstructs geometry and appearance directly in 3D.

Generating content entirely in 3D sidesteps the multi-view inconsistency problem by never creating multiple candidates in the first place, and it's faster than the 2D-based alternatives in the paper's comparisons. It's the first Gaussian splatting inpainting method to work in the representation space of a 3D-native prior without inpainted references. The pattern rhymes with Imagine3D-LLM: both papers conclude that reasoning or editing natively in 3D beats stitching together 2D views.

Keeping text and image honest

CO₂Jump comes from a NeurIPS 2026 collaboration across Google, Google DeepMind, and Stony Brook, and it targets a failure mode I've seen constantly: a model describes the correct solution to a maze while drawing a different path. Generate text and image in parallel and nothing keeps them consistent. The sampler uses coupled Markov jump processes, with text confidence and cross-modal attention guiding image updates during sampling. Low-confidence tokens get masked again and regenerated, so early decisions are revisable as generation proceeds. Cost is one model forward pass per denoising step, no additional training.

Evaluation covers image editing, maze solving, and nonograms, with three new datasets: JEdit-1M, JMaze-200K, and JNono-200K. On the puzzle benchmarks, a sample only counts as correct if both the textual answer and the generated image are right, which is the right bar to set. Across 8 to 512 sampling steps, CO₂Jump was the only sampled method that improved monotonically on both editing quality and grounding.

The Reddit thread around the release collects the failure modes people recognize. The maze example landed for me immediately; I've watched text-to-image systems narrate one solution while painting another, which is easy to file as a quirk until you try to grade it. The authors argue it's structural: parallel generation optimizes each modality separately, and nothing enforces agreement. They asked for other tasks where text-image consistency can be evaluated jointly. I'd put diagram reasoning and structured visual QA on the list, since both let you check the text answer against the pixels independently.

Common Pitfalls

The papers are unusually explicit about what fails, so let's collect the warnings.

Applying adversarial post-training to latent diffusion is the fastest way to waste a week. The tested latent configurations showed no joint gains and almost no added high-frequency power; the autoencoder decode path eats the signal. The correction only works when the model can write pixels directly.

Forcing uniform expert usage on video MoEs is the second trap. Load-balancing regularizers scatter coherent patches across unrelated experts. SplitMoE's split-role pool exists precisely because uniform routing is wrong for long-tailed video data. Route by semantics, not by balance constraints.

Optimizing streaming VSR for keyframe quality alone backfires. Errors in shared keyframes propagate and accumulate across output frames. RelayVSR's VARO shows that a system-level reward over final videos beats a reference-level reward over keyframes.

Pruning experts with static statistics misses the real dynamics. Activation or routing statistics can't capture how other experts re-route when one is deleted. DIET replays deletions from cached tensors and measures responses, which is why its training-free pruning holds up.

Defaulting to multi-step refinement for high-res video is the last one. If your base generator is decent, SoL-Refiner shows one step after RL and distillation removes the second bottleneck entirely.

One Thing to Remember

Every result this week shares a premise: the bottleneck in visual generation has moved. It's no longer whether a model can generate. It's whether it can generate fast enough, compact enough, and consistent enough to ship. Adversarial post-training fixes spectral quality without new sampling. DIET halves a checkpoint without fine-tuning. CO₂Jump keeps text and pixels honest without retraining. Pick any one, and the pattern holds.

The Bottom Line

Three takeaways, concrete enough to act on.

If you're shipping real-time video features, streaming upscaling, live refinement, the relay architecture is the answer. RelayVSR hits 29.29 FPS at 1080p on a single A100 with 13.82 GB peak memory and 0.327 s first-frame latency, and ReCaVSR stays above 21 FPS while using recycled latents instead of full KV caches. Both leave FlashVSR-Tiny's 7.80 FPS in the dust.

If you're training or serving video diffusion models, adopt split-role MoE routing and plan expert pruning into the serving story. SplitMoE avoids the uniformity trap that load-balanced routing creates on long-tailed video data, and DIET showed that cutting LingBot-Video from 57 GB to 30 GB moves it onto a single 48 GB card while nudging VBench Total up from 0.7941 to 0.8115.

If you're building a multimodal system where text and pixels must agree, don't trust parallel decoding to keep them consistent. CO₂Jump's masked-regeneration sampler was the only method in its comparison that improved monotonically on editing quality and grounding across 8 to 512 steps, and it costs one forward pass per denoising step with no extra training.