AI papers — 2026-09-24

Problem: There is no unified benchmark for evaluating whether world models (video, spatial, and embodied) remain reliable — consistent and responsive — under exploration, interaction, and modification, rather than just visually plausible.

Method: The authors define a six-level capability hierarchy (W1 Perceptual through W6 Universal World) and build HappyWorld-Bench with three independent evaluation tracks — video world models, spatial world models, and embodied world models — comprising 1,138 video prompts, 300 spatial scenes, and 254 embodied test cases. They run HappyWorld-Arena for blind pairwise human A/B comparisons converted into per-model Arena Elo ratings, complemented by automated metrics computed per W-level (perception, causality/interaction, persistence, rule programmability, etc.).

Key results:

• Video world model track: HappyOyster tops Arena Elo at 1263 (Genie 3 second at 1206); HappyOyster leads W2 (78.0) and W3 (76.8), Genie 3 leads W1 (82.8).
• Spatial world model track: best placement accuracy is 70.14% and best edit execution is 73.33%; Marble leads capability-adjusted Arena Elo (1308) but FlashWorld/Lyra variants score only 0.00–1.36 on W2 despite renderable scenes.
• Embodied world model track (8 models, Arena ELO from 62,592 blind pairwise votes): MiniMax-H3 ranks first (Elo 1060, W2 93.60, W3 91.42, W4 88.62); Sora 2 and Cosmos 3 stay below 75 overall capability at all three levels.

Why it matters / caveats: The results show visual quality and interactive/persistent reliability are dissociated (e.g., high-fidelity generators still fail at causal/state consistency), arguing that world-model evaluation must move beyond frame quality to state consistency and action/intervention correctness. The video and embodied ELOs derive from human raters and may reflect subjective preference rather than pure capability.

Problem: Autoregressive video generators must operate under bounded context windows, causing critical historical information (entity identities, spatial layouts, dynamic states, causal changes from interventions) to be lost as sequences grow — a survey is needed to organize the fragmented literature on memory mechanisms addressing this.

Method: This is a survey (not an empirical paper). It formulates memory operationally as persistent historical information maintained across autoregressive steps that can influence generation after the originating evidence leaves the active context, and organizes prior work along five axes: Forms (representational carriers of history, e.g., pixel-space/VAE-space visual memory, attention-cache states, recurrent/state-space states, explicit entity/spatial states, adaptive parametric memory), Functions (identity, spatial, dynamic, semantic, causal preservation), Operations (writing, reading, updating, managing, integrating memory), Learning (objectives and rollout distributions such as teacher forcing, history augmentation, self-rollout), and Evaluation (benchmark landscape and validity controls).

Key results:

• Not stated (survey paper; no original experiments or benchmark numbers reported).
• The taxonomy spans 9 major sections and cites hundreds of prior works (reference list runs well past 300 entries) organized under the five-perspective framework.

Why it matters / caveats: The paper's central argument is that memory capacity alone is insufficient — retained states must be accurate, accessible, and causally influential on later generation — and it identifies open challenges (composable/resource-aware memory architectures, trustworthy state updating, self-rollout learning, standardized evaluation) as future directions. As a survey, it offers no new quantitative results of its own; value lies in the organizing framework and literature coverage.

Problem: Existing VLM spatial training relies on static QA about object attributes/relations, giving little supervision for how spatial states transition and accumulate over interaction, leaving VLMs unable to track state across long trajectories.

Method: Spatial-Interactor trains VLMs via a three-level curriculum — L1 passive world-state transitions, L2 active self-state transitions, L3 long-horizon interaction trajectories — using a newly constructed LSI-108K dataset (107,518 QA pairs) built from simulated interaction trajectories and real-world videos (camera poses, object tracks, robot trajectories). Training is two-stage: Supervised Fine-Tuning (SFT) on L1/L2 for local transition modeling, followed by On-Policy Distillation (OPD) under the GRPO framework, where a frozen strong VLM provides segment-level transition descriptions as a privileged teacher trace that supervises the student's on-policy chain-of-thought for long-horizon integration.

Key results:

• Overall accuracy improves by 16.4–25.0 points over Base models across four backbones and benchmarks (VSI-Bench, MindCube, VSTI-Bench, SPBench-MV); the 8B variant reaches the best Overall score of 65.9.
• Cross-benchmark generalization (MMSI, ViewSpatial, SAT-Real, SAT-Syn, unseen during training): Overall improves 4.3–10.6 points, with OPD adding a further 1.0–1.4 points over the SFT checkpoint per backbone.
• Ablation on Qwen2.5-VL-7B: SFT on external spatial mixture alone raises Overall from 35.1 to 56.0; adding L1/L2 interaction data raises it to 58.4; standard GRPO reaches 59.2 vs. OPD's 60.1.
• Diagnostic: shuffling video frames drops Qwen2.5-VL-3B/7B accuracy by only 0.8–0.9 points, showing baseline order-invariance; GPT-5.5 accuracy drops from 88.7 (local task) to 23.9 (long-horizon camera-displacement task), recovering to 35.5 with explicit transition traces.

Why it matters / caveats: Demonstrates that direct interaction-trajectory supervision (rather than static spatial QA) meaningfully improves both local state-transition modeling and long-horizon spatial integration, with consistent gains across model families/scales. Reported gains are relative to the paper's own Base models; comparisons to other named systems (e.g., SpatialLadder, GPT-5.5) use differing architectures/training data, so those cross-system comparisons are a "broader reference" rather than controlled comparisons per the authors' own caveat.

Problem: General-purpose LLM memory systems lose speaker/group relations and fail to integrate evidence distributed across members, groups, and time in multi-party dialogue, creating two bottlenecks: message attribution/relational understanding and state reconstruction from interleaved histories.

Method: SpeakerMem-R1 is a dual-track memory system storing speaker-labeled verbatim messages alongside derived states organized into person-level and group-level views; at query time an Anchor–Separate–Resolve–Compose procedure retrieves and organizes evidence by participant, event, and time. A locally deployable Writer (Qwen2.5-3B, "Writer-R1") is trained with a SpeakerLevenshtein reward (combining token-level F1 with normalized sequence/owner-decomposed matching) and speaker-conditioned GRPO to reduce attribution and update errors, with the query/answer modules frozen during this RL stage.

Key results:

