HDATF
English
Start a conversation
Menu

Paper Archive

Every archived paper with its summary, highest number first.

Papers 1,193Archive updated BenchmarksRSS feed
  1. 1095Machine LearningarXiv:2609.20807

    Score Centering Stabilizes Off-policy Reinforcement Learning

    • Identified the cause of RL instability as 'drift' (engine discrepancies accumulating at every training step) and mathematically derived an additive correction term that cancels it.
    • Under low-precision quantization such as FP8/INT4 over 800 training steps, score centering matched or outperformed major correction methods including PPO and DAPO.
    • Because it is an additive rather than ratio-based correction, it composes with importance sampling, and the combination beat pure importance sampling in stale rollout experiments.
    • Validated with Qwen3-0.6B (Countdown game) and Qwen3-30B (math data), and released the code on GitHub.
    AbstractPDF
  2. 1094LLMs / NLParXiv:2609.19969

    DeepSeek-V4.1-Flash: Pushing the Limits of KV Cache Compression

    • Cut per-token memory to about 1/4 of the previous generation (890 bytes) by combining cross-layer KV sharing (CSA2) with FP4 low-precision storage.
    • Reduced the persistent SSD cache to about 1/8 with SWA Bounded Replay, which benefits agents that reuse long conversations across sessions.
    • The encoder-decoder structure (CED) halves active parameters during prefill (8B), making it cost-efficient for agent workloads with heavy input and short output.
    • Supports contexts up to one million tokens, pretrained on 45T multimodal tokens and post-trained with large-scale agent task synthesis plus RL.
    • Confirmed across 8 benchmarks that raising the reasoning-effort setting from 25 to 100 predictably scales response length by 2.0-3.1x while consistently improving performance.
    • Model checkpoints are publicly released on Hugging Face for immediate use.
    AbstractPDF
  3. 1093AI AgentsarXiv:2609.20519

    SoL-Pi: Recursively Scaling Auto-Research Loops for Efficient Agent Harness

    • Applies RSI (recursive self-improvement) at the harness layer — the AI observes its execution traces and automatically improves the harness code.
    • Stage-gated exploration from broad to deep: 152 proposed directions → 500 execution environments → 3,000+ runs → 4 surviving mechanisms.
    • The 4 survivors: Action Fusion (command merging), Online Context Compaction, ObservationPack (observation bundling), and Evidence-Preserving Delegated Reading.
    • On EdgeBench's 51 tasks, it matched Pi's performance (42.0 vs 44.8) while cutting tokens by 44.7-49.0% and reducing API costs to about one-third.
    • Consistent improvements across both GPT-5.6 Sol and Opus 5 — confirming generalization across models.
    • Proposes the concept of 'harness pretraining' — a recursive efficiency vision where a more efficient harness lowers the cost of the next research cycle.
    AbstractPDF
  4. 1092RoboticsarXiv:2609.17524

    Modality-Autoregressive World-Action Models

    • This paper is the first to propose a 'modality-autoregressive' structure that predicts the future as multiple information types in sequence and generates actions last.
    • It showed that predicting point tracks (motion), DINO features (semantics), and depth (geometry) improves performance, while adding RGB video prediction gives no consistent benefit.
    • It achieved a similar or better success rate (75% vs. 72%) than a 6B pretrained model with roughly 20x less training compute.
    • It beat existing methods on three real-world bimanual robot tasks (cup stacking, towel folding, drawer organization) and improved further when human video data was mixed in.
    • Training from scratch without pretraining enables controlled comparisons, which is a significant lesson for experimental design in this field.
    AbstractPDF
  5. 1091Natural Language ProcessingarXiv:2609.19134

    ScienceIDE: Turning World's Scientific Codebase into Agent Learnable Environments

    • It defined the 'scientific experience bottleneck', where papers and code do not directly become training experience, and proposed infrastructure to solve it.
    • It converted 27 scientific codebases into 64 executable environments and 2,812 verified tasks, covering broad fields such as astronomy, climate, and materials.
    • The PhAI-IDE model family trained on verified trajectories improved not only on scientific code repair but also on general coding and reasoning benchmarks.
    • On the ScienceIDE-Hard evaluation, even the top model (Claude Fable 5.1) reached only about 67%, showing that scientific coding remains a hard area.
    • Its aim of an integrated workspace where SFT, reinforcement learning, and evaluation run on the same environment directly resonates with the LabChin architecture.
    AbstractPDF
  6. 1090Computer VisionarXiv:2609.19138

    In-Context Robot Learning with VLM Agents

    • It is one of the first systematic measurements of how far commercial VLMs alone, without robot training, can adapt in the field.
    • With only a human video demonstration, task progress rose from 55% to 100% while run time and token usage decreased.
    • It compared five context types, including goal images, robot video with actions, and interaction history, within a single execution framework.
    • On human-robot interaction tasks like tic-tac-toe, GPT-6 Astra succeeded 3/3 while handling turn-taking and strategic reasoning together.
    • On the other hand, it clearly exposed the limitation that precise contact, outcome verification, and safety issues cannot be solved by general-purpose models alone.
    AbstractPDF
  7. 1089RoboticsarXiv:2609.18207

    Reinforcement Learning for Real-Time Vision-Language-Action Policies

    • It solved the problem of stale observations at execution time caused by large VLA model inference latency with a dual structure of 'slow proposal plus fast correction'.
    • Unlike prior real-time execution methods based on imitation learning, it raised reliability beyond the training distribution through reinforcement learning fine-tuning.
    • On four real-robot tasks (object passing, ball balancing, table soccer kicking, dynamic picking), it improved performance from 42% to 97% with only 10 minutes of online data.
    • Training runs fully automatically without human intervention, which matters greatly for real-world deployment.
    • On the Kinetix simulation benchmark it beat all delayed and non-delayed methods, ranking first in all 10 environments.
    AbstractPDF
  8. 1088Machine LearningarXiv:2609.15903

    Discrete Beckmann Transport Models for One-Step Language Modeling and Reasoning

    • The paper establishes theory showing that a one-step transport map satisfies the conservation equation b·∇T=0, and builds a method that trains directly by minimizing its residual without teacher distillation.
    • Iteratively applying the partially learned map converges to a fixed point (the completed sentence), so accuracy can be raised while reducing the number of computation steps.
    • The method supports self-correcting generation that uses extra computation as a refinement step via partial-context interpolation.
    • On language modeling (OpenWebText generation PPL) and reasoning tasks, it outperformed diffusion and flow-map baselines such as FMLM with equal or fewer function evaluations.
    AbstractPDF
  9. 1087AI / GeneralarXiv:2609.15818

    Atria Dawn: The Dawn of Agentic Superintelligence

    • The team trained a 744B-parameter mixture-of-experts agentic model with a pipeline that runs from tool use through artifacts to external verification.
    • It posted top scores on 5 of 16 benchmarks and second-best on 3, including SWE-bench Pro 59.6 and GDPval 1583.
    • Alongside the model, the authors ran an empirical human-AI collaboration study analyzing 769 work logs from 56 participants.
    • Participants judged that roughly a third of the AI-assisted tasks would have been impossible without AI under the same conditions.
    • The study shows roles shifting toward a project-level partnership in which the agent proposes methods and executes changes while humans evaluate, choose, and set direction.
    AbstractPDF
  10. 1086AI / GeneralarXiv:2609.15364

    RSIAgent: Autonomous Exploration for Recursive Self-improvement in New Environments

    • The paper proposes a recursive self-improvement loop that rotates three agent roles—curriculum, execution, and verification—to accumulate environment knowledge without human supervision.
    • A two-stage strategy of broad parallel exploration followed by deep digging on important directions captures corner cases and hidden constraints into memory.
    • Instead of logging simple successes, it stores action-condition-outcome causal relations in memory and reuses them on other tasks.
    • Using memory alone, with no training or parameter updates, it lifted open-source models (Kimi-K3, GLM-5.3) to or above GPT-6-class performance.
    • It demonstrated passing frontier closed models with an OSWorld-v2 partial score of 78.82 and 71.60 on Agent's Last Exam.
    AbstractPDF
  11. 1085LLMs / NLParXiv:2609.10715

    NCP-ArchPreview Technical Report: Moving towards Latent Space Language Models through Next Concept Prediction

    • The method builds a concept vocabulary from internal representations, trains next-concept prediction together with next-token prediction, and feeds predicted concepts back into token generation.
    • The 8.9B model reached the final pretraining loss of the OLMo-3-7B baseline with 51.3% of its total training tokens, and after full training scored 2.45 points higher on the downstream task average.
    • Against a separate 8.9B-sized baseline, it approached a similar training loss using 85% of the baseline compute, showing the gains are not explained by model size alone.
    • It presents domain adaptation that tunes only a 17M-parameter concept module, and feeding concept representations into the DFlash2 draft generator raised mean acceptance length by 4.17%, suggesting benefits for speculative decoding.
    • This architecture preview was evaluated at standard context lengths without long-context training, so whether the same gains hold in long-document settings needs further verification.
    AbstractPDF
  12. 1084Machine LearningarXiv:2609.11873

    The Last AI Built by Humans: Toward Genuine Recursive Self-Improvement

    • The paper proposes a five-level autonomy framework (B0–L5) that maps scattered self-improvement research onto a single landscape.
    • The authors directly surveyed more than 100 industry cases including Anthropic, DeepSeek, and Tencent, and graded them by level.
    • It quantifies development cost: multi-agent workloads use roughly 15 times the tokens of standard chat, and DeepSeek-V3.2 spent over 10% of pretraining compute on post-training.
    • It cites the GPT-5.6 case where AI directly designed and ran experiments, improving token-generation efficiency by more than 15%.
    • It identifies reliable verification and learning environments as the core bottleneck for recursive self-improvement.
    AbstractPDF
  13. 1083Machine LearningarXiv:2609.11801

    Thinking with Looped Flows

    • Compared with the prior best model of the same architecture (TRM), it raises ARC-AGI-1 accuracy from 44.6% to 58.8% and ARC-AGI-2 from 7.8% to 12.2%.
    • It solves 90.9% of the cases where earlier loop models failed, recovering 89.9% of non-convergence cases and 98.0% of cases that settled on wrong answers.
    • On problems with many valid answers such as N-Queens and graph coloring, different samplings yield multiple distinct valid solutions, achieving the best scores on every metric.
    • Performance keeps improving simply by refining the inference-time grid or using higher-order integrators, realizing the goal of solving better with more compute.
    • Ablations show that each flow component—time conditioning, the interpolant, annealed noise, and noise sharing—contributes measurably to performance.
    AbstractPDF
  14. 1082LLMs / NLParXiv:2609.10745

    Think Before You Link: Rarity, Reasoning, and Retrieval in Multilingual Entity Linking

    • To complement view-count-based rarity measures, the authors built an evaluation set of rare entities using structural signals such as Wikidata link counts and description metadata.
    • A reasoning-capable vision-language model iteratively searches English Wikipedia to gather evidence; no additional model training was done for the proposed procedure.
    • On the MERLIN benchmark spanning Hindi, Indonesian, Japanese, Tamil, and Vietnamese, combining retrieval with reasoning performed best, while reasoning alone did not significantly improve rare-entity accuracy.
    • Adding retrieval alone can improve rare-entity performance while hurting overall accuracy, showing that reasoning over retrieved evidence matters in multilingual entity linking.
    • Applicability is limited to entities with an English Wikipedia article, and search failures dominate the residual errors, leaving retrieval quality as the main open problem.
    AbstractPDF
  15. 1081Machine LearningarXiv:2609.11917

    Data Scarcity and Model Sparsity: Mixtures-of-Experts Overfit More to Repeated Data

    • The researchers varied data repetition rates, domain mixtures, and expert counts and sizes across models with 80 million to 1 billion active parameters.
    • At the 80-million-active-parameter scale, mixture-of-experts models degraded from four data repetitions onward and lost their advantage over dense models at high repetition rates.
    • Expert-routing paths freezing early in training and experts over-specializing on repeated data were observed, offering clues for understanding the overfitting.
    • Dropout and output masking mitigated the damage from repeated data, suggesting that overfitting countermeasures deserve review alongside architecture choices when data is limited.
    • None of the tested mitigations fully reproduced training on unique data, so repeated-data training cannot be treated as a complete substitute for new data.
    AbstractPDF
  16. 1080Computer VisionarXiv:2609.11929

    SenseNova-U1.5: Towards Native Unified Visual Intelligence

    • With a single architecture that drops the encoder and VAE and learns directly from pixels, one model handles image understanding, reasoning, generation, and editing.
    • Instead of predicting each pixel patch independently, a reconstruction scheme lets neighboring regions exchange information, producing seamless images even at 4K resolution.
    • It uses a specialize-then-unify strategy: separate reinforcement-learning experts are trained per capability and merged into one model via on-policy distillation.
    • It scored 68.2 on the VBVR-Pro-Bench text-image bidirectional benchmark, ahead of commercial models such as Nano-Banana-Pro (56.4) and GPT-Image-2 (50.7).
    • Despite almost no structured formats in the generation training data, the model follows long, complex structural instructions well, indicating that understanding capability transfers to generation.
    • On the reasoning-centric editing benchmark RISEBench, using chain-of-thought substantially improves causal, logical, and temporal editing scores.
    AbstractPDF
  17. 1079Machine LearningarXiv:2609.10464

    Semigroup-JEPA: Latent Dynamics Consistency for Zero-Shot Physics Generalization

    • SG-JEPA takes a gravity condition and recursively predicts multi-step latent states, jointly training the encoder and predictor.
    • Generalization is tested on eight MuJoCo datasets that train in a narrow gravity range and evaluate over a wider one.
    • The paper reports that 2D prediction error falls to as little as half that of DINO-WM and 3D robot-control success rates rise by up to 2.5 times.
    • Training a new predictor on a frozen encoder shows the key gain lies in dynamics-relevant representations, which are then used as control inputs for a separate diffusion policy.
    • Settings that vary several physical variables beyond gravity together were not validated, and transfer under changed object shape and rotation is uneven.
    AbstractPDF
  18. 1078Computer VisionarXiv:2609.10540

    Programmable World Model

    • Separating a state-managing engine from a video-generating renderer structurally solves video world models' inability to remember.
    • A coding agent turns natural-language instructions into executable programs, letting users directly program game rules.
    • A 3D oriented-bounding-box intermediate representation keeps programs easy to manipulate while precisely guiding video generation.
    • On the new CombatStateBench it reaches 94% character-count consistency and 98% state fidelity, leading prior models by up to 62 percentage points.
    • It also stays best on all four VBench video-quality metrics, showing structured control does not hurt visual quality.
    AbstractPDF
  19. 1077RoboticsarXiv:2609.10522

    Show-Harness: Just a VLM Agent Can Play Robots

    • Without robot-specific retraining as in vision-language-action models, it taps a foundation VLM's intelligence for robot control through a meaningful motion-primitive interface alone.
    • Real robot-arm experiments confirm that state-of-the-art closed VLMs can be used directly as robot agents zero-shot, with no training.
    • Small open-source VLMs (2B class) handle robots in the same action space after just a few GPU-hours of light fine-tuning, opening a low-cost deployment path.
    • It generalizes better across tasks, robot morphologies, and environments than prior agent approaches and VLA models.
    • A GUI-based control interface called GUMI lets humans and agents collect robot demonstration data together without expensive teleoperation rigs.
    • Component ablations show planning, failure recovery, and motion logging lift success rates by up to 24–35 percentage points.
    AbstractPDF
  20. 1076LLMs / NLParXiv:2609.08936

    AuK Technical Report: An Open-Source Foundational Model for Speech Generation and Editing

    • Taking natural-language instructions and audio context as common inputs, it covers speech generation, content editing, restoration and separation, and speaker-attribute or acoustic editing.
    • It combines semantic conditioning from a multimodal language model with acoustic conditioning from an audio VAE, and jointly trains generation and editing after generation-centric pretraining.
    • Different post-training signals are applied to generation and editing, and AuK-Flash reports a 4.5x speedup under matched conditions with four-step inference.
    • Handling diverse audio tasks through one unified interface makes it a foundation for building speech production and editing tools.
    • Understanding compound instructions and generalizing to new instruction combinations remain open, and the current system partly relies on task classification and instruction completion.
    AbstractPDF
  21. 1075RoboticsarXiv:2609.07398

    OpenWAM: An Open, Modular Exploration Towards Systematic World-Action Model Pretraining

    • OpenWAM-Infra breaks the design space of world and action models into modules and integrates training, inference, deployment, and evaluation.
    • Controlled experiments disentangle the roles of generative models and compact representations, what information flows from world prediction to action, and the effect of joint training.
    • Models trained on roughly 6,400 hours of egocentric human and robot data were evaluated on eight simulation benchmarks and real robot manipulation.
    • Because design and evaluation conditions are shared, others can reproduce component swaps and compare robot-learning methods on the same footing.
    • The abstract's performance claims were verified only for the evaluated single-arm and bimanual manipulation settings, not for every robot environment.
    AbstractPDF
  22. 1074Computer VisionarXiv:2609.09155

    SyncWorld: Visual Calibration Enables World Models as Zero-Shot Simulators

    • Videos of the robot moving along each control direction plus action logs serve as a calibration context, so the model learns how commands map to visual change in a given environment.
    • At prediction time it uses the calibration context, recent observations, and the planned action together, requiring no additional training for a new environment.
    • The authors show experiments simulating action outcomes in unseen environments and using these predictions to improve policy performance at evaluation time.
    • This can cut the cost of retraining a simulator whenever the camera or robot placement changes.
    • Trajectory prediction is unstable from extreme viewpoints, and out-of-distribution objects may appear blurred or misplaced.
    AbstractPDF
  23. 1073Computer VisionarXiv:2609.05416

    WorldSculpt: Generating Compositional Worlds from Grounded Videos

    • By adding a circuit that feeds multi-view video into a single-object 3D generative model (Pixal3D), it handles scenes with hundreds of objects without scene-level training.
    • Each object is produced as an individual mesh and placed in world coordinates, so games, AR, simulation, and robotics can pick objects out separately.
    • It releases UE-MeshyScene, an Unreal Engine benchmark of 6 scenes with 93 to 701 objects and ground-truth meshes per object.
    • On the heavily occluded benchmark, learning-based image-based rendering cuts CD-L2 error by 12% and raises F-Score from 0.944 to 0.951.
    • It also demonstrates, without extra training, converting 3DGS scenes from generative world models such as Marble and HY-World 2.0 into object-level mesh scenes.
    AbstractPDF
  24. 1072AI / GeneralarXiv:2609.05275

    Don't Drop Dropout: Optimizing Layer Sparsity for Efficient LLM Training and Inference

    • Across more than 2,400 training runs, it finds the optimum is stronger dropout for deeper layers, gradually annealed as training progresses.
    • At the same training budget, validation loss matches or beats the no-dropout dense baseline while saving up to 25% of compute.
    • An 8.2-billion-parameter model with an aggressive schedule peaking at 99% dropout reached loss 1.663, better than the dense baseline's 1.732.
    • Dropout-trained models stay robust when layers are skipped, enabling self-speculative decoding—where the model drafts and verifies quickly—for up to 1.55x speedups.
    • In contrast, dense models trained without dropout blow up to loss 6.446 when layers are skipped, making them effectively unusable.
    AbstractPDF
  25. 1071LLMs / NLParXiv:2609.03430

    Random Attention: Rethinking KV Cache Eviction for Efficient Reasoning

    • The method preserves the input question while evicting cache entries uniformly at random from each attention head's reasoning history, eliminating importance scoring and ranking.
    • Comparisons across four models and six reasoning tasks showed accuracy comparable to strong existing eviction methods, and most performance differences shrank when all methods were configured to preserve the input question.
    • In vLLM experiments on a single H200 with a cache budget of 2048, a 1k-token input, and a 32k-token generation, output throughput was 32–43% higher than TriAttention.
    • The analysis that needed information is restated during reasoning and stored redundantly across multiple heads suggests that memory demands and cache-management costs in long-reasoning services could be reduced without complex importance calculations.
    • Selection signals helped in an experiment retrieving information that appeared only once and was never mentioned again, so these findings should not be generalized to mean that random eviction is superior for all information-retrieval tasks or all models.
    Full textCodeAbstractPDF
  26. 1070ResearcharXiv:2609.03344

    Large-Language Models as a Cognitive Virus

    • In a population dynamics model (epidemic-style diffusion) that divides people into three states (non-use U, autonomous use C, and persistent dependence D), crossing a critical range of transmission rates produced bistability (a range in which two stable states coexist), with a sharp shift from coexistence between autonomous and dependent groups toward dependence.
    • With illustrative parameters (ρ=0.10, κ=0.40), hysteresis occurs between the thresholds λSN=0.40 and λTC=0.50. Once adoption runs away, reducing transmission pressure to its previous level does not automatically restore the earlier state (technological lock-in).
    • The persistent-dependence fraction is determined by D*=(µ/σ)C*. Reducing the rate of entering dependence µ or increasing the recovery rate σ can reduce dependence (through training, verification habits, and deliberate cognitive friction).
    • Using illustrative cognitive-capacity values (autonomy 1.0, autonomous use 0.5, and persistent dependence 0.1), average capacity follows the same hysteresis. The key point is that population-wide capacity can drop sharply even when individual adoption is gradual.
    • It defines 'cognitive immunization' as maintaining habits of independent verification and unaided problem solving, along with educational designs that support them, rather than blocking exposure to AI. The conclusion is that prevention is much easier than recovery.
    • Experimental evidence cited by the paper: a 'think first, ChatGPT later' protocol improved subsequent independent creativity, while unrestricted AI use improved performance while using the tool but reduced unaided performance, understanding, and memory.
    AbstractPDF
  27. 1069LLMs / NLParXiv:2609.04173

    Last Translation Benchmark

    • Humans created and peer-reviewed 3456 challenging translation examples across 109 languages in text, image, audio, and video formats.
    • Each example includes verification rules specifying how it should be translated, and an LLM judge assigns a pass or fail for each rule. An example counts as successful only if every rule passes.
    • On a simple English-to-Czech sentence involving the gendered expression for a male nurse, Google Translate and Gemini 3.1 Pro scored 0%, and only GPT-5.6 Sol passed. This shows that even strong models make critical mistakes.
    • In an experiment transferring examples to other languages, automatic filtering retained 48%, while human review passed 64.1%, demonstrating the feasibility of semi-automatic expansion.
    • The data is released under CC BY 4.0, and this is a living benchmark that continues to accept contributions.
    AbstractPDF
  28. 1068AI / GeneralarXiv:2609.04148

    Terminal-Universe: Turning Agent Trajectories into Scalable Terminal Environments

    • Starting from the idea that agent traces already contain all the environmental information, it reconstructed 37.3k reusable execution environments by rewinding file operations and using a repair agent.
    • It generated multiple tasks from each environment, including tasks spanning multiple codebases (breadth expansion) and multi-round tasks with continuing user feedback (depth expansion).
    • By attaching a verifier to each task and using only data that passed, it improved Qwen3.5-27B by 11.9 points on Terminal-Bench 2.1 and 13.8 points on EvoCode-Bench v2 MT@4.
    • With the same data budget, increasing the number of environments was more effective than increasing the number of questions or solutions (53.2→56.0 vs 53.8/53.9).
    • Training the agent to solve tasks again in reconstructed environments was much better than training it to imitate the original traces directly.
    • Data generated from software engineering (SWE) traces also raised the terminal benchmark average from 47.0→50.0, demonstrating cross-domain generalization.
    AbstractPDF
  29. 1067Machine LearningarXiv:2609.04010

    Unlocking Lossless Speedups in LLMs via Discrete Diffusion

    • Adding only a lightweight training stage that equips an existing LLM with diffusion weights, allowing multiple tokens to be filled in simultaneously, delivered up to a 3× speedup without major architectural changes.
    • Unlike speculative decoding methods such as EAGLE-3 and DFlash, which require a small draft-only model, it handles drafting and verification in a single model and provides lossless acceleration with an answer distribution exactly matching the original.
    • Whereas earlier diffusion LLMs lost their gains as batch size increased, Uno achieved higher throughput than speculative decoding at every evaluated batch size and maintained a 2× speedup even at the largest batch.
    • The 8B Uno outperformed the 26B DiffusionGemma and commercial Mercury 2 across all benchmarks for agentic tool use, coding, and long-document reasoning.
    • It also accelerated rollout generation, the slowest stage of RL post-training, showing that it can speed up reinforcement-learning training itself as well as inference.
    • It can be built on already released open-weight models, so there is no need for a new large-scale training run.
    AbstractPDF
  30. 1066AI / GeneralarXiv:2609.04172

    Rethinking On-Policy Distillation of Large Language Models II: One Training Example

    • Even with just 1 question for distillation training, performance kept improving for hundreds of steps, recovering 72% of the full-data effect on math tasks.
    • It proposed 'state coverage' as an explanatory measure. 1 question achieved 71.5% coverage, while 16 semantically different questions achieved 98.9% coverage and matched full-data training performance.
    • The absorption rate (the fraction of the remaining teacher-student gap closed by a single update) declined at a similar rate whether training used 1 question or 17,000. This suggests that the bottleneck is the learning algorithm rather than the amount of data.
    • Training on nearly content-free templates or unrelated-domain conversation data (WildChat) had effects similar to training on real questions. The argument is that a question's only role is to 'trigger thinking.'
    • Over 1000 steps using the same single question, distillation (OPD) produced at least twice the performance gain of reinforcement learning (RLVR). Outcome rewards are exhausted once the answer is correct, whereas token-level supervision continues to provide a signal.
    AbstractPDF
  31. 1065LLMs / NLParXiv:2609.02702

    Trace as State: Reasoning Traces as Conditional States for Long-Context Transformers

    • Simply placing the reasoning trace from the first reading before a long document and having the model read it again outperformed the existing approach of appending the trace in 26 of 27 model × task × metric combinations.
    • A theoretical analysis explains the advantage of prepending the trace: providing a condition first requires exponentially less memory than providing it later.
    • On GraphWalks Parents, GLM-5.2's accuracy rose from 66.4% on the first attempt to 100%, while DeepSeek V4 Pro improved from 29.2% to 81.8%.
    • Inserting a trace from a different problem actually reduced performance. This indicates that the effect comes from information specific to the problem, rather than the format.
    • Performance continued to improve as the number of traces increased from 1 to 5, making trace count an additional scaling lever for controlling the number of reasoning attempts.
    • Its biggest advantage is that it requires no model-architecture changes and can therefore be added directly to any service that handles long documents.
    AbstractPDF
  32. 1064RoboticsarXiv:2609.01938

    One Demonstration, Many Objects: Generalizing Manipulation via Local Contact Geometry

    • Instead of teleoperation, it starts from a single human video demonstration, converts it into a robot trajectory, refines it with residual reinforcement learning in simulation, and distills it into a depth-camera policy.
    • It separates a low-level policy that observes only local geometry near the contact point through a wrist-mounted depth camera from a high-level policy that determines the global trajectory from frontal RGB video, allowing operation without object-position estimation at execution time.
    • Ablation experiments showed that contact-alignment and contact-maintenance rewards barely affected simulation scores but decisively improved success rates on real hardware.
    • Across 16 objects × 4 tasks × 2 types of robot hands, it achieved an average real-world success rate of 71% (76% for one hand and 65% for the other), with the smallest sim-to-real performance drop among the baselines.
    • Performance fell to 39% on an object with different local contact geometry (a box with a curved lid), candidly showing that generalization is bounded by similarity in contact structure.
    AbstractPDF
  33. 1063Machine LearningarXiv:2609.01343

    SMELT: Scaling Laws for Compute-Matched MoE Looped Transformers

    • This is the first multi-scale comparison in looping research to simultaneously match all three budgets, compute per token, total parameters, and KV cache, ruling out the objection that the gains merely come from using more computation.
    • The design loops only the middle half of the layers twice, reduces the hidden dimension, and then increases the number of experts to restore knowledge capacity, exploiting a budget trade-off possible only with MoE.
    • It consistently achieved lower loss across 4 scales up to 54B non-embedding parameters and multiple sparsity levels, with scaling-law fits indicating that reaching the same performance requires 6.8–18.0% less training compute.
    • The largest gains were in the code domain, and the gap widened with longer inputs and more examples in the prompt, showing that looping becomes more valuable for structured inputs.
    • On the second pass, attention sinks disappeared and attention shifted toward evidence tokens for the correct answer. In a bracket-matching task, attention concentrated on the first token fell from 0.60 to 0.02, while attention to evidence tokens rose from 0.24 to 0.85.
    AbstractPDF
  34. 1062AI / GeneralarXiv:2609.01481

    Harness-of-Harness: Multi-Day Autonomous Software Development with Continual Improvement

    • It secured both agent autonomy and verifiability by leaving the harness implementation untouched and enforcing only the formats of artifacts (plans and test reports), triggering retries on violations.
    • Across GameCraft-Bench, FrontierSWE, and ProgramBench, the Codex+GPT-5.5, OpenCode+DeepSeek-V4-Pro, and Pi+MiniMax-M3 combinations all improved after just 3 loops, with an average relative gain of 52.25% and a maximum of 82.86%.
    • On FrontierSWE, Codex+GPT-5.5 continued improving from 22% to 72.67% over 10 loops, showing that gains accumulated with more iterations.
    • Given only a requirements document in an empty working directory, it autonomously completed 'Fusepoint,' a first-person shooter with a story, combat AI, presentation, and audio, over more than 70 loops. Human intervention was limited to restoring network connectivity.
    • It closed 65 of 81 recorded issues on its own and used version history to recover from 17 regression issues in which previously verified features had broken, showing that regression management is central to long-term development.
    • It used a progressive-disclosure structure that assigned skills for Godot engine integration, asset generation, UI/UX, and testing by role to encourage reuse.
    AbstractPDF
  35. 1061Computer VisionarXiv:2609.02886

    SolarWM: Open Data and Scalable Training for Long-Horizon Video World Models

    • It converted 1.43 million clips from 10 datasets, totaling at least 25TB, into a unified format containing frame alignment, camera geometry, captions, and quality metadata, enabling experiments with different training mixtures without rerunning preprocessing.
    • It applied backbone-native adaptations that preserve the original representations and objectives of the structurally different Wan2.2 (5B/14B), LTX-2.5 (22B), and MiniMax-H3 (33B) backbones, producing 4 directly comparable model families.
    • A simple 3-stage process of bidirectional training, autoregressive adaptation, and distribution matching distillation (DMD, a technique that compresses a large model into a smaller one by training it to imitate the large model's output distribution) achieved leading performance without special initialization.
    • Despite training only on 5-second sequences, it maintained scene identity and camera responsiveness throughout continuous 60-minute rollouts without fine-tuning on long videos or using attention-sink mechanisms.
    • Even when initialized with externally generated images from GPT Image 2 or Krea in styles absent from the training data, it generalized by imagining unseen regions and expanding them into explorable worlds.
    • It released all data, processing pipelines, training recipes, and weights, establishing a reference point for reproducible video world-model research.
    AbstractPDF
  36. 1060Agents / InfrastructurearXiv:2609.01437

    HarnessDev: Can LLMs Create and Evolve Their Own Agent Harness?

    • HarnessDev defines a harness as execution infrastructure reused across tasks rather than a single response, separates creation from evolution, and evaluates both capability and execution token cost.
    • It used 6 generation models and 2,207 unique tasks across 4 domains and 5 benchmarks. Generated harnesses were strong in writing and machine-learning experiments but lagged behind human-built baselines in coding, search, and research.
    • All 18 coding harnesses implemented execution loops, but state and memory were their weakest areas. Although 11 declared a State class, only 1 provided a storage interface and only 1 provided periodic checkpoints, and no checkpoint event appeared in 26,679 execution traces.
    • Analysis of 73 official versions and 64 version transitions across 9 evolution runs found that visible and hidden scores moved in the same direction 53.1% of the time, and the final selected version was optimal on hidden tasks in only 2/9 cases.
    • In evolution experiments with Gemini fixed as the execution model, only the Opus family improved on hidden tasks, while the other 3 families worsened, showing that harness improvements can overfit a particular model and public feedback.
    AbstractPDF
  37. 1059Machine LearningarXiv:2609.00196

    WHALE: A Simple Recipe for Joint Harness-Weight Optimization

    • It alternates between online rejection-sampling fine-tuning with the current harness fixed and Meta-Harness code search with the updated model fixed.
    • Evaluations of Qwen3.5-2B and 4B on search-based question answering, mathematical reasoning, and chess puzzles achieved peak accuracies 7.67–24.38 percentage points higher than single-component baselines and 4.15–13.00 percentage points higher than FST, which changes only prompts.
    • The harness was the main bottleneck for search tasks, but mathematical tasks required weight updates first before the same harness search became effective, showing that the bottleneck varies by task.
    • Interleaving multiple small updates improved accuracy and rollout efficiency over a staged approach that trains all the weights and then searches for a harness once, providing grounds for designing agent-training pipelines as a joint optimization problem.
    • Important limitations are that validation covered only Qwen3.5-2B and 4B and three tasks, and that the rollout-cost comparison excluded compute used by the model proposing harnesses.
    AbstractPDF
  38. 1058Computer VisionarXiv:2609.00111

    Qwen-Drive-1.0: An Initial Step towards a Vision-Language Foundation Model for Autonomous Driving

    • Without changing the architecture of the pretrained VLM (Qwen3.5-4B), it added just two external modules, a BEV perception head and a Planning Expert, to integrate 3D perception, question answering, and path planning.
    • It used the BEV head as a '3D probe' to make it possible to test how well the model understands actual 3D scene structure, beyond simply producing fluent text answers.
    • Staged training that mixes driving data with general-purpose vision-language data preserved both driving and general capabilities, mitigating catastrophic forgetting (losing old capabilities while learning new ones).
    • It achieved 43.95 mAP for 3D perception and 60.99 mIoU for mapping on nuScenes, a NAVSIM driving score (PDMS) of 90.7, and a Waymo E2E evaluator score of 7.91.
    • In line with the trend toward vehicle cockpits (multimedia) and driving functions sharing a single computing platform, it aims for a model that handles them together rather than a model dedicated only to driving.
    AbstractPDF
  39. 1057Computer VisionarXiv:2609.01560

    H3-World: Turning Language Understanding into World Control

    • Rather than attaching a dedicated control module to the 33B video-generation model MiniMax-H3, it directly reused the text pathway the model already understands as a control interface.
    • It achieved precise character and camera control using just 8,000 gameplay samples, 10,000 LoRA training steps, and 0.199% trainable parameters.
    • Temporal attention routing restricts each command to its own time interval, reducing command leakage into other intervals.
    • In camera-direction-change experiments, the global-prompt approach achieved horizontal flow of only +0.0/-17.3, whereas H3-World accurately followed both directions with +52.7/-106.0.
    • The same interface worked unchanged for action combinations never seen during training and for scenes outside games, including first-person views, interiors, and fantasy settings.
    AbstractPDF
  40. 1056Computer VisionarXiv:2608.30821

    Lucida: Parse, Generate, and Place for Composable Real-to-Sim Scene Modeling

    • It redistributed the requirements of a three-stage pipeline that had demanded 'precise inputs,' redesigning each stage to consume only what real captured data can reliably provide.
    • A VLM policy called GizmoAct translates object placement into 3D editor GUI operations, deciding the next adjustment and when to stop using rendered views alone.
    • It improved scene-level 3D detection mAP by 69% over Boxer, from 0.351 to 0.592.
    • It raised pose-estimation ADD-SB@0.05 on CA-1M from 57.8% to 83.4%, a gain of 25.6 percentage points, and increased the scene-reconstruction F-score from 0.794 (SAM 3D) to 0.924.
    • A single policy trained with reinforcement learning after SFT handled initialization methods with different error characteristics without retraining.
    AbstractPDF
  41. 1055LLMs / NLParXiv:2608.31119

    PaperGym: Rubric-Centered Evolution for Research-Plan Generation

    • Using paper structure to separate the sources of questions, drawn from objectives and background, from scoring criteria, drawn from methods and experiments, reduced criterion leakage from the previous 11.9–34.1% to 3.7%.
    • Two-stage training that uses the same rubric twice, first as privileged context for OPSD self-teaching and then as a GRPO reward, outperformed SFT, either stage alone, and the reverse order.
    • For Qwen3-1.7B/4B/8B, it raised the average across 5 benchmarks by +5.6, +5.0, and +4.8 points, respectively.
    • In a controlled comparison with the training recipe fixed, a model trained on PaperGym-20k dominated RubricHub Science (28.2%) with a 58.1% win rate in a three-way comparison, isolating the effect of data quality.
    • The trained Qwen3-8B scored 73.48 on ResearchQA, surpassing the much larger Kimi K2.6 at 73.19.
    AbstractPDF
  42. 1054RoboticsarXiv:2608.30935

    LightNav-0: Eliciting VLM Spatial Intelligence for Generalist Embodied Navigation

    • A single VLM backbone handled instruction following, open-vocabulary object search, and visual tracking in one model without task-specific prediction heads.
    • Dual pointing (an affordance point + an object point) raised average success from 54.7% to 63.1%, and removing it reduced performance on every benchmark.
    • A residual vector quantization (RVQ) action tokenizer precisely generated a 10-waypoint trajectory using just 3 tokens.
    • It achieved the highest monocular success rate across all 10 public navigation simulations.
    • It transferred zero-shot to humanoid, quadruped, aerial, and wheeled robots, and expanding environmental diversity was a more reliable driver of performance than increasing model size (the backbone saturated at 4B and above).
    AbstractPDF
  43. 1053Machine LearningarXiv:2608.31046

    Does On-Policy Distillation Really Distill? From Noisy Teacher to Self-Improvement

    • Noise in OPD's teacher signals, penalizing correct answers and rewarding incorrect ones, reached 30.6% for a 4B teacher and 50.6% for a 235B teacher, yet training after removing this noise produced essentially the same results.
    • It showed that OPD's gains concentrate on low-probability tokens and that a single fixed negative advantage can replace the teacher signal.
    • OPSA, with no external supervision at all, raised AIME24 Avg@32 by +35.41 points, a relative gain of 263%, and exceeded OPD by 16.77 points.
    • It at least doubled Pass@32 on all 3 mathematical benchmarks: AIME24/25 and HMMT.
    • At high-entropy branching points where probabilities diverge, it distributes probability evenly among candidate tokens, preserving exploration diversity while sharpening the distribution.
    AbstractPDF
  44. 1052Machine LearningarXiv:2608.31036

    Normalized Low-Rank Adaptation

    • It identified that LoRA's early learning is governed by the down-projection A and showed that simply normalizing A along the rank dimension improves optimization.
    • It raised the supervised fine-tuning average from 37.93 (LoRA) to 43.37, and even NoRA-init, which applies normalization only at initialization, reached 42.38.
    • In reinforcement learning for mathematical reasoning (RLVR), it achieved an overall average of 44.4%, exceeding LoRA (42.8%), and remained stable in contrast to SVD-based PiSSA, which collapsed to 0.2% under the same settings.
    • Post-adaptation retention of existing knowledge (average change across 3 evaluations including MMLU) was +0.02, showing much less forgetting than LoRA (-0.56) or MiSS (-0.70).
    • Applying the same normalization principle to DoRA also raised its score from 38.30 to 41.40, confirming that the idea is not limited to the LoRA family.
    AbstractPDF
  45. 1051AI / GeneralarXiv:2608.27953

    The Illusion of $\textit{What If}$: Evaluating the Breakdown of Counterfactual Reasoning in LLMs

    • It released a diagnostic benchmark of 220 open-domain what-if questions spanning STEM, humanities and social sciences, and mixed domains.
    • It developed the PRISM evaluator, which converts free-form answers into causal graphs, DAGs of events, states, and mechanisms, to score the reasoning process rather than the outcome.
    • The best score among 6 current LLMs was only 64.62%, showing that counterfactual reasoning remains far from saturation.
    • The most common failure was a causal gap: models listed plausible outcomes but omitted the intermediate links connecting the premise to those outcomes.
    • It concluded that fluent narratives conceal weak causal processes, emphasizing the need for structure-based evaluation.
    AbstractPDF
  46. 1050Machine LearningarXiv:2608.27763

    Fast Weight Attention for Continual Learning

    • It reinterpreted state-update rules as online learning and developed a framework that separately analyzes temporal alignment, plasticity, forgetting, and rehearsal.
    • It showed that, in next-token prediction, the pair the state should learn is offset by one step: (previous key, current value).
    • It derived normalized first-order update equations for regression objectives (Falcon-1/2/3) and inner-product objectives (Falcon-1A/2A/3A), and provided recurrent, masked-parallel, and chunk-parallel forms.
    • It remained competitive with existing recurrent models in language-modeling evaluations.
    • In extrapolation to 33–48-digit addition, Falcon-3A.3 achieved 87.2%, outperforming both RetNet and Transformer baselines.
    AbstractPDF
  47. 1049Computer VisionarXiv:2608.27549

    Code as Worlds: Agentic Discovery of Executable World Representations for Physical Reasoning

    • It encoded objects, physical laws, and appearance as code to create compact world representations that can also be verified numerically.
    • An agent loop of proposal, execution, rendering, verification, and revision, inspired by abductive reasoning, automatically discovered world representations from text or video.
    • Using verified executable worlds as supervision, it taught vision-language models quantitative physical reasoning, such as answering questions about speed or mass in videos.
    • Code-as-World-VL-9B outperformed much larger commercial models such as Gemini-3.1-Flash on QuantiPhy, while the 27B model achieved the best overall score.
    • Its central contribution is translating the scientific discovery process of forming hypotheses and testing them experimentally into an agent loop.
    AbstractPDF
  48. 1048LLMs / NLParXiv:2608.28476

    ContextPilot: Teaching Agents for Proactive Context Management via Fine-grained RL

    • Adding planning, long-term memory, and offloading to the tool set raised BrowseComp+ accuracy from 63.49% to 80.96%.
    • Reinforcement learning delivered a 5.34-point gain on the more difficult BrowseComp+ benchmark. The longer and harder the task, the greater the effect.
    • The baseline agent's input length grew linearly with each turn to 30K tokens, whereas ContextPilot stabilized at 8–10K tokens.
    • Reinforcement learning also reduced tool-use mistakes. Memory and offloading tool failures, which were frequent early on, decreased substantially during training.
    • It showed consistent improvements across different base models, including Qwen3-8B/14B and Gemma4-E4B.
    AbstractPDF
  49. 1047ResearcharXiv:2608.28122

    Agentic Artifact Creation: Systems, Evaluation, Principles, and Opportunities

    • Reviewing 259 studies published through August 2026, it defined agentic creation with state persistence and observation-based course correction as a research field.
    • It compared shared challenges and difficulty across 6 artifact families: text, 2D images, audio, video, 3D and spatial artifacts, and behavior such as software.
    • It identified the trade-off whereby decomposing a task reduces local complexity but increases coordination and reassembly costs.
    • It warned that learned judges sharing the generating model's preferences and blind spots add little independent evidence.
    • It proposed principles of making contracts and responsibilities explicit, turning feedback into local repairs, and revalidating affected parts after changes.
    AbstractPDF
  50. 1046LLMs / NLParXiv:2608.28444

    Sliding-window beats linear attention

    • 0 additional training runs: SWA, which changes only the attention mask, matched or outperformed conversions to linear attention that require retraining on billions of tokens.
    • The gap was larger in long contexts. At a 256K context length, SWA recovered 20–25% of the original performance, whereas linear attention (LoLCATs) recovered only 2.2–5%.
    • On MMLU, SWA recovered 93.2% of the original performance, outperforming all major linearization methods, including LoLCATs (83.2%) and Liger-GLA (62.2%).
    • SWA (window 64) had the fastest decoding speed and lowest memory use among the tested methods.
    • Citations to related work also confirmed that training-free sliding windows are a strong baseline for video generation models.
    AbstractPDF