Runtime Control Moves Into the Open

Today's Overview

  • WorldTrace Makes Long Video Memory Addressable: It assigns in-distribution virtual positions to compressed memory slots. Two variants improve LoopBench temporal consistency by 15.5% and episodic recall by 19.5%.
  • Modular TTT Makes Test-Time Learning Composable: It represents fast weights, loss functions, and learning rates as a DAG. After training on 100B tokens, its 410M and 1.45B models match Gated DeltaNet.
  • ReASearch Lets One Agent Run the Search: It unifies evaluation, diagnosis, editing, and stopping. It beats specialized systems on most of 14 tasks by 2% to 40%, though its validation discipline needs scrutiny.

Featured

01 WorldTrace Makes Long Video Memory Addressable

Interactive video models can lose old scenes once generation runs beyond the time horizons seen in training. The frames may still be stored, but the model cannot find them. WorldTrace reframes long-term consistency as a memory-addressing problem, not merely a context-length problem.

The KV cache keeps growing, but RoPE’s temporal offsets move outside the training distribution. Attention then struggles to retrieve the right frames. Directly compressing a position-rotated cache makes matters worse by averaging content with incompatible phases.

WorldTrace needs no retraining. It assigns each compressed memory slot a distinct virtual position within the training distribution. One variant compresses continuous history for temporal coherence. Another preserves landmarks at scene transitions for later revisits. On LoopBench, the variants improve temporal consistency by 15.5% and episodic recall by 19.5%. Before expanding cache capacity, test whether position encoding and compression have made old memories inaccessible. Broader interactions and longer horizons still need validation.

Key takeaways:

  • Memory addressing may limit long-video consistency more than cache capacity.
  • Cache compression should avoid mixing incompatible positional phases.
  • Long-horizon world models need explicit tests for scene recall after detours.

02 Stop Rebuilding TTT From Scratch

Test-time training has many variants, but each often arrives as a hard-coded architecture. That makes it difficult to identify which design choice produced the result. Modular TTT represents the inner learner as a directed acyclic graph.

Fast weights, loss functions, and learning rates become replaceable components with separate attribution. The reported ablations favor lower initial learning rates, weight decay, and a single-layer nonlinearity. Deeper fast-weight networks and normalization can hurt by driving activations too high.

Models with 410M and 1.45B parameters, trained on 100B tokens, match Gated DeltaNet in training loss and benchmark performance. The useful contribution is a reusable runtime-learning interface that reduces duplicate implementation. Its compositional range and engineering cost still require closer inspection.

Key takeaways:

  • Evaluate fast weights separately from their internal learning rules.
  • Deeper inner networks may underperform when activations grow too large.
  • A shared modular representation speeds up ablations and reuse, not just benchmark gains.

03 ReASearch Puts Search Inside the Agent Loop

Optimizing prompts, programs, and ML workflows usually requires an outer-loop algorithm. It decides what to try, how to revise candidates, and when to stop. ReASearch assigns those decisions to the same tool-using agent.

The agent evaluates results, diagnoses failures, allocates budget, and adapts its strategy through persistent memory. Across 14 tasks, one shared loop beats specialized optimization systems in most cases. Gains over strong baselines range from 2% to 40%. Some results also exceed the best previously known human-designed solutions.

The open question is whether this unified interface transfers reliably across tasks. Proposal, evaluation, and stopping authority all sit with one agent. The full experimental design must show that validation and budget controls remain dependable.

Key takeaways:

  • An agent can internalize search strategy instead of merely generating candidates.
  • A reusable loop can reduce the cost of building task-specific outer algorithms.
  • Centralized editing and evaluation demand strict validation and budget controls.
Runtime Control Moves Into the Open

Also Worth Noting

04
Traditional Scaling Laws May Misprice Data-Scarce And Overtrained Regimes When Model Size And Data Volume Do Not Affect Loss Independently. TrainingSkaling combines Chinchilla exponents with the Kaplan coupling relationship. link
05
Unified Image Restoration Models Can Adapt Tokenization Itself To Spatially Uneven Degradation Instead Of Waiting For The Backbone. Image GenThe paper proposes degradation-aware deformable tokenization. link
06
General Leaderboards Cannot Capture Real-Time Embodied Interaction When Selecting Foundation Models For Social Robots. EvaluationThe paper proposes a community evaluation framework that includes deployment constraints. link
07
One-Shot, Training-Free, Task-Agnostic Pruning Could Cut Vision-Language Model Deployment Costs On Constrained Devices. EfficiencyPrune Once explores this approach for vision-language models. link
08
Training-Free High-Resolution Generation Could Spare Teams From Retraining Existing Diffusion Transformers. Image GenHRDiT extends pretrained DiT models to higher resolutions without training. link
09
Corruption Resistance In Natural Images May Depend On Internal Computation Paths, Not Just Final Representations. InterpretabilityThe paper studies resistance by suppressing and diversifying those paths. link
10
Autonomous Discovery Of Accelerator-Tuning Algorithms Could Reduce Repeated Expert Rewrites After Light-Source Design Changes. AI for ScienceThe study applies automated algorithm discovery to simulated accelerator tuning. link

Today's Observation

Modular TTT, addressable video memory, and ReASearch point to the same system design shift. Runtime learning, long-term visual retrieval, and search decisions are becoming configurable operations. Teams can record and evaluate them separately instead of leaving them hidden inside the model.

Base models still set the capability ceiling. System differences may increasingly come from an explicit runtime control plane spanning fast weights, memory addresses, and search procedures. Aggregate scores cannot reveal whether gains came from parameter updates, memory hits, or better evaluation decisions.

The next experiments should instrument all three layers. Record fast-weight update paths, memory-address hit rates, and search evaluation histories. Then ablate each layer separately alongside the overall score.