• Binary accuracy on GroupMemBench, SocialMemBench, EverMemBench: 47.9%, 69.2%, 61.9% respectively — 3.3, 12.4, and 9.4 percentage points above the best mainstream framework results on each benchmark.
• Achieves 62.33% on the publicly reported EverMemBench leaderboard (EverMind-AI), the best reported result among latest state-of-the-art frameworks; 70.85% on all 1,986 LoCoMo questions.
• In a controlled 305-question evaluation, RL raises the SFT Writer's mean accuracy from 57.38% to 68.20% under a frozen query/answer pipeline — 10.82 points above SFT and within 3.28 points of a 71.48% LLM-writer reference (95.4% of that reference's accuracy).

Why it matters / caveats: Shows that structuring multi-party memory into dual (verbatim + structured, person/group) tracks combined with a targeted RL objective for attribution/update accuracy substantially closes the gap to larger LLM-based writers while remaining locally deployable (3B model). Ablations reported by the authors confirm both tracks and both structured views are complementary, though the training/eval pipeline is specific to the three benchmarks and LoCoMo used.

Problem: Existing video reward models map videos directly to a single scalar score without explicit evaluation criteria, causing "scalar drift" — score-range collapse or shifts across prompts/contexts — that makes the reward unreliable for RL-based video generation training.

Method: RewardVerse inserts a dynamic rubric as an intermediate representation between the evaluation query and the scorer: a rubric generator first decomposes the query into explicit themes, weights, and scoring tips, then a scorer (with soft-logits readout) evaluates the video against these rubrics and aggregates per-theme scores. Training uses Rubric-Guided Policy Optimization (RGPO), a two-stage GRPO-based algorithm: Stage 1 warms up the scorer with self-evolving seed rubrics synthesized offline, and Stage 2 jointly optimizes the rubric generator for query-adaptive criteria while continuing to align the scorer with human ratings, using only 30 preference pairs per dimension and no prior SFT.

Key results:

• On the 16-dimensional EvalVerse benchmark, RewardVerse achieves the highest PLCC in 14 of 16 dimensions, e.g., Logic PLCC of 0.750 (vs. next-best 0.593) and Action PLCC of 0.566 (vs. 0.390).
• On the external VGRB pairwise benchmark, RewardVerse scores best among non-oracle baselines: Visual Quality (seen) accuracy-with-tie 0.545 / without-tie 0.660; Text Alignment (unseen) 0.471 / 0.623 — above VisionReward, UnifiedReward-Thinking, VideoScore2, and VideoScore-v1.1, though below the oracle upper bound VideoReward (0.596/0.756).
• Ablations (macro-averaged over EvalVerse, full RGPO PLCC=0.530/SRCC=0.416): removing Stage-1 warm-up drops PLCC by 0.099 and SRCC by 0.061; skipping Stage-2 joint optimization drops PLCC by 0.074; replacing hierarchical tips with a flat rubric also reduces performance (PLCC 0.497).

Why it matters / caveats: By anchoring scoring to explicit, query-adaptive rubrics rather than unconstrained scalar prediction, the method mitigates scalar drift and remains highly data-efficient (30 preference pairs/dimension), which the authors argue makes it a more stable, interpretable reward for downstream RL-based video generation optimization. Some individual dimension correlations remain low or negative for competing methods (e.g., VideoScore-v1.1's PLCC of −0.245 on Logic), and RewardVerse itself still trails the oracle (in-domain-trained) VideoReward baseline on VGRB.

Problem: Existing LLM-agent memory systems curate experience into fixed artifacts at write time (before the future task is known), which irreversibly discards information and forces a single artifact to serve many unknown downstream queries.

Method: JitMem keeps a memory bank of raw, unabstracted trajectories and defers curation to read time: a BM25 retriever fetches the top-k relevant past trajectories for the current task, and a trainable memory curator (initialized from Qwen3-8B) synthesizes a task-conditioned payload from them, which is injected into a frozen executor LLM's context. The curator is trained with GRPO using the executor's immediate task-success reward as signal (no value network), so credit assignment collapses to a single step; a fixed training bank of successful base-executor trajectories is used during training, and an LLM-as-judge gates which trajectories enter the bank at deployment.

Key results:

• JitMem outperforms the strongest baseline by 16.2 absolute success-rate (SR) points on ALFWorld, 16.3 on WebShop, and 3.9 on τ²-bench.
• Even the untrained curator is competitive: untrained JitMem-gemini reaches 61.0 SR on WebShop vs. 41.0 for SkillOS (both using Gemini-2.5-Pro).
• With Qwen3-8B as executor/curator, JitMem-base reaches 60.5 SR vs. 55.7 for ReasoningBank on ALFWorld, and 77.4 vs. lower SkillOS numbers on the same base model.
• The curator, trained once with Qwen3-8B, transfers to stronger executors, closing to within 1.4 SR points of in-domain performance on ALFWorld.
• Compact payloads reduce input tokens by 50.3%–56.3% and executor steps by 28.4%–31.4% relative to write-time methods.

Why it matters / caveats: The approach reframes agentic memory as reconstructive rather than write-time distillation, simplifying RL credit assignment to an immediate, single-step signal; results rely on benchmark-specific reward functions (ALFWorld/τ²-bench binary, WebShop continuous) and a curated training bank built from ground-truth labels, which may not directly transfer to open-ended deployment settings without a labeled task stream.

Problem: Token-level credit assignment in RL post-training of LLMs lacks a generally accepted mathematical definition, leaving its relationship to training signals used by algorithms like GRPO, PPO, and GAE unclear.

Method: The paper proves a uniqueness theorem showing token-level credit is fully determined by three regularity conditions (Completeness, Prefix Consistency, Neutrality), and uses this to analyze On-Policy Distillation, RLOO, and GAE. Building on this analysis, it proposes Policy Aligned Critic Training (PACT), an actor-critic recipe that uses an Actor-then-Critic update order (critic trained after the actor update, using importance-sampling correction so the critic targets the updated policy) and replaces the standard MSE critic loss with Binary Cross-Entropy (BCE). Experiments train Qwen3.5-4B on a DAPO-Math-17k subset (3,200 problems) via the OpenCode harness for math, and Qwen3.6-35B-A3B on OpenSWE via a Codex agent through Harbor for coding, using the Dressage/slime RL framework.

Key results:

• On four math reasoning benchmarks (AIME 2025, AIME 2026, HMMT Nov. 2025, BeyondAIME), PACT reaches 72.87% average Avg@16 accuracy, beating GRPO by 8.80 and PPO (λ=1.0) by 13.16 percentage points.
• On SWE-bench Verified with Qwen3.6-35B-A3B, PACT achieves 67.4% pass@1, outperforming GRPO by 2.0, PPO by 2.4, and SAO by 3.8 percentage points.
• Ablation: removing the importance-sampling correction (PACT w/o IS) drops average math accuracy from 72.87% to 67.74%, a 5.13-point gain attributable to that component.
• PPO with λ=1.0 outperforms λ=0.95, which the authors attribute to policy collapse from intermediate critic errors in GAE.

Why it matters / caveats: Provides a theoretical grounding (unique credit representation) that unifies explanations for why RLOO and OPD work despite coarse granularity, and translates that theory into a concrete, empirically validated actor-critic training recipe; gains are demonstrated on specific model scales (4B and 35B-A3B) and two task domains, so generalization to other scales/domains is not directly shown.

Problem: Static, popular repository representations used in benchmarks like SWE-bench Verified may let coding agents succeed via memorized repository-specific cues rather than genuine repository-level reasoning, making reported performance ambiguous.

Method: The authors build SchrodingerRepo, an evaluation framework that treats the test repository as a latent variable instantiated only at evaluation time via four seeded, invertible transformation levels: Level 1 reconstructs the problem statement, Level 2 remaps repository-owned namespaces/identifiers, Level 3 reorders intra-file layout, and Level 4 rewrites local implementations while preserving functionality and executability; patches are translated back to original repository coordinates for standard scoring. They evaluate GPT-5.4-mini, GPT-5.1, DeepSeek-v4-Flash, and Gemini-3.1-Flash-Lite on SWE-bench Verified, the March 2026 SWE-rebench Leaderboard split, and SWE-QA, plus a human-judged memorization probe that reveals problem-statement units round by round.

Key results:

• In the human-judged motivation experiment, more than 65% of SWE-bench Verified instances show clear data-leakage evidence per model, and more than 18% can be recalled at the patch/test level.
• The full SchrodingerRepo transformation reduces Pass@1 by 6.0–14.4 percentage points across evaluated models on SWE-bench Verified, with Namespace Mapping (Level 2) causing the largest drop (6.0–7.4 points for GPT-5.1, GPT-5.4-mini, DeepSeek-v4-Flash).
• 81.6–83.6% of the additional actions triggered by transformation are spent on exploration/localization rather than editing or validation.
• On temporally held-out SWE-rebench instances, Pass@1 stays unchanged (17.27% for GPT-5.4-mini) under transformation while actions increase by 8.15% and input tokens by 22.01%, indicating the effect is about interaction process, not intrinsic task difficulty.
• On SWE-QA, transformed views reduce answer quality by up to 4.64 points (GPT-5.4-mini: 70.35 → 65.71) while increasing actions by 18.15–43.02%.

Why it matters / caveats: Provides direct evidence that a meaningful share of reported SWE-bench performance reflects familiarity with canonical repository surface cues rather than pure reasoning, arguing for dynamically instantiated evaluation. The study is limited to Python, open-source repositories and command-line-based agent interaction; generalization to other languages/ecosystems or IDE-tool-equipped agents is untested.

Problem: Post-training transformer compression via matrix factorization typically treats layers independently or uses heuristic adjacency-based grouping (e.g., Basis Sharing) that distorts layer-specific activation geometry and ignores non-local cross-layer redundancy.

Method: GeoPair is a training-free, three-stage pipeline: (1) a shape-agnostic column-space alignment metric measures structural compatibility between layers; (2) layer pairing is solved as a global maximum-weight matching problem via Edmonds' Blossom algorithm instead of fixed adjacency; (3) for matched layer pairs, a shared dictionary is computed in closed form by solving a generalized Sylvester equation (respecting each layer's distinct whitening/calibration geometry) rather than averaging covariances, and coefficient sparsity is enforced via Hard Thresholding Pursuit (HTP) with a conjugate-gradient linear solver.

