AI papers — 2026-08-28

Problem: Existing video-generation/world-model benchmarks judge single generated videos for plausibility but never test whether repeated rollouts from the same initial observation and action recover the correct distribution over physically valid futures (probabilistic alignment).

Method: The authors formalize probabilistic alignment (support alignment vs. stronger probability-mass alignment) and introduce PAWBench, a 50-scenario benchmark spanning eight physical-mechanism groups, split into PAW-Calibration (25 scenarios with analytically/symmetry-derived reference distributions, e.g., coin toss, spinner) and PAW-Coverage (25 scenarios with enumerable but unspecified-probability outcomes, e.g., bowling, block-tower stability). PAWEval, a rubric-based protocol using Gemini 3.5 Flash as judge, maps K=50 repeated rollouts per scenario to terminal outcome labels and aggregates them into an empirical distribution, scored by total variation distance (TVD) against the reference (Calibration) or by valid-support recovery percentage (Coverage). They further probe three ways to reshape a model's output distribution: language/prompt engineering (VLM-predicted outcomes, GPT-5.5 prompt engineering, Oracle PE), initial-noise sampling via Couple-to-Control (C2C) repulsive Gaussian coupling, and LoRA fine-tuning on Wan2.2 with varied outcome-mixture training data.

Key results:

• Across 11 video generators (HappyHorse, Veo3.1 Fast, Kling 3 Std., Seedance 2, Wan2.7, Wan2.2, LTX-2.3, LTX-2.5, Cosmos 3 Super I2V, LingBot-Video-MoE, MiniMax H3), none achieves both low Calibration TVD and high Coverage with high Scene Pass Rate (SPR) simultaneously.
• Cosmos 3 Super I2V has the best Calibration TVD (20.5 avg, ×100 scale) but only 80% SPR; LTX-2.3 has the best Coverage (82.7% avg) but only 72% SPR.
• Monte Carlo control: observed average TVD across models is 31.2, while 99% of matched-sample simulations from the true reference distributions stay below 9.22 — confirming the gap is not a finite-sampling artifact.
• PAWEval agrees with human judgment on 722/888 (81.3%) of videos with clear terminal outcomes.
• Oracle PE (explicit target outcomes given to generators) still only achieves 37.6–58.1% target-hit rate across four generators.
• C2C coupled noise sampling lowers mean Calibration TVD and raises mean Coverage for all three tested generators (e.g., Wan2.2 Calibration TVD 26.3→25.7, LTX-2.3 Coverage 82.7%→92.8%), without much change to SPR.
• LoRA fine-tuning on pencil-fall training mixtures (0–100% left-fall share) shifts generated outcome frequencies nonlinearly and non-independently across scenes; no single trained model achieves both the 50/50 (upright) and 100/0 (left-leaning) reference distributions simultaneously.

Why it matters / caveats: Demonstrates that "looking plausible" and even "controllable" video generation does not imply a probabilistically correct world model, which matters for using video generators for planning/decision-making. Caveats acknowledged by the authors: evaluation is limited to terminal outcomes (not full trajectory dynamics), relies on finite rollout budgets, and uses controlled/visually parseable scenarios rather than long-horizon interactive settings.

Problem: Research on generating interaction data for LLM agents is fragmented by domain (tool use, coding, GUI, embodied, etc.) and conflates how candidate data is constructed with how it is verified/selected, making it hard to compare generation mechanisms or judge what makes agentic data actually useful.

Method: The paper is a survey/framework paper. It defines agentic data as a common factorized object d = (E, q, τ, v) — Environment specification, task-conditioned Query/objective, interaction Trajectory realization, and an optional Verifier/reward — and formulates generation paradigms by which factor anchors the pipeline (forward generation: E→q→τ; reverse generation: task-first, trajectory-first, or structure-first). It then proposes the Accuracy–Complexity–divErsity (ACE) lens as a constrained-distribution-design objective: Accuracy defines the feasible support (grounded, internally consistent data), Complexity places learning mass relative to a declared learner's capability within that support, and Diversity maximizes non-redundant coverage across environments, tasks, and interaction behaviors. The survey synthesizes verification mechanisms (rule-, model-, human-based checking, execution/state-based verification), complexity construction/calibration techniques (structural specification, task/information control, failure-driven calibration), and diversity-expansion mechanisms (source/support expansion, compositional recombination, exploration-driven discovery, coverage-guided balancing) across tool-use, coding, GUI/web, embodied, social, and scientific agent domains.

Key results:

• Identifies a literature-wide shift: from plausibility-based judgments toward execution-grounded accuracy verification, from static difficulty heuristics toward learner/configuration-relative complexity, and from surface-level variation toward genuine behavioral-coverage diversity.
• Cites evidence (from surveyed work) that diversity-oriented data scaling can outperform simple quantity scaling under comparable or smaller data budgets, and that a smaller set of robust, behaviorally distinct environments can outperform a larger but redundant/weakly verified collection.
• Cites controlled tool-use studies showing that tool-pool and per-task toolset coverage improves out-of-distribution performance more efficiently than repeated sampling from the same support.
• Argues accuracy and diversity/complexity are asymmetric objectives: difficulty or variation cannot compensate for invalid (inaccurate) data, whereas uniformly valid but trivial/repetitive data provides little learning value.
• Extends the ACE lens to discuss scaling laws, real-vs-synthetic data tradeoffs, agentic pre-/mid-training, and self-evolving agent data loops as emerging directions.

Why it matters / caveats: Provides a unifying vocabulary (E, q, τ, v and ACE) for comparing agentic data generation methods across previously siloed domains, useful for anyone designing new data pipelines or evaluating existing ones. As a survey/positional paper it reports no new experiments of its own; its "results" are syntheses and framework claims drawn from cited prior work rather than original benchmark numbers.

Problem: Post-training methods for math reasoning (RL, on-policy self-distillation) require ground-truth labels, which are unavailable in test-time training (TTT), and replacing them with majority-vote pseudo-labels is fragile because an incorrect pseudo-label can corrupt a distillation teacher and mislead every token.

Method: The authors observe an asymmetry: rollouts that disagree with a majority-vote pseudo-label are usually wrong regardless of whether the pseudo-label itself is correct (on AIME 2026 with Qwen3-1.7B, pseudo-labels are wrong for ~85% of prompts, yet ~79% of disagreeing rollouts are also wrong). Test-Time Policy Optimization (TTPO) exploits this asymmetry: rollouts that agree with the pseudo-label are distilled via On-Policy Self-Distillation (OPSD) toward an answer-conditioned teacher (forward KL, per-token weighted using student entropy and teacher-student divergence via a Soft-OR combination), while disagreeing rollouts are penalized with GRPO (group-relative RL) using token-level masking that keeps only the top-50% "confident error" tokens (ranked by negative log-probability times certainty). The two branches are combined in a single objective with an RL weight λ=0.1, using K=64 sampled trajectories per problem for majority voting.