Key results:

• On Llama3.2 1B and Llama3 8B ablations at compression ratio 0.2, the full pipeline (Sylvester + Optimal Grouping + HTP) recovers average accuracy to 54.09 (1B) and 68.17 (8B), compared to Basis Sharing's 33.11 (1B) and 53.47 (8B) — over 90% of uncompressed baseline accuracy (57.61 and 70.36, respectively).
• GeoPair achieves the highest average accuracy and lowest log-perplexity across compression ratios 0.2–0.4 on Llama3 8B versus Basis Sharing, SVDLLM, CoSpaDI, ROCKET, and COMPOT.
• GeoPair matches or beats compression/pruning baselines on Llama2 7B without any post-compression fine-tuning, unlike competing methods that require healing/recovery training.
• Ablation on the coefficient sparsity (KS) ratio identifies KS=2.5 as optimal, balancing perplexity (34.26 on WikiText-2 vs. 48.51 at KS=2.0) and accuracy (45.6 vs. 43.5).

Why it matters / caveats: Demonstrates that a training-free, optimization-driven cross-layer compression method can match or exceed methods that require fine-tuning, reducing compute cost for deployment. A stated limitation is that the exact closed-form Sylvester solver only generalizes to pairwise (m=2) layer grouping; extending to larger groups would require iterative approximations not yet developed.

Problem: Existing robotic bin-packing methods rely on hand-crafted heuristics or RL policies trained under fixed object/container distributions, and prior MLLM-based approaches only infer object properties for a separate conventional planner rather than directly performing closed-loop object selection and placement.

Method: PackLab has three components: PackLab-Suite, a physics-grounded simulator with a layout-first data generation engine (partitions container space into stacked layers/regions, reconstructs a forward packing trajectory by reversing an object-removal process, validates trajectories under gravity/rigid-body/stability physics) that produces the PackData-20K dataset (20K trajectories); PackLab-VLM, a packing-specialized MLLM (built on a Qwen3.5-9B-scale backbone) that autoregressively encodes container heightmaps, candidate-object attributes, and observation-action history to jointly predict object selection, orientation, and (x,y) placement at each step, trained via supervised fine-tuning with token-level negative log-likelihood on PackData-20K; and PackLab-Bench, a standardized evaluation suite (60 test cases, 905 packing steps) with easy/medium/hard difficulty tiers scored on Success Ratio, Compactness, and their product, Overall Score.

Key results:

• PackLab-VLM achieves average Overall Score 0.660 (Success Ratio 0.882, Compactness 0.718), outperforming the strongest heuristic baseline SDF-Pack by 0.059 and the strongest RL checkpoint TAP-Net by 0.186.
• RL baselines TAP-Net and IR-BPP achieve average Overall Scores of only 0.405 and 0.345 respectively.
• Training effect: PackLab-VLM's average Overall Score rises from 0.209 (zero-shot backbone) to 0.660 after packing-specific fine-tuning, with Easy going from 0.246 to 0.922, Medium from 0.220 to 0.665, and Hard from 0.162 to 0.394.
• Ablating visual input (replacing the heightmap with a black image) drops Overall Score from 0.660 to 0.494.
• In a real-world robotic packing demonstration, PackLab-VLM achieved 1.00 Success Ratio and 0.72 Compactness on the showcased case.

Why it matters / caveats: Shows an MLLM can be trained to directly perform closed-loop, long-horizon bin-packing decisions end-to-end, outperforming both heuristics and RL policies across heterogeneous configurations, and validates transfer to a physical robot. On the hardest difficulty tier, PackLab-VLM's Success Ratio (0.680) is not the best among compared methods, and heuristic SDF-Pack remains competitive there (0.719), indicating room for improvement on high-complexity scenes.

Problem: Most vision-language-action (VLA) policies condition only on the current observation and instruction, so they fail on history-dependent manipulation tasks where the correct action depends on information no longer visible, while naively keeping past observations in context makes inference cost grow with episode length.

Method: MemBodied augments a VLA backbone (π0 or π0.5) with a fixed-size episodic memory made of two pathways: an associative state, one key-value matrix per action-network layer, updated after every policy call with a gated delta rule (Yang et al., 2025) using a write value built from the executed action and its observed visual consequence; and an episode anchor, a persistent compact encoding of the initial-scene observation. At each policy call, information read from both pathways is injected (via memory-token readout) to condition action generation instead of using raw past observations. Training uses sequence training over episodes with a causal read/write schedule; RMBench and LIBERO backbones were adapted with LoRA (rank 16).

Key results:

• On five memory-dependent RMBench tasks, MemBodied reaches 50.0% mean success rate, 7.81x a stateless π0 policy and 2.98x vanilla recurrent memory, and 1.3x the strongest memory-augmented baseline (NativeMEM) while using ~10x fewer added parameters (40M vs. NativeMEM's 415M).
• With the π0.5 backbone, MemBodied achieves 48.0% mean success vs. 12.4% for the stateless baseline (e.g., Rearrange Blocks improves from 13.0% to 94.0%).
• On three real-robot tasks, mean success rises from 3.33% to 26.67% (8.0x); inference latency is 91.9% lower and peak GPU memory 9.5% lower than NativeMEM.
• On fully-observable LIBERO, MemBodied reaches 95.1% mean success (vs. π0's 94.2%), with the largest gain on LIBERO-Long: 90.6% vs. π0's 85.2% (+5.4 points).

Why it matters / caveats: The approach offers a practical, low-overhead alternative to context expansion for giving VLA policies working memory, but gains are concentrated in memory-dependent and long-horizon settings; on some fully-observable LIBERO suites (Spatial, Object) it slightly underperforms the stateless baseline.

Problem: There is no standard way to measure whether AI research agents accurately learn, from a limited budget of experiments, how changing individual components of a computational workflow (and combinations thereof) actually affects outcomes.

Method: WhatWorkedBench has agents inspect workflow code, choose configurations to measure under a budget, and submit a complete predicted response surface (a table of scores for every configuration of component settings); exhaustive CPU execution of every legal configuration supplies ground-truth conditional effects for comparison. The benchmark spans 36 tasks across 30 data sources and 8 workflow types (1,248 configuration records), and evaluates both the agent's own submitted predictions and shared estimators (a pair-effect ridge regression and a Gaussian process fit to the same agent-chosen observations) applied post hoc to separate measurement-policy quality from numerical-inference quality.

Key results:

• Across 4,206 numerical-control records and 108 agent episodes, pair-effect ridge selects the optimal configuration on 15 of 22 sources (at 8 new measurements) and keeps every effect error under 10% of score range on 3 sources.
• Fitting a shared Gaussian process to the same agent observations raises effect-recovery accuracy from 0.632 to 0.698 (original Flash cohort) and from 0.621 to 0.720 (additional cohort).
• On six completed beat-detection/graph submissions, shared-GP raises family-macro recovery from 0.303 to 0.455.
• Encoding code equivalences (configurations with identical behavior) for six-factor workflows at 20 measurements raises GP recovery from 0.248 to 0.462.

Why it matters / caveats: The results show agents can often pick a near-optimal configuration while still holding substantially wrong beliefs about individual component effects, i.e., correct decisions can mask poor causal/quantitative understanding — a distinction future "experimental" agents should be evaluated on, not just final-answer accuracy.

Problem: Deploying frontier-capability large language models typically requires heavy compute and high inference latency, limiting broad accessibility.

Method: Hunyuan-A13B is a fine-grained Mixture-of-Experts LLM with 80B total parameters and 13B activated per token (1 shared expert always active plus 8 of 64 non-shared fine-grained experts), using Grouped-Query Attention and a 128K vocabulary, pretrained on a 20T-token corpus (including 250B tokens of curated STEM data) with a fast-annealing stage and a long-context stage extending the window to 256K. Post-training combines supervised fine-tuning (including long-CoT reasoning data) with large-scale reinforcement learning, plus a dual-mode Chain-of-Thought scheme offering a fast-thinking mode and a slow-thinking mode selectable by the user; inference is optimized with quantization (INT8, W8A8, KV-cache FP8) and serving features like Auto Prefix Caching, Chunk Prefill, and FusedMoE.

Key results:

• In slow-thinking mode, Hunyuan-A13B scores 87.3 on AIME2024 (vs. 85.7 for Qwen3-A22B and 79.8 for DeepSeek-R1), 89.1 on BBH, and leads agent benchmarks with 78.3 on BFCL v3 and 63.5 on C3-Bench.
• In fast-thinking mode it reaches 74.0 on ComplexFuncBench (vs. 38.1 for Qwen3-A22B) and 65.4 on C3-Bench (vs. 48.4 for Qwen3-A22B).
• Throughput reaches 1,981.99 tokens/s at batch size 32 (2048 input / 14336 output tokens) under A16W16C16 precision.
• On long-context benchmarks it reaches 87.7 on PenguinScrolls and 55.0 on LongBench-v2, comparable to much larger dense/MoE models like Gemini 2.5 Pro and DeepSeek R1.

Why it matters / caveats: With only 13B active parameters, the model claims performance competitive with or exceeding substantially larger open models (e.g., Qwen3-A22B at ~22B active), particularly in agentic tool-use settings, at markedly lower inference cost; some individual metrics (e.g., LiveCodeBench, GPQA-Diamond) still trail larger competitors.

Problem: In joint multimodal diffusion transformers (e.g., video generated together with motion or audio), the companion modality learns a strong cross-attention correspondence to video, but the reciprocal video-to-companion-modality attention pathway remains much weaker, so the companion modality fails to meaningfully constrain the generated video despite architecturally bidirectional attention.

Method: The paper defines a reciprocal correspondence gap between the two attention directions (video→modality vs. modality→video, re-normalized to be comparable) as a KL divergence, and introduces RecCAR (Reciprocal Cross-modal Attention Regularization): a stop-gradient KL loss that treats the stronger, well-established video→modality correspondence as a fixed target and trains the weaker modality→video pathway to match it, added to the standard denoising/flow-matching loss with weight λRecCAR. Only lightweight LoRA parameters (rank 128) on the relevant attention projections are fine-tuned, keeping the pretrained backbone frozen; it is applied to EchoMotion for video-motion generation and to LTX-2/JavisDiT++ for video-audio generation.

Key results:

• On video-motion generation (VBench, 1,000-prompt test set), EchoMotion + RecCAR improves Human Anatomy from 0.69 to 0.75 while maintaining comparable Dynamic Degree (0.83) and improving other VBench metrics (e.g., Background Consistency 0.9346 → 0.9406).
• Standard fine-tuning on the same data does not reproduce these gains (per the ablation).
• On T2AV-Compass (500 prompts), applying RecCAR to LTX-2 reduces absolute AV Desync from 0.804 to 0.752 while preserving/improving audio and video quality metrics (e.g., Video Quality Overall 0.72 → 0.72, Tech. 0.115 → 0.124).
• On AVGen-Bench, LTX-2 + RecCAR reduces AV Desync from 0.424 to 0.406.

Why it matters / caveats: RecCAR is modality-agnostic and requires no extra inference-time components or annotations, offering a cheap way to make bidirectional joint generators actually exchange information in both directions; gains on JavisDiT++ for audio-video are smaller and mixed on some sub-metrics (e.g., Speech NISQA score drops slightly for JavisDiT++ + RecCAR).

Problem: Existing pipelines for generating agentic RL training environments typically build the environment first and attach an outcome/reward rule afterward, leaving dynamics and evaluation only loosely aligned, which limits the diversity, reliability, and low-cost extensibility of agentic training environments for long-horizon, stateful tasks.

Method: VHD-Play reverses this order (mechanism-first construction): it samples and solves a mathematical model (e.g., from optimization families such as inventory dynamic programming, knapsack, linear/quadratic programming, routing) before a frozen corpus-grounded LLM setter renders the solved model's decision process as stateful tools, seeded with a real-world document sample; both the executable environment dynamics and the trajectory-scoring reference are derived from the same solved mechanism, with information-asymmetric interfaces (the agent/player sees only interface observations, not the underlying parameters or solution) and automatic admission filtering. Training uses GRPO to optimize groups of rollouts from the same environment instance, applied to a Qwen3.6-35B-A3B policy trained on 3,300 admitted environments across three families.

Key results:

• Training Qwen3.6-35B-A3B on three families raises mean agentic score from 0.204 to 0.815 on a five-family diagnostic, with gains on held-out instances from the trained families as well as eight unseen mechanism families.
• On the 365-day E-Commerce Bench, the trained checkpoint completes all five storefront runs without bankruptcy (vs. the base checkpoint going bankrupt once out of five) and reaches a mean ending balance of 182,844 (3.4x the base's 54,294), exceeding the Qwen3.7-Max reference of 165,224.
• On BFCL V4's ten interaction-focused cells, the unweighted mean rises from 61.25 to 64.08 (+2.84 points); TravelBench plan quality rises from 0.700 to 0.794 (below Qwen3.7-Max's 0.891).
• Comparing written-out vs. stateful problem forms shows most of the learnable performance gap lies in stateful interaction rather than underlying problem-solving (e.g., Knapsack: written-out 0.984→0.996, but parameters-acquired/agentic form 0.117→0.843).

Why it matters / caveats: The pipeline produces diverse, verifiable agentic environments at low cost (a few cents each) and demonstrates transfer beyond the training substrate to external benchmarks, but on TravelBench the trained model still trails the much larger Qwen3.7-Max reference.

Problem: Existing world-action models (WAMs) struggle to couple expensive, long-horizon visual future prediction with fast, closed-loop robot control across heterogeneous embodiments and contact-rich tasks without incurring high inference latency.

Method: InternW0 is a mixture-of-transformers (MoT) architecture with an asymmetric video expert (learns future visual dynamics from a frozen Wan VAE and DINOv3-encoded observations) and a lightweight action expert, jointly trained via video–action flow matching. An observation-conditioned "context routing" layerwise K/V editor (following AHA-WAM's design) lets the action expert reuse cached, slower-updating video context while adapting it to newly observed states ("asynchronous duplex inference"), avoiding full replanning on every action step; contact-aware post-training adds force/tactile signals and 6D wrench prediction. It is pretrained on ~7,200 hours of heterogeneous robot and egocentric data, including a new 275-hour real-laboratory egocentric dataset (EgoLab).

Key results:

• LIBERO (40 tasks, 4 suites): 98.6% average success rate, exceeding LingBot-VA and Fast-WAM baselines by 0.1 and 1.0 percentage points respectively; 99.4% on LIBERO-Spatial.
• RoboTwin 2.0-Full (50 bimanual tasks): 93.12% average success (93.20% clean / 93.04% randomized), within 0.98 points of the best baseline (ABot-M0.5, 94.10%).
• RoboTwin 2.0-Clean2Random (out-of-domain generalization): 75.60% average success, beating the strongest baseline (GigaBrain-0.7, 67.3%) by 8.30 points.
• Real-world tasks (e.g., pipetting) show inference speed of 60.73 ms vs. 190.00 ms (Fast-WAM) and 1866.10 ms (Motus), a reported 3.13× speedup over Fast-WAM.

Why it matters / caveats: The asynchronous decoupling of slow video prediction from fast action generation targets a real deployment bottleneck (latency) rather than just offline accuracy, and the model is evaluated on real scientific workflows (MOF synthesis, quantitative pipetting), not just simulation. Results come from a single lab's benchmarks/baselines self-selected for comparison, so independent replication is Not stated.

Problem: Fine-tuning pretrained visual encoders for better image reconstruction (to preserve fine-grained detail for representation-autoencoder-based diffusion) unexpectedly hurts downstream text-to-image generation quality when using standard velocity (v)-prediction flow matching.

Method: The authors show that reconstruction fine-tuning reduces the effective dimensionality of the encoder's high-dimensional feature space, so v-prediction forces the diffusion model to fit noise directions orthogonal to the low-dimensional signal manifold, hurting optimization. They propose replacing v-prediction with clean-data (x0-prediction) parameterization in flow matching, tested with two representation autoencoder (RAE) tokenizers: a fine-tuned DINOv2-L (with a semantic-preservation loss during reconstruction fine-tuning) and MAE-RAE, evaluated with a Diffusion Transformer trained on ImageNet/BLIP3o-style data.

Key results:

• Fine-tuned DINOv2-L with v-prediction: GenEval 30.96, DPG-Bench 67.47, COCO-30k FID 29.97 (worse than original DINOv2-L: GenEval 37.63, DPG-Bench 70.21, FID 18.34).
• Switching to x0-prediction on fine-tuned DINOv2-L recovers/improves performance: GenEval 39.48, DPG-Bench 71.83, FID 16.80 — beating both the original DINOv2-L and the v-prediction fine-tuned variant on all three metrics.
• MAE-RAE (768-dim): x0-prediction improves GenEval from 36.17 to 40.89, DPG-Bench from 67.54 to 73.90, and FID from 22.20 to 17.24 versus v-prediction.
• A low-dimensional bottleneck baseline (32-dim adapter + v-prediction) gets stronger GenEval/DPG-Bench (40.99/73.04) but worse FID (17.64) than the high-dim x0-prediction approach (FID 16.80), showing x0-prediction preserves fidelity without needing dimensionality reduction.

Why it matters / caveats: Offers a simple, architecture-agnostic fix (swap the prediction target) for a specific failure mode in RAE-based diffusion, letting practitioners use stronger-reconstruction encoders without sacrificing generation quality. Results are at 256×256 resolution primarily, with a larger-scale/higher-resolution scaling experiment mentioned but not detailed here (Not stated further specifics).

Problem: It is unclear whether LLM-based coding agents can autonomously write working control programs for long-horizon, contact-rich, dexterous robotics tasks, and whether their solutions can serve as scalable training supervision for generalist robot policies (VLAs).

Method: The authors build EmbodiedSWE-Bench, an Isaac Lab/Isaac Sim benchmark of 28 long-horizon dexterous tasks (assembly, packing, puzzle, deformable/liquid manipulation, cutting, loco-manipulation) across five embodiments (Franka, xArm7, Kinova Gen3, bimanual Franka, Unitree G1 humanoid), where agents must produce a solve(env) Python program with full simulator-state access. They then introduce EmbodiedSWE-Gen, a hierarchical pipeline that diversifies a single verified coding-agent solution (via scene/strategy/phase/dynamics/visual augmentation) into large demonstration datasets used to finetune SmolVLA and π0.5-DROID policies, including a real-to-sim/sim-to-real pipeline using 3D Gaussian Splatting reconstruction for a real lamp-disassembly task.

Key results:

• Frontier coding agents solve tasks with mean best scores ranging from 11% (GPT-5.6 Terra) to 82% (GPT-6 Astra) success across the benchmark.
• SmolVLA finetuned on EmbodiedSWE-Gen data: mean success rate over six tasks rises from 18% (10 demos/task) to 69% (400 demos/task); mean rubric score rises from 0.32 to 0.76.
• On held-out generalization (out-of-distribution scene/object variations), agent-aided diversified data raises overall rubric score from 0.066±0.008 (script-only baseline) to 0.233±0.016.
• Sim-to-real: a π0.5-DROID policy finetuned solely on 500 coding-agent-generated simulated demonstrations achieves 100% success grasping the lamp shade, 80% placing/releasing it, 30% grasping the bulb, and 20% unscrewing/extracting it (10 real trials), versus 0% at every stage for the pretrained π0.5-DROID baseline.

Why it matters / caveats: Demonstrates a path to bootstrap generalist robot policies from LLM-coding-agent-written solutions rather than costly teleoperation, with actual sim-to-real transfer shown on a multi-stage task. Success rates on the hardest task categories (e.g., deformable-object tasks) reportedly remained at 0% for all evaluated agents/harnesses, and results depend on privileged full-simulator-state access not available on real hardware.

Problem: Vision-Language-Action (VLA) systems for long-horizon manipulation often leave task planning implicit or rely on coarse task-level labels and slow, error-prone token-by-token chain-of-thought reasoning, lacking event-level supervision and low-latency plan representations.

Method: X-Planner is a planning front-end built on a Qwen-series VLM backbone (Qwen3.5) trained on multisource hierarchical data (Ego, UMI, teleoperation) annotated at up to four granularity levels (L3 Task/L2 Subtask/L1 Action/L0 Segment), with takeover-time annotations and human-designed failure demonstrations supervising ongoing error recognition. It exposes two plan forms from a shared backbone: a discrete interface emitting interpretable event states (progress, current/next event, error recognition), and a latent interface using "Staircase Decoding," a depth-parallel Mixture-of-Transformers schedule that relays continuous CoT states across staggered Transformer depths (sharing lower-layer grounding computation, updating upper layers in parallel), regularized by a frozen latent-to-text reconstruction objective.

Key results:

• Offline two-step planning evaluation (BERTScore-F1 / Doubao-Judge Overall): X-Planner scores 0.9011 / 1.411, ranking second of four models — above Qwen (0.8878/1.367) and Doubao (0.8846/1.366) but below kimi3 (0.9108/1.434).
• Real-robot Reasoning Manipulation suite: the X-Planner-conditioned policy achieves the highest average Task Progress among compared systems, 71.60 (0–100 scale).
• Generalization suite: X-Planner achieves average Task Progress of 53.75, versus 28.50 for DreamZero, 24.00 for π0.5, and 18.50 for a U-baseline.

Why it matters / caveats: Frames embodied planning around action-grounded "events" with a latency-reducing latent decoding scheme, and is validated both offline (text quality) and on real robots (downstream task execution) rather than simulation alone. The paper notes it does not report controlled comparisons between its discrete and latent plan forms, leaving that analysis for future work.

Problem: NLP research routinely introduces new LLMs, datasets, and benchmarks reporting only performance metrics (e.g., accuracy, BLEU, F1) without checking whether the models' confidence scores are calibrated, despite calibration methods already existing.

Method: This is a position paper (no new empirical experiments) that reviews existing calibration metrics (Expected Calibration Error, Brier score, AUROC/selective prediction) and confidence signal types (token/sequence probabilities, verbalized confidence, behavioral signals), argues miscalibration harms both deployment (overconfident errors) and the research pipeline (LLM-as-judge, synthetic data generation, active learning all implicitly assume calibrated confidence), and proposes reporting norms: pairing every subfield's primary metric with a calibration score, and treating missing calibration reporting as a methodological gap in review.

Key results:

• The authors reviewed public technical reports/model cards for major model families (GPT-5.5, Claude Sonnet 4.6, Gemini 3.5 Flash, DeepSeek V3.2, Llama 3, Qwen3, Gemma 3, GPT-OSS, OLMo 3) and found none reports calibration, despite reporting results on "dozens" of capability and safety benchmarks (the GPT-4 technical report is cited as an earlier exception).
• Not stated: no quantitative calibration numbers or new experimental results are presented, as this is an argumentative/position piece.

Why it matters / caveats: Highlights a concrete, verifiable gap in current LLM evaluation and reporting practice across nearly all major model releases, and proposes low-cost, immediately actionable fixes for tasks with well-defined correctness criteria; the authors acknowledge calibration for open-ended free-form generation still lacks a consensus definition and remains an open research problem.

Problem: Whisper's encoder has received little effective compression compared to its decoder, and existing encoder-compression approaches require custom inference code that limits real-world adoption.

Method: The authors rank each of the 32 layers in whisper-large-v3-turbo's encoder by the leave-one-layer-out change in Word Error Rate (WER) on the FLEURS test set (Danish, English, German, French), then remove the six least-important layers ([5, 6, 7, 9, 11, 12]) by replacing the encoder's PyTorch nn.ModuleList with a shorter copy — requiring no architectural or inference-code changes. To recover the resulting degradation, they apply label-free knowledge distillation: the pruned encoder (student) is trained with MSE loss against the frozen full encoder's (teacher) hidden states, using unlabeled English-only audio from the People's Speech dataset (AdamW, batch size 8, 2000 steps, ~30 minutes on an A100).

Key results:

• Zero-shot pruning of 6 layers (18.5% of the encoder) raises mean WER across four languages from 18.2% to 21.9%; label-free distillation on English-only audio recovers it to 20.1%.
• Removes 118M encoder parameters, shrinking the full model from 1543MB to 1318MB in bf16 (225MB saved).
• On an Apple M4 Pro, the pruned encoder is 1.22–1.24× faster standalone, giving 1.08× end-to-end speedup at batch size 1 and 1.75× at batch size 8.
• Random selection of 6 layers (n=50 trials) produced WER increases ranging from +5% to +471%, versus +3.8% for the importance-ranked selection, showing informed layer selection is essential; degradation jumps sharply beyond k=6 (a "cliff" at k=7).

Why it matters / caveats: The pruned encoder is a drop-in replacement needing no custom inference stack, unlike prior compression work. Caveats: evaluated on only four languages and one model size (whisper-large-v3-turbo), and distillation used only English audio, leaving open whether multilingual distillation data would improve recovery for the hardest-hit languages (Danish, French).

Problem: It is unclear whether current LLMs, used with minimal scaffolding, can produce human-tutor-equivalent learning gains for real students studying for a high-stakes exam.

Method: The authors built StudentBench, a platform that randomly assigned ~70,000 invited students (2,383 participants after filtering, 2,469 sessions) to AI tutoring, live one-to-one human tutoring, or a no-tutoring video control for one hour on newly authored GRE Quantitative/Verbal questions (created by former ETS/Kaplan question writers to avoid train-test contamination), with counterbalanced pre/post-test forms. Each AI tutor (13 tutors spanning frontier and open-weight models, e.g., GPT-5.5 Pro, Gemini 3.5/3.6/3.7 Flash, Opus 4.8/5, Kimi K2.6, Gemma 4 31B) ran on just two prompts (lesson planning/problem creation, and interactive tutoring), with no post-test access. Equivalence between AI and human learning gains was tested via ANCOVA-adjusted two one-sided tests (TOST) with ±0.25-pooled-SD bounds; a second study had 51 expert GRE tutors complete 2,028 pairwise rubric comparisons of AI-generated lesson plans and practice problems.

Key results:

• Pooled AI tutoring and human tutoring produced statistically equivalent learning gains (p=.015, AI−human difference −0.58 percentage points, 90% CI [−2.18, 1.03]); also equivalent under the stricter ±0.20-SD bound (p=.023).
• One AI tutor achieved learning gains statistically equivalent to the human tutor (p=.044) at 918× lower cost per percentage point gained ($0.0052 for AI vs. $4.81 for human), with a mean inference cost of $0.067 for a full tutoring session.
• AI−control learning-gain difference was 6.86 percentage points in Quantitative (95% CI [4.02, 9.69]) and 5.47 in Verbal ([2.46, 8.47]); overall AI−control gain was 6.15 points ([4.08, 8.21]), roughly 1.5–2 more correct answers out of 27 than control.
• In five of seven GRE domains, the best-performing AI tutor's mean learning gain exceeded the human tutor's; human tutors retained the highest mean in Verbal overall.

Why it matters / caveats: Suggests LLM tutoring, even with minimal prompting/scaffolding, can match expert human tutoring on a standardized-test benchmark at dramatically lower cost, relevant to addressing Bloom's "two-sigma problem" of affordable one-on-one instruction. Caveats: results are for one hour of tutoring on GRE content specifically; equivalence held for Quantitative but was not established for Verbal alone; findings represent current-generation models and the authors note this may be a lower bound as models continue improving.

Problem: Memoryless temperature sampling for LLM test-time scaling produces an increasing share of semantically duplicate completions as more samples are drawn, causing diminishing returns and sample inefficiency, especially at rare "branching points" where the correct token is not the highest-probability one.

Method: FLEET represents each generation as a sparse trajectory through decoding states whose entropy/varentropy exceed calibrated thresholds (τH, τV) at a chosen LogitLens layer, clusters trajectory metadata via a VectorDSU (disjoint-set) mechanism to detect and avoid near-duplicate trajectories, and uses accumulated per-cluster reward/utility statistics with a pUCT-style search (candidate window k, resampling temperature) to adjust logits toward more diverse, higher-utility continuations. All principal hyperparameters (target layer, entropy/varentropy thresholds, k, τdsu, resampling temperature) are set via a single automated calibration pass on a held-out prompt set, and in its evaluated greedy-decoding configuration the method is deterministic. It is evaluated with Pass@32 under both ground-truth verification and Outcome Reward Model (Skywork-Reward-V2) guidance on LiveCodeBench (222 contamination-filtered "easy" tasks) and GSM8K.

Key results:

• Under ground-truth verification, FLEET raises LiveCodeBench Pass@32 from 59.90% to 66.21% (+6.31 points, 14 additional tasks solved out of 222) and GSM8K from 97.27% to 97.80% (+7 additional problems, near-ceiling baseline).
• Under ORM-guided candidate selection, FLEET improves LiveCodeBench from 19.36% (43 problems) to 25.22% (56 problems, +13 tasks), but on GSM8K the baseline slightly outperforms FLEET (85.44% vs. 83.62%) due to reward-ranking errors from the surrogate model.
• The paper reports FLEET achieves "the same accuracy as the repeated sampling baseline, with a 3x speedup" (per abstract), attributed to reduced redundant trajectory exploration via VectorDSU deduplication.

Why it matters / caveats: Offers a training-free, calibration-based way to make sampling-based test-time scaling more sample-efficient, particularly valuable for coding tasks where solution diversity matters. Caveats: gains are modest on GSM8K where baseline accuracy is already near ceiling; the ORM-guided results reveal that surrogate reward models can misrank FLEET's more diverse trajectories, sometimes underperforming the baseline; claimed parallel speedup quantification is noted by the authors as future work.

Problem: Building scalable, general-purpose robot simulators is difficult because real-world robot interaction data is costly to collect and conventional (hand-built) simulators require labor-intensive construction and struggle to generalize across embodiments, cameras, and open-ended horizons.

Method: Uranus is a joint-trajectory-conditioned autoregressive diffusion model (a video diffusion transformer, DiT) that operates in a causal VAE latent space, generating one latent frame (four RGB frames) per autoregressive step conditioned on streamed future joint-position (qpos) trajectories rendered as Plücker/skeleton representations via forward kinematics and MuJoCo/URDF rendering, enabling open-ended rollout across variable robot embodiments and camera counts. It is trained with a teacher-forcing causal mask, latent-frame-relative RoPE, and a reference attention sink on more than 3,300 hours of curated real-world robot data (from AgiBot G1/G2, Agilex, DOS-W1, ARX, UR5, Franka Panda, etc.), then accelerated via distribution matching distillation (DMD) to a 4-step distilled model, plus systems optimizations (sliding-window KV cache, streaming VAE decoding, disaggregated DiT/VAE serving, Flash-VAED decoder) reaching 24 FPS (10 FPS on H20 after distillation, per the abstract/figure).

Key results:

• Released as a 1.3B-parameter model (SFT and distilled checkpoints on Hugging Face); the distilled model runs at 10 FPS on H20 GPUs (24 FPS "after inference optimization" per abstract).
• On the WorldOlympiad long-horizon robotics benchmark, Uranus-1.3B scores 0.925 / 0.511 / 0.304 / 0.730 (individual metrics) with an overall 0.722.
• In a controlled comparison against GE-Sim 2.0 on 100 AgiBotWorld-Beta episodes (same G1 embodiment), during the final 140–160 second interval Uranus achieves ~12.3 PSNR / 0.45 SSIM (head view) versus 7.1 PSNR / 0.20 SSIM for GE-Sim 2.0, and maintains this advantage across all rollout horizons and both single- and multi-view evaluation.
• Unlike compared baselines (Ctrl-World: 15 RGB frames/call, GigaWorld-1: 33, GE-Sim 2.0: 25 — all non-causal, fixed camera view, seen-embodiments-only), Uranus generates causally/autoregressively (4 frames/call from 1 latent), supports variable camera views, and generalizes to embodiments defined only by URDF/MJCF, without appearing in training data.

Why it matters / caveats: Positions itself as a more general, extensible, and temporally stable alternative to fixed-chunk bidirectional robot world models, released open-source with code, SDK, and weights. The authors themselves note limitations: uneven generalization to unseen scenes/trajectories dependent on training-data diversity, substantial computational cost even after distillation, and discrepancies from the causal inference-time KV window not fully resolved by self-forcing distillation.

Problem: Prior addressable-memory systems for language models (e.g., Engram) always feed the model a representation retrieved directly from storage, leaving open whether useful memory could instead be generated, and if so, whether generated memory is uniformly better or must be selectively applied.

Method: MemoryAthena defines three memory pathways over a frozen Mistral-7B-v0.3 backbone (with an Engram-style addressable table injected at layers 2 and 10 via a four-branch reader): direct Engram retrieval (E), generation from retrieved Engram cues (GE), and generation from causal backbone states without consulting memory (GH). With backbone, memory table, generators, and readers all frozen, a lightweight causal routing head (534,924 trainable parameters; ~201M total memory-side parameters excluding backbone) is trained via counterfactual future-token likelihood advantages of GE/GH relative to E under teacher forcing; at inference, an admitted candidate modifies the E residual via bounded interpolation r = e + α(g − e), while rejection exactly recovers the direct E pathway. Cross-backbone transfer is also tested by importing a learned Llama-2-7B source memory, and model/data scaling is studied across GPT-2 Small/Medium/Large/XL backbones.

Key results:

• MemoryAthena raises the five-task QA average from 37.65 (direct E pathway) to 39.28, and the six-task general-NLP average from 76.73 to 79.13, on the same frozen checkpoint.
• A random-router control performs worse than E alone (e.g., 31.67 average, a −1.5% change), confirming the learned routing (not just exposure to generated pathways) drives the gains.
• Gold-label oracles exceed the deployed causal router by 3.04+ points, indicating further complementarity among E, GE, and GH that the router does not yet fully exploit.
• In GPT-2 model scaling, WikiText perplexity for GPT-2 Small improves from 30.841 (bare) to 24.033 (E) to 23.372 (routed); the memory-side system scales from 37.6M parameters (GPT-2 Small) to 472.9M (GPT-2 XL), while E-only inference remains faster at all scales (1.88x at Small down to 1.40x at XL latency advantage).

Why it matters / caveats: Demonstrates that generated memory representations can complement, not replace, retrieval-based memory, provided a router explicitly anchors on the direct pathway — a useful design pattern for memory-augmented LLMs. Caveats: generated memory (especially GH) adds inference-time cost (extra clean backbone forward pass), the router sometimes helps some tasks while leaving others unchanged or slightly worse (e.g., decreases SST2 in cross-backbone transfer), and a gap remains between the deployed router and its oracle upper bound.