Key results:

• On OpenThoughts training data (labels available but unused by TTPO), TTPO exceeds label-supervised OPSD on all three scales: 40.1 vs. 39.7 avg (Qwen3-1.7B), 58.6 vs. 58.4 (4B), 62.6 vs. 61.7 (8B), across AIME25/26, HMMT25/26, BRUMO25.
• In the pure label-free TTT setting, TTPO raises Qwen3-1.7B average accuracy from a 38.0% base to 45.2%, beating OPSD-TTT (41.9) and TTRL (40.2); TTPO on Qwen3-4B (61.1) surpasses the untrained Qwen3-8B base (60.7).
• With thinking mode disabled at inference, TTPO gains +25.2 (1.7B), +30.6 (4B), +36.4 (8B) points over base, versus only +7.1/+5.8/+3.5 for label-supervised OPSD.
• Ablations: removing positive-sample token weighting or negative-sample token masking each hurts performance (e.g., full TTPO 31.6 AIME26 vs. 30.6 w/o pos. weight vs. 29.5 w/o neg. mask); the asymmetric routing (FKL on positives, GRPO on negatives) at 48.9 AIME26 clearly beats all three alternative pairings (best alternative 46.7).
• Cross-benchmark transfer: training on any one of AIME26/HMMT26/BRUMO25 improves performance on the other two, indicating generalizable reasoning gains rather than memorization.
• Surprisingly, TTPO with pseudo-labels outperforms a variant using ground-truth labels (TTPO w/ GT) because perfect labels are too hard to match on difficult problems, starving both branches of active samples.

Why it matters / caveats: Shows unlabeled test-time training can match or exceed label-supervised post-training for math reasoning by exploiting a simple statistical asymmetry in pseudo-label errors, with a documented "self-evolving" cycle (Maj@12 keeps rising during training rather than plateauing at the base model's ceiling). Caveats: evaluated only on math competition benchmarks (AIME/HMMT/BRUMO) with Qwen3 models, and the method depends on hyperparameters like the RL weight λ and rollout count K=64 that were tuned/ablated specifically for this setting.

Problem: A live e-commerce digital-avatar streamer needs a compact, low-latency model, but compact models trained on a fixed "Harness" (the modular Skills/Hooks/prompts/tools execution environment) overfit to that specific configuration and break whenever the Harness is updated, while large zero-shot models generalize but are too slow (e.g., DeepSeek-V4-flash has >11s median latency) for real-time streaming.

Method: The paper introduces Harness-Aware Training (HAT) for a compact model (Qwen3.6-35B-A3B) built around Harness-State Augmentation (HSA), which applies task-preserving perturbations to five surfaces: Skill identifiers, Skill content, tool schemas/definitions, system prompt structure, and Hook behavior. HAT is a three-stage pipeline: (1) HSA-SFT — supervised fine-tuning on trajectories from a strong teacher model generated across HSA-diversified Harness variants, filtered by a rejection-sampling judge on Accuracy/Effectiveness; (2) General On-Policy Distillation (General OPD) — the pre-SFT base model distills into the student on general Tulu3 instruction data to recover capabilities lost during domain SFT; (3) HSA-RL — reinforcement learning (GRPO-style with Group reward Decomposed Policy Optimization/GDPO advantages and GSPO sequence-level importance sampling) inside a production-informed live-streaming simulator with injected tool failures, rewarding Accuracy, Effectiveness, Tool Rationality, and Skill Selection, plus a chain-of-thought length penalty.

Key results:

• HAT reaches AVG 94.8 on Live-Stream QA (T1) and 94.6 on Harness-Variant QA (T2), versus base model 80.3/75.4 and the strongest general LLM baseline (93.0/93.5).
• HAT's T1-to-T2 performance gap is only 0.2 points, versus 4.9 points for the untuned base and 1.3 points for naive Fixed-Harness SFT — showing robustness to Harness changes.
• Fixed-Harness SFT causes a 7.7-point drop on IFEval (81.5→73.8) and a 5.3-point drop on IFE-I, while HAT avoids this, scoring 83.5 IFE-P (+2.0 over base) and 88.7 IFE-I (+1.0).
• Ablation: HSA-SFT alone improves T1/T2/Tool-Robustness by 9.7/14.8/15.7 points while raising Prompt Robustness by 4.5 points (vs. Fixed-Harness SFT's 4.6-point Prompt Robustness drop); without HSA, the RL stage drops Prompt Robustness from 72.6 to 66.7 (below base), whereas HSA-RL raises it from 77.1 to 77.6.
• Deployed on one NVIDIA H20 GPU with MTP speculative decoding, the system achieves P50 latency of 3.4s and P95 of 8.1s (all requests under the 15s bound at concurrency 1–2), with MTP raising decoding throughput by 1.69x/1.52x at concurrency 1/2.
• In a production Taobao Live A/B test against a ReAct control, the Harness-based treatment achieved UV-normalized uplifts of 4.33% in confirmed-receipt GMV and 0.91% in item-page views.

Why it matters / caveats: Demonstrates a practical recipe for keeping a small, fast model aligned with a frequently-updated agent execution environment without retraining per update, validated with real production A/B test results rather than only offline benchmarks. Caveats: results are specific to one company's live-streaming deployment and one model family (Qwen3.6-35B-A3B); some diagnostics (e.g., CoT-length and MTP-adaptation trajectories) are explicitly noted by the authors as single-run process diagnostics rather than causal or statistically robust evidence.

Problem: Spatial/world-model post-training lacks a cheap, reliable reward signal analogous to compilers/tests for code — current spatial generation relies on fuzzy, gameable proxies (CLIP scores, FVD, MLLM-as-judge), which caps data efficiency and prevents the kind of RL post-training loop that has driven progress in coding and reasoning models.

Method: The paper argues game engines can supply the missing verifier and proposes Reinforcement Learning with Human-Engine Verification (RLHEV), a post-training paradigm combining dense engine-check rewards (collision, physics stability, navmesh reachability, script execution, bounded playability) with sparse human developer acceptance/rejection signals, formalized as a constrained reward-selection objective (Eq. 2) with engine checks as penalty terms and hard gates plus a human-review utility term. This trains the Agentic World Model (AWoMo), a world-building agent with intent/action/verification/review interfaces that proposes scene edits, engine-executes and localizes failures, repairs, and stores every step as a structured trace under the proposed Unified World-Development Protocol (UWDP), a typed multimodal state-action-check-review record format. The full RLHEV reward mixes 0.65 human + 0.35 engine signal.

Key results:

• On UnitySceneBench (a 200-example Unity asset-edit/classification benchmark, best-of-8-seeds evaluation), Full RLHEV achieves the highest primary score (0.681: 0.665 accuracy, 0.665 balanced accuracy, 0.733 F1, 0.690 AUC), beating the strongest non-full baseline by +0.098 primary score and +0.120 accuracy/balanced accuracy.
• On the generation-side task with the full 720-instance training budget, Full RLHEV reaches 0.8197 generation quality vs. 0.7934 for Engine-based RLVR alone.
• Generalization: pretraining on source data before target adaptation improves Unity in-distribution-shift score from 0.25 (scratch) to 0.75; cross-engine transfer gives smaller positive gains, Unity-to-Unreal rising from 0.25 to 0.35 and Unity-to-Godot from 0.15 to 0.35.
• Embodied diagnostics: AWoMo-augmented training improves over the original baseline by +0.79% on R2R success rate, +9.96% on Gymnasium MuJoCo rollout return, and +48.43% on D4RL Gym-MuJoCo normalized score (vs. smaller gains of +0.22%, +5.07%, +39.68% for naive augmentation on the same three benchmarks).

Why it matters / caveats: Proposes a concrete, falsifiable path (via stated "oracles"/falsifiers P1-P3) to give spatial/world-model training a code-agent-like verifiable reward loop by treating game development trajectories as training data, potentially enabling recursive self-improvement for world models. The authors themselves describe the results as "pilot studies" / "diagnostic" rather than large-scale validation, note that cross-engine asset quality still relies on an MLLM-as-judge rubric (audited by humans) rather than a fully engine-native scalar, and flag that larger scaling studies are needed to confirm generalization.

Problem: It is unclear whether multimodal large language model (MLLM) agents that perceive a single street-view scene well can turn that local perception into reliable, sustained navigation and action across a complex, real-scale city.

Method: The paper introduces URBANGROUND, a Unity-based sandbox built from Hong Kong's territory-wide 3D Visualisation Map and 3D Pedestrian Network (Lands Department data), giving agents closed-loop first-person control, physical collision, an interactive map, and controllable time-of-day, weather, road closures, and animated pedestrians (Microsoft Rocketbox avatars). Agents are evaluated through a five-level "spatial agency evaluation ladder" (local understanding, explicit navigation, implicit-instruction exploration, multi-task planning, dynamic environment interaction) spanning 810 manually verified task instances, using metrics like answer accuracy, pedestrian-network adherence (PNA), navigation success rate, safe-progress rate (SPR), and pedestrian-collision rate (PCR).

Key results:

• On visual recognition, top models like Kimi-K3 and Gemini-3.6-Flash reach 92.5-93.8% accuracy, but orientation understanding drops sharply (e.g., Gemini-3.1-Pro at 23.3%, near random for a 4-option task).
• Short-range navigation success reaches up to 75% (GPT-5.5, Claude-Opus-4.6), but long-range navigation collapses to near 0% across nearly all models (e.g., 0.0-3.8%).
• Despite near-zero full-task success, over 50% (up to 81.3% for Claude-Opus-5) of long-range navigation episodes still end closer to the goal than they start, showing partial but uncompleted progress.
• Under road closures, safe-progress rate (SPR) stays low (10-46.7%) even though pedestrian-network adherence remains high (>93%), indicating agents keep moving in locally plausible ways without adapting their route.
• Weather/time changes (dusk, night, rain) reduce local QA accuracy noticeably (e.g., GPT-5.4 drops from 56.8% clear to 44.1-48.6% under dusk/night) but have inconsistent effects on short-navigation success.

Why it matters / caveats: The benchmark shows that strong local perceptual grounding does not compose into reliable long-horizon urban navigation—errors accumulate without correction, and agents fail to revise plans when the city changes (e.g., road closures), exposing a key gap for deploying MLLM agents as embodied city-scale assistants.

Problem: On-policy distillation (OPD) for flow matching models gives stable, dense step-wise supervision but requires training a separate task-specific teacher for every new objective, which is costly and causes teacher-student distribution mismatch and gradient conflicts when fusing multiple teachers.

Method: Self-OPD is a teacher-free OPD framework that, at each denoising timestep, branches the deterministic next-state prediction into K stochastic SDE candidates, rolls each out via an ODE sampler to a clean image, and scores them with task reward models against a deterministic self-reference (pure ODE) baseline to compute normalized advantages. It then applies an "all-branch pull-push" distillation objective (with SDE-variance normalization, connected to a per-step reward-tilted KL minimization) where high-advantage branches pull the velocity field and low-advantage branches push it away under a direction-aware attenuation coefficient that prevents repulsion from countering the best branch; for multi-objective alignment it fuses z-scored rewards at the reward level (ranking branches) rather than blending gradients, avoiding field-level teacher routing and gradient conflict.

Key results:

• On single-reward training with SD3.5-Medium, Self-OPD achieves GenEval strict 0.9536 (vs. base 0.5222), OCR accuracy 97.45% and PickScore 24.47/HPSv2 0.3665 under respective reward targets, outperforming Flow-GRPO and GRPO-Guard on every task.
• In mixed-reward training, the single unified Self-OPD model reaches GenEval strict 0.9479, OCR accuracy 96.0%, and (same-test-images protocol) PickScore 23.87 / HPSv2 0.3214, beating teacher-based DiffusionOPD's PickScore 22.72 / HPSv2 0.2676.
• Field-level fusion (DiffusionOPD) shows a preference-score shift of Δ=1.23 (PickScore) and Δ=0.105 (HPSv2) between aesthetic and task prompts, whereas Self-OPD's shift is only Δ=0.48 and Δ=0.020, indicating consistent quality across prompt types.
• Ablations show Best-of-K branch selection is unstable, unbounded direction-aware gating causes performance collapse, while the full bounded all-branch + KL-normalized loss gives stable, faster convergence.
• Training efficiency: Self-OPD (from scratch) reaches DiffusionOPD-level OCR (0.946) in ~62h and GenEval (0.915) in ~90h versus DiffusionOPD's 97h total; a warm-start variant converges in ~48h/~44h, about 2x faster with higher final performance.

Why it matters / caveats: By removing the need for task-specific teachers and per-teacher gradient fusion, Self-OPD offers a cheaper, more flexible path to multi-objective flow-matching alignment (text rendering, composition, aesthetics) that generalizes across objectives without the teacher-coupling artifacts seen in prior OPD methods; results are demonstrated only on SD3.5-Medium at 512x512 with LoRA fine-tuning.

Problem: Existing game-playing agents map visual/task context directly to actions without modeling how the visual world evolves, while interactive game world models predict visual dynamics but rely on externally supplied actions rather than choosing task-directed behavior themselves—leaving no unified model that both predicts consequences and selects actions for native, closed-loop video game and GUI control.

Method: GameWAM is a World-Action Model built from parallel Video-DiT and Action-DiT branches trained with joint flow matching under block-causal attention, jointly generating future visual observations and executable keyboard-mouse action trajectories. It handles heterogeneous native control via a per-action router that selects gameplay- vs. GUI-specific action-flow predictions with regime-specific normalization, and it uses "block-cycle control" that predicts P future actions but commits and executes only a short E-step prefix before replanning, combined with a bounded within-cycle KV cache plus a hierarchical cross-cycle visual history (recent Conv3D-compressed segments and attention-pooled long-term memory slots) to preserve temporal continuity under bounded memory. Training uses synchronized gameplay/GUI trajectories (regular and event-anchored VPT data plus scripted GUI trajectories) with event-anchored clip sampling that emphasizes event-rich segments.

Key results:

• On the MCU Minecraft benchmark (800+ tasks), GameWAM achieves the highest average success rates on both Mini (46.6%) and full task sets (42.5% ASR All) while using fewer native interaction steps per successful episode than compared agents across all task categories (e.g., 138 steps for embodied vs. 305-406 for other agents).
• On ViZDoom across four maps, GameWAM consistently improves over Game-TARS and achieves competitive or leading average reward relative to multimodal agents including GPT-5, Gemini-2.5-Pro, and Claude-4-Sonnet.
• Ablations show removing future-video supervision or using coarser temporal sampling causes the largest performance drop (Avg ASR falls from 50.7% to 35.7-36.7%); using a unified (non mode-specific) action distribution and matching prediction/execution horizons (P=E) also degrade performance.
• The paper identifies "Low-Frequency Action Source Imprinting" (LASI): low-frequency DCT components of the sampled action source causally steer coarse camera motion, with within-condition Pearson r up to 0.890 for yaw, donor-swap follow rate of 94.8%, and zeroing the low-frequency band removing 99.25% of associated output variance.

Why it matters / caveats: GameWAM demonstrates that joint world-action modeling can serve as an effective, action-efficient policy for native game control rather than just a passive dynamics simulator, but the discovered LASI failure mode shows generative action policies can develop persistent, harmful directional biases from reused random sources during closed-loop rollout, which the authors mitigate only by resampling the source at each replanning step (not fully solving the underlying sensitivity).

Problem: Existing agent self-improvement methods (reflection, judge-based evaluation, self-evolving harnesses) process experience only after a run ends, so lessons cannot help the run that produced them, and no existing architecture combines live mid-run correction with a dedicated, separate self-improvement role.

Method: PILOT is a supervisor-worker harness, implemented as an extension of the Pi coding-agent runtime, that realizes "live self-improvement" through two coupled mechanisms: (1) live steering, a two-way channel where the supervisor receives worker notifications/questions/results during execution and can steer (queue guidance) or abort the active worker mid-run; and (2) live self-evolution, where the supervisor distills reusable procedures and failure modes observed in the live trajectory into a persistent skill library K and memory M (harness H) available to later workers, without ever using benchmark/verifier feedback to create the updates (only to decide which updates carry forward).

Key results:

• Across two frozen backbones (GLM-5.1, Kimi-K2.6) and three benchmarks (Terminal-Bench 2.0, SWE-bench Multilingual, SWE-bench Pro), PILOT ranks first in 5 of 6 backbone-benchmark combinations.
• On Terminal-Bench 2.0, PILOT reaches 71.9% (GLM-5.1) and 71.3% (Kimi-K2.6), outperforming the strongest baseline (Pi) by up to 9.8 percentage points in some comparisons and by 5.0/4.4 points respectively on average; on Hard tasks PILOT reaches 55.0% on each backbone, 5-6.7 points above Pi.
• In the self-improvement (iterative) setting, PILOT's best pass rate rises 14.6 points (66.3% -> 80.9%) with GLM-5.1 and 12.4 points (68.5% -> 80.9%) with Kimi-K2.6, versus only +7.9 points for OpenCode and +2.3 points for Pi under the same conditions.
• Skill libraries grow from 62->83 (GLM-5.1) and 50->81 (Kimi-K2.6) skills across iterations; mean output tokens per evaluated task fall by 42.9% and 47.4%, while successful evaluations per million output tokens rise by 110.3% and 134.0%.
• Manual trace analysis shows live steering aids 10.6% (Kimi-K2.6) and 2.3% (GLM-5.1) of successful runs overall, concentrated on Hard tasks (up to 19.7%) and absent on Easy tasks.

Why it matters / caveats: PILOT shows that separating live execution from live oversight (rather than post-hoc review) can both recover failing runs in-flight and make accumulated experience more efficiently reusable across tasks; limitations include that supervisor and worker share the same frozen backbone (leaving heterogeneous pairings unexplored) and evaluation is limited to three benchmarks and two open-weight models due to the cost of repeated iterative runs.

Problem: Robot manipulation policies need to generalize zero-shot to unseen tasks at deployment, but language instructions underspecify spatial constraints, intermediate states, and temporal structure, and large-scale paired human-robot demonstration data needed to exploit human videos as richer task specifications is scarce.

Method: Zero-WAM is a causal video-action model (built by converting Wan-2.2-TI2V-5B into a Mixture-of-Transformers video+action policy, following the LingBot-VA framework) that autoregressively predicts future robot video chunks and then decodes executable action chunks via an inverse-dynamics action Transformer, conditioned on either a language instruction or an in-context human demonstration video (using a RoPE height-axis offset to distinguish human-video tokens from robot-video tokens). To scale training data, the authors build an automatic in-context human video generation pipeline (VLM task analysis + image editing + video generation models like Nano Banana 2/Wan 2.7/Kling AI 3.0) that converts task-sampled robot trajectories into semantically matched human videos, producing the HumanGen dataset (74.2K human-robot ICL pairs, 8.6K tasks) plus a task-balanced Task-diverse VA pretraining corpus (~400K trajectories/epoch over 6,000+ tasks). Training also adds an in-context future chunk prediction (IFP) objective that supervises multiple strided future video chunks to prevent the model from shortcutting past the human-video prompt using only recent robot history.

Key results:

• On 7 unseen RoboTwin 2.0 tasks, Zero-WAM achieves a 46.95% average success rate, versus 17.45% for LingBot-VA and 10.98% for a Wan-2.2-based baseline (WAN-Action) — improvements of 29.50 and 35.97 percentage points respectively.
• Zero-WAM outperforms both baselines on all 7 individual unseen tasks, e.g., 84.87% on "place empty cup" (more than double the baselines) and is the only method with non-zero success (9.0%) on the hardest long-horizon task "stack blocks three."
• In real-world evaluation on a bimanual Franka robot, Zero-WAM reaches 53.3% success on object-to-container placement (vs. 43.3% for language-conditioned LingBot-VA), 33.3% on three-object sequential manipulation (vs. 10.0%), and 16.7% on two-table-leg insertion (vs. 0.0% for LingBot-VA).
• HumanGen is reported as containing 74.2K human-robot ICL pairs across 8.6K tasks and >45 robot embodiments, substantially broader in task coverage than prior manually-collected paired datasets (e.g., RH20T's 110K samples but only 147 tasks).

Why it matters / caveats: The results suggest human demonstration video is a more effective in-context task specification than language alone for zero-shot manipulation generalization, and that automatically generated (rather than manually collected) paired human-robot data can scale this training paradigm; however, absolute success rates remain modest on hard tasks (e.g., 9% on stack-blocks-three, 16.7% on precise insertion), indicating substantial room for improvement.

Problem: It is unclear whether Evolution Strategies (ES), a memory-efficient gradient-free post-training method, is merely a weaker substitute for GRPO or offers a genuinely different optimization behavior for LLM reasoning, particularly regarding reasoning-coverage (Pass@K), catastrophic forgetting, and scalable hyperparameter settings.

Method: The paper compares ES (population-based parameter perturbation with reward-standardized, one-point gradient estimation) against GRPO (token-level clipped policy-gradient with group-normalized advantages) both theoretically and empirically. It derives Fisher-information-based lemmas showing verifier-projected Jensen–Shannon policy diversity across the ES population increases Pass@K, proposes two sequential composition strategies (ES→GRPO and GRPO→ES) to combine GRPO's Pass@1 strength with ES's Pass@K gains, and analyzes parameter-update magnitude distributions (via relative L2 drift and magnitude-thresholding) to test whether large ES parameter drift causes catastrophic forgetting.

Key results:

• On GSM8K→GPQA training/testing with Qwen2.5-1.5B-Instruct, GRPO finishes below the base model on Pass@16/Pass@32 while ES finishes above it; GRPO raises Pass@1 but lowers Pass@16/Pass@32 on representative task pairs, while ES improves all three metrics.
• GRPO falls below the base model on both Pass@16 and Pass@32 in 15 of 18 comparisons in the Easy Setting (GSM8K post-training across three models), whereas ES improves average Pass@1, Pass@16, and Pass@32 over base in both Easy and Hard Settings.
• Full ES parameter drift (relative L2 distance) is 40.7–44.1× larger than GRPO's across four models, yet at threshold τ=1.5×10⁻³, 77.6–93.0% of nonzero updates are within this small-magnitude range and removing them barely changes target-task Pass@1 — the largest ES updates concentrate in LayerNorm weights and attention projections (e.g., 117/144 max-magnitude coordinates in DeepSeek-R1-Distill-Qwen-1.5B are LayerNorm weights) versus GRPO's largest updates (48× and 16× smaller) concentrated in token embeddings/LM head.
• z-score reward normalization improves ES training rewards versus no normalization; population size needed to match N=64 reward drops with scale (N=16-to-N=64 gap falls from 0.0352 at 0.5B to 0.0051 and 0.0030 at 1.5B/3B); two-point (antithetic) ES estimators give no advantage over one-point for reasoning tasks, unlike in supervised zeroth-order fine-tuning.

Why it matters / caveats: The findings reposition ES as a distinct reasoning post-training paradigm (broader exploration/coverage, avoids entropy collapse) rather than a lesser, only-more-memory-efficient alternative to GRPO, and suggest sequential ES/GRPO composition and scale-dependent population sizing as practical recipes. The forgetting analysis is based on held-out benchmark comparisons under specific training settings and contradicts a prior paper's claim of ES-induced catastrophic forgetting, which the authors attribute to that prior work's limited (small dataset/single model) evaluation.

Problem: Video foundation models can generate realistic imagery but cannot reliably guarantee consistent gameplay rules, object states, or interaction outcomes, so directly replacing conventional game rendering pipelines with generative video risks losing the reproducibility and designability required for real interactive games.

Method: Magpie separates gameplay execution from visual generation: an Unreal Engine-based Game Engine resolves player actions and maintains authoritative world state, emitting a "white-box" observation and camera pose per chunk, while an independent Render Server (built on a distilled Wan2.2-TI2V-5B backbone) generates the final video conditioned on the white-box frame (via cross-attention injection, chosen over direct-latent-embedding and AdaLN alternatives), a text/first-frame initialization, and a bounded memory of anchor block + Context-as-Memory-style FOV-retrieved history + recent chunks. The renderer adopts Helios's hierarchical few-step generation and pyramid 3-step distillation, plus LightTAE autoencoding and FP8 mixed-precision execution for real-time deployment, and the two components communicate over WebRTC with a jitter buffer tuned for freshness over smoothness. Training data comes from a custom-collected ~300-hour Unreal Engine dataset (30+ scenes, human operators, 1920×1080 @60FPS) with synchronized high-fidelity/white-box video pairs, camera poses, and structured interaction records; appearance annotations (scene style, character appearance) are auto-generated via Qwen3.6-27B.

Key results:

• On a single H100 GPU, the distilled 5B Render Server achieves steady-state compute throughput of 32.2 FPS (620 ms per 20-frame chunk) at 1280×768 resolution, with peak GPU memory usage of ~34 GB.
• End-to-end interaction latency from user action to visible feedback is ~1.55 s, decomposed as ~0.83 s Game Engine white-box chunk preparation + ~0.1 s network transmission/encoding + ~0.62 s Render Server inference/decoding.
• Training data: ~300 hours of human-operated paired video across 30+ Unreal scenes covering locomotion, viewpoint changes, driving, sitting, collisions, and idle states.

Why it matters / caveats: The engine/renderer separation offers a practical path to cut visual-asset production costs in early game prototyping while preserving rule reproducibility, but the authors themselves note major limitations: end-to-end latency (~1.6s) is too high for responsive gameplay, white-box RGB conditioning suffers depth/geometry ambiguity, generated output can drift from the white-box condition under fast motion or occlusion, there is no persistent 3D visual memory (causing long-horizon appearance drift), no audio generation, and the 34GB/H100 requirement blocks edge deployment — so this is a systems proof-of-concept rather than a production-ready renderer.

Problem: Native mesh-based 3D generators (SDF/voxel or autoregressive) produce soft, scan-like surfaces with no part decomposition and no editable parameters, while single-shot LLM code generation for 3D shapes stays low-poly and drifts on many-part objects because one pass must commit every part, dimension, and placement at once.

Method: Procedura is an agentic framework in which a frozen LLM (Gemini 3.7 Flash or GPT-5.6-sol) writes an object as a "procedural assembly" — a parametric CSG program whose named parts (modules) are joined by typed, machine-checkable "mates" (9 static types like peg-socket, bolt-pattern, snap-tab, plus revolute/prismatic/spherical kinematic mates) drawn from a closed vocabulary. The pipeline runs three stages: Planning (a vision call decomposes a synthesized reference image into an ordered assembly graph, followed by one-direction plan review that can only add/refine, never merge/remove/reorder); Mate-Driven Building (one LLM call per part, given assembly reference + built history + multi-view 3D feedback renders, with placement solved algebraically from mated frames rather than guessed, gated by a compile check, a mate gate measuring registration area/penetration depth, and a span-based connectivity gate); and Decoupled-Critic Refinement (a separate single-turn vision critic diagnoses issues, gated one-fix-per-diagnosis via a one-shot latch). The same mate graph additionally drives per-part PBR material assignment (via a material library extracted from the reference plus a decoupled critic) and simulator-validated articulation (joint tree exported as OpenUSD/URDF, validated headless in Isaac Sim).

Key results:

• On MechBench-36 (the paper's new 36-object hard-surface benchmark), Procedura (Gemini 3.7 Flash) achieves the top judge composite of 0.828 versus 0.810 for TRELLIS.2 (best native generator) and 0.799/0.797 for Adam CAD and Procedura's own GPT-5.6-sol variant.
• On P3D-Bench (203 cases), Procedura reaches composite scores of 0.590 (Gemini 3.7 Flash) and 0.575 (GPT-5.6-sol), versus 0.524 for the strongest prior full-coverage baseline, with the largest margin on the geometry axis (0.490 vs. 0.392).
• Edge sharpness: Procedura's programs carry 158.1 (Gemini) and 185.2 (GPT-5.6-sol) units of sharp-edge length above a 60° dihedral — 2.6× and 3.1× the next code-emitting method — at 95th-percentile dihedrals of 98.0°/105.3°, versus 33–73° for native generators.
• Ablations on MechBench-36: removing refine drops the composite from 0.828 to 0.800, removing planning drops it to 0.791 (largest hit), removing 3D feedback drops it to 0.819; paired per-object gains over single-shot prompting on Gemini 3.7 Flash are +0.105 aesthetics (sign test p=0.019) and +1.80 CLIP (p=0.011).
• Articulation validated in Isaac Sim across 18 objects: 14 clear all dynamics phases (settle, per-joint actuation, rest-contact scan, URDF re-import), and 9 of those also pass advisory asset rules.

Why it matters / caveats: Procedura demonstrates that casting 3D generation as verifiable, part-structured code (rather than mesh regression) yields sharper geometry, native part decomposition, and directly editable/simulatable output with no 3D-specific training — at the cost of only handling rigid, hard-surface/mechanical objects well (CSG is a poor fit for organic/freeform shapes), relying solely on rendered-image perception (missing occluded interior geometry), and being limited to a fixed, closed mate vocabulary that cannot verify relations the plan never declares.

Problem: Existing generative video editors handle only short, single-shot clips with homogeneous instructions; naive fixed-duration chunking of long, multi-shot videos with multiple heterogeneous instructions causes entity hallucination (applying instructions to shots where the target entity is absent), broken cross-shot identity consistency, and disrupted temporal/spatial structure.

Method: The paper formalizes the Multi-Instruction Multi-Shot Long-Video Editing (MMLVE) task with three objectives — Cross-Shot Editing Consistency (CSEC), Multi-Instruction Decoupling (MID), Zero-Destruction on Spatiotemporal Structure (ZDSS) — and proposes MMLVE-Agent, a heterogeneous multi-agent pipeline: (1) Instruction & Video Analysis uses PyDetect for physical shot segmentation and an LLM/VLM agent (Gemini 3.5 Flash) to parse/decouple instructions and extract keyframes; (2) Global Memory Card Making retrieves top-k entity keyframes via VLM voting and synthesizes a "before/after" reference image pair with the Nano Banana 2 image generator, refined by an image-level Pos-Neg Editing Feedback (P-NEF) loop that generates both a Negative Prompt (errors to avoid) and a Positive Prompt (features to retain, preventing attention drift/catastrophic forgetting during iterative refinement); (3) Multi-Shot Video Editing applies retrieval-based on-demand editing (a shot is only edited if the entity gets ≥2 of 3 VLM votes) via the HappyHorse video editing model conditioned on the Global Memory Card, with a video-level P-NEF self-correction loop (max 3 attempts) enforcing MID and ZDSS. The authors also build MMLVE-Bench, 25 curated ~1-minute multi-shot videos (derived from UniVA-Bench) with ~5 dense, heterogeneous (ADD/DELETE/MODIFY) instructions each, and a 15-sub-dimension VLM-judge (Gemini 3.5 Flash) scoring protocol for CSEC/MID/ZDSS.

Key results:

• On MMLVE-Bench, MMLVE-Agent achieves the highest average VLM-judge score of 81.84, leading on CSEC (84.80) and MID (79.04), versus Seedance 2.0 (79.47 avg, 77.58 CSEC, 78.58 MID), Kling o3 (70.57 avg), and HappyHorse 1.0 standalone (69.61 avg).
• Seedance 2.0's ZDSS score (82.25) is inflated by a conservative strategy that skips edits in complex scenes, resulting in lower CSEC/MID; MMLVE-Agent's ZDSS (81.68) is close behind despite executing all edits.
• User study with 9 expert evaluators (45 rankings, 5 cases each): MMLVE-Agent ranked 1st in 75.6% of cases and top-2 in 93.3%, with best average rank 1.36 vs. 2.63–3.16 for baselines; pairwise preferred over Seedance 2.0, Kling o3, and HappyHorse in 88.4%, 80.5%, and 93.3% of co-rated cases respectively (all p<0.001, Bonferroni-corrected Wilcoxon signed-rank test).
• Qualitative ablation shows the P-NEF mechanism (vs. Negative-only feedback, NEF) prevents "catastrophic forgetting" of previously correct edits by using a Positive Prompt as an attention anchor, reducing the number of correction iterations needed.

Why it matters / caveats: The work introduces both a well-defined new task/benchmark and an agentic system that substantially outperforms closed-source SOTA video editors (Seedance 2.0, Kling o3) on long multi-shot editing without any new video-generation model training, relying instead on retrieval, memory-anchoring, and self-correction around an off-the-shelf editor (HappyHorse). Baselines' failures (Seedance's safety-mechanism rejections in 1–2 scenarios, marked with †, excluded from means) and the reliance on a single VLM (Gemini 3.5 Flash) as both agent backbone and judge are worth noting as evaluation caveats.

Problem: Existing agent skill-evolution methods (e.g., EvoSkill, Trace2Skill, SkillOpt) iteratively refine skills from execution traces, but the insights that guide skill development remain scattered across optimization histories, limiting systematic reuse of accumulated knowledge across iterations.

Method: WikiSkill introduces a three-layer agent workspace — an immutable Raw Layer (execution traces), a persistent, never-reset Wiki Layer (structured pattern pages, an evolution log, and a skill-impact tracker), and a Skill Layer (active procedural skills, each with SKILL.md and a PURPOSE.md linking back to motivating wiki patterns). Each evolution iteration runs four components: an Inference Agent executes rollouts using current skills (restricted from Wiki access, per ablation findings); a Wiki Maintainer performs root-cause analysis on sampled traces and patches the persistent pattern catalog/index/logs; a Wiki-Informed Skill Proposer (operating in ReAct style, using the wiki index, skill-impact tracker, and task outcome summaries) proposes one atomic skill creation or edit; and a Gating and Rollback mechanism accepts the candidate skill set only if it improves validation score (rolling back skills but never the wiki) — recording every proposal, diff, and outcome to skill-impact.md for future reference.

Key results:

• Across 5 models (Qwen-3.5-4B/9B, Qwen-3.6-27B, Gemma-4-31B, Gemini-3.5-Flash) and 5 benchmarks (LiveMath, SealQA, SpreadSheetBench, OfficeQA, ALFWorld), WikiSkill achieves the highest average performance for every model, beating the strongest competing skill-evolution baseline by +3.3, +5.1, +10.0, +5.8, and +12.0 points respectively.
• WikiSkill improves Gemini-3.5-Flash from 33.0%→72.6% on LiveMath and 50.5%→76.6% on SpreadSheet; improves Qwen-3.6-27B from 52.8%→77.6% on ALFWorld.
• Benefits of skill evolution scale with model size within the Qwen family: average WikiSkill gains rise from +12.3 points (4B) to +17.5 (9B) to +23.9 (27B); Qwen-3.5-9B with WikiSkill (47.4% avg) outperforms Qwen-3.6-27B with no skills (39.4% avg).
• Cross-model transfer: skills evolved by Qwen-3.6-27B improve Qwen-3.5-9B on SpreadSheet to 50.5% (vs. 24.3% no-skill, 33.6% self-evolved); on ALFWorld, Qwen-3.5-9B reaches 70.2% using a Qwen-3.6-27B-evolved skill vs. 63.4% with its own.
• Ablation (Gemini-3.5-Flash): giving the Skill Proposer wiki access (with Inference Agent lacking it) raises average performance from 48.7% to 63.7% (+15.0 points); conversely, also giving the Inference Agent wiki access during training rollouts drops it back to 60.9%, since trajectories become less informative for skill development.

Why it matters / caveats: The results support the hypothesis (attributed to Karpathy's "LLM Wiki" concept) that separating persistent, compounding knowledge from mutable, rollback-able skills is critical for reliable skill evolution, and show skill discovery and skill execution are distinct capabilities that can be decoupled across models. Caveats stated by the authors: skills are injected directly into the prompt (skill retrieval/triggering at scale is untested), validation gating requires strict per-iteration improvement (excluding potentially useful neutral proposals), the wiki has no pruning mechanism as it grows, and evaluation does not cover very long-horizon tasks spanning hundreds of actions or multiple hours.

Problem: Vision-language models (VLMs) struggle to comprehend multimodal humor (satire, sarcasm, memes) because standard reasoning methods like Chain-of-Thought fail to capture the causal, relational incongruities that generate comedic effect.

Method: CARGO-T (Causal Reasoning Graph-of-Thought) prompts a VLM to first construct a Causal Reasoning Graph (CRG) — a lightweight, code-serialized structure of entities, their properties, and cause-effect relations — before producing a final answer, in both zero-shot and in-context-learning (K-shot) settings. In-context example CRGs are drafted by GPT-4o and then manually rectified into a standardized entity/causal-relation format. It is compared against Vanilla, Chain-of-Thought (CoT), Chain-of-Draft (CoD), and Compositional Chain-of-Thought (CCoT) baselines across GPT-4o, GPT-4o-mini, and MiniCPM-V-2.6.

Key results:

• Improves Humor Understanding Avg. Score by ~1–20% and Humor Detection by ~1–3% over reasoning baselines across four datasets (YesBut, MemeCap, MMSD 2.0).
• Zero-shot: on GPT-4o, CARGO-T raises Satirical Image Understanding Avg. Score to 0.3726 vs. 0.3663 (best baseline CoD) and Meme Captioning to 0.3321 vs. 0.3289.
• Sarcasm Detection (MMSD 2.0, GPT-4o, 0-shot): CARGO-T improves accuracy by 2.93% and F1 by 0.83% over best baseline (CoT).
• In-context learning shows diminishing returns with more shots (e.g., GPT-4o improvement over CoT: 11.66% at 0-shot, 10.14% at 2-shot, 5.86% at 5-shot).
• Mutual-information analysis: CARGO-T's reasoning component has higher/equal KL-divergence and Low-Similarity-Fraction (more novel lexical/semantic content) than CoT, CoD, CCoT, and the highest INFERSCORE (45.11 vs. 37.64–40.78 for baselines), indicating its reasoning better supports the ground-truth answer.

Why it matters / caveats: Suggests explicit causal graph structuring (rather than free-form or scene-graph reasoning) is a more effective inductive bias for social/humor reasoning tasks; however, zero-shot use depends on the VLM's code-generation ability, and gains diminish with larger in-context example counts and stronger backbone models.

Problem: As LLM-agent skill libraries grow, retrieval must expose relevant procedural context (prerequisites, verification, recovery steps), but existing graph-based skill retrieval propagates relevance over edges (from semantic similarity, co-occurrence, or loose interface compatibility) that are often plausible associations rather than reliable operational dependencies.

Method: CaSKG builds a high-recall directed candidate skill graph from semantic, lexical, input/output, and structural evidence (plus repair evidence and an optional LLM judge), then applies three direction-conditioned textual counterfactual probes to a budgeted subset of edges — removal (necessity), substitution (specificity), and reordering (directionality) — aggregating probe outputs via Beta-smoothed Bayesian calibration into a reliability score. Edges are then assigned publication states (confirmed/uncertain/rejected/unvalidated-scaffold) to produce a frozen, state-filtered weighted graph, over which task queries are expanded at inference time via personalized PageRank-style propagation.

Key results:

• Across six LLM backbones (MiniMax-M2.7, GLM-5.2, Kimi-K2.6, Qwen3.5-397B-A17B, DeepSeek-V4-Flash, GPT-5.6-Luna) and two benchmarks (ALFWorld ID-140, ScienceWorld U211), CaSKG achieves the highest task score in all 12 model/benchmark combinations.
• Relative to Graph-of-Skills (GoS) baseline, six-model macro-average ScienceWorld score rises from 72.62 to 80.50; ALFWorld success rises from 80.01% to 86.79%.
• Largest ScienceWorld gains: +12.48 points (MiniMax-M2.7) and +9.95 points (DeepSeek-V4-Flash) over GoS; smallest positive gain +1.25 points (GPT-5.6-Luna).
• Largest ALFWorld gain: +9.97 percentage points over GoS for MiniMax-M2.7 (and >27 points over non-graph baselines).
• CaSKG also uses fewer mean environment steps than GoS in all 12 settings (e.g., ScienceWorld six-model mean 15.29 steps vs. 16.39 for GoS; ALFWorld 14.05 vs. 15.96).
• On ScienceWorld task-type breakdown (24 types), CaSKG improves over GoS on 21 types, ties on 1, trails on 2 (non-living-thing search, temperature measurement).
• Component ablation shows the candidate graph has 9,937 edges; removing the LLM judge, semantic-only signals, or publishing all candidates unvalidated degrades performance (partial table shown, full detail not captured).

Why it matters / caveats: Demonstrates that calibrating edge reliability with counterfactual probing — rather than just building bigger or denser graphs — is what drives better procedural retrieval; the construction is offline and does not change the downstream agent policy. The paper notes trace co-occurrence and existing-relation channels remain unused "extension points" in this static setting, and some model names (e.g., GPT-5.6-Luna, Qwen3.5-397B) suggest synthetic/future-dated benchmarking that should be treated with caution.

Problem: It is unclear for which multimodal reasoning tasks an image-edited visual intermediate (produced by an instruction-based image editor within an MLLM→editor→MLLM pipeline) actually helps, since a visually plausible edit may still fail to realize the exact count, relation, symbol, or counterfactual state a task requires.

Method: Aphanta is an automated task-discovery and closed-loop diagnostic framework that evaluates three conditions per task — (A) direct reasoning, (B) reasoning with an actual editor-generated intermediate, (C) reasoning with an idealized programmatically-constructed reference intermediate — computing Δedit = SB−SA (practical utility) and Δref = SC−SA (visual headroom). A four-phase agent pipeline (proposal/screening, preliminary A/B/C diagnosis, data construction, training/evaluation) discovers and curates 20 candidate tasks (Aphanta Train/Test) spanning grounding, cue injection, counterfactual state realization, and structured extrapolation, with human quality review at each phase.

Key results:

• Of 20 candidate tasks, 4 were stopped early (e.g., limited headroom), 16 proceeded, and 13 yielded a positive retained editor pipeline; 2 (Plane Geometry Auxiliary Line, Flowchart Decision) did not provide reliable final-stage assistance.
• Counterfactual state realization tasks (clock editing, object deletion, masked-state completion) improved downstream score by 0.21–0.37.
• Macro-average by operation type: state realization mean task score rises from 0.283 (direct) to 0.580 (edit) — an edit delta of +0.297; grounding rises 0.673→0.773 (+0.100); cue injection 0.195→0.365 (+0.170); structured tasks show a negative edit delta (-0.069) despite positive reference headroom (+0.083).
• On the consolidated Qwen3-VL + Qwen-Image-Edit pipeline over the selected positive-task subset, mean task score improves from 0.343 (direct) to 0.445 (edit) — +10.2 points, +29.7% relative — with reference score 0.558 indicating remaining headroom.
• Across model/editor combinations, holding Qwen3-VL fixed and swapping only the editor yields deltas ranging from −4.7 to +10.2 points; the GPT-5 + GPT-Image-1.5 pairing shows a negative delta (-5.0) on this subset, while Seed-2.0+Seedream-4.5 (+3.5) and Gemini-3+Nano Banana 2 (+4.5) are smaller positives.

Why it matters / caveats: Positions image editing as a task-conditioned "specialized visual workspace" rather than a universal reasoning aid — useful for cue injection, grounding, and counterfactual realization, but unreliable for symbol-sensitive or structurally exact tasks (circuits, geometry constructions, flowcharts). The authors caveat that the A/B/C protocol establishes pipeline-level utility, not proof that the returned pixels are causally responsible for the gain (since condition B also adds an extra reasoning turn and edit instruction text), and that task selection after Phase-2 screening can inflate reported gains on the retained subset.

Problem: Existing video-editing methods cannot be applied to human-centric live streaming because they introduce facial-expression inconsistencies (from training on synthetically-generated video pairs) and rely on multi-step offline, bidirectional-attention inference that is too slow for real-time interaction.

Method: EditaLive builds on Wan-Animate, a pretrained image-animation model that decouples appearance from motion, and repurposes it for instruction-based editing via reference-frame editing plus video reconstruction, trained on a newly collected CharEdit-50K dataset (forward/reverse instructions synthesized via GPT-5.5, Qwen-Image-Edit, and Nano Banana 2). The model is then adapted from offline bidirectional to chunk-wise causal streaming generation, and finally compressed via an "aligned self-rollout distillation" strategy (building on Self Forcing) into a two-step sampler, using three novel components: Align Forcing (decouples gradient updates from rollout termination to match training and inference KV-cache construction), Fixed RoPE (assigns positions by role rather than absolute timestamp to avoid positional extrapolation), and First-frame Preserved Sparse Attention (FPSA, keeps first-frame tokens visible to anchor appearance and reduce drift).

Key results:

• On CharEdit-Bench-S, EditaLive ranks first or second across all eight quality metrics (ID-SIM, AED, APD, TA, EQ, BC, SR, Pick Score) against bidirectional baselines (LucyEdit, UniVideo, Ditto) and streaming baselines (LiveEdit, SANA-Streaming, StreamDiffusionV2).
• Achieves 14.47 FPS end-to-end throughput and 0.829s inter-chunk latency on a single H100 GPU, with edit success rate (SR) of 0.720 vs. at most 0.428 for dedicated streaming baselines.
• 4.7× higher throughput and 31.7× lower latency than LucyEdit (fastest bidirectional baseline); 11.4× faster and 76.7× lower latency than a cascaded Qwen-Image-Edit + Wan-Animate baseline.
• Swapping in Flash-VAED decoder increases speed further to 16.4 FPS.
• Ablations on CharEdit-Bench-L: removing Align Forcing drops ID-SIM from 0.492 to 0.252 and SR from 0.817 to 0.367 (largest degradation); removing Fixed RoPE drops ID-SIM to 0.381; removing FPSA drops ID-SIM to 0.455 (0.466 without first-frame preservation specifically).

Why it matters / caveats: Demonstrates a practical path to real-time, identity/expression-preserving instruction-based character video editing for live streaming by exploiting appearance-motion decoupling rather than general video-to-video editing. Results are reported by the authors' own CharEdit-Bench and rely on proprietary/dated models (e.g., GPT-5.5) for dataset construction, so generalization beyond the constructed benchmark is not independently verified in the excerpted text.