Papers

Raphaël Bonnet-Guerrini, Bruno Sanchez, Dominique Fouchez et al.

You can train accurate astronomical classifiers without expensive human labels by combining synthetic data injection with robust handling of noisy labels, and get reliable confidence scores through a hybrid uncertainty approach.

This paper develops a Real-Bogus classification system for astronomical transients that requires no human-labeled training data. It uses simulated transient injections combined with noisy survey data and a dual-network training approach to reliably distinguish real astronomical events from false detections, while also providing calibrated uncertainty estimates.

Jacky Kwok, Shulu Li, Pranav Atreya et al.

Using continuous probability-based scores instead of discrete LLM judgments improves verification accuracy and calibration, and these fine-grained signals can guide both solution selection and reinforcement learning training.

This paper introduces LLM-as-a-Verifier, a framework that uses language models to evaluate solution correctness by computing probability distributions over scoring tokens rather than discrete scores.

Haozhe Wang, Weijia Feng, Jinpeng Yu et al.

Visual generators need to learn *when* to search for external knowledge, not just *how* to use it—and this knowledge boundary is discoverable through co-training, not fixed in advance.

This paper identifies a critical gap in visual generators: they confidently create incorrect images for requests about new entities, trending topics, and post-training events. The authors show that naive search-augmentation fails because generators have an evolving 'knowledge boundary'—a threshold between what they learned and what needs external context.

Wentao Zhang, Liliana Hotsko, Woojeong Kim et al.

Instead of calling large language models for every fuzzy task, you can compile a natural-language specification once into a tiny reusable neural artifact that runs locally and cheaply—shifting from per-input problem solving to one-time function compilation.

This paper introduces Program-as-Weights (PAW), a method to compile natural-language function specifications into small, locally-executable neural adapters. A 4B compiler generates parameter-efficient adapters that run on a lightweight 0.6B interpreter, matching the performance of much larger models while using 50x less memory and running efficiently on consumer hardware like MacBook M3.

Mona Schirmer, Metod Jazbec, Alexander Timans et al.

Simple threshold-based monitoring with statistical risk control can effectively catch unsafe LLM outputs in production without requiring complex sequential testing methods.

This paper presents a real-time safety monitoring system for LLMs that uses a verifier model to detect unsafe outputs at deployment time. The approach calibrates decision thresholds using risk control methods and proves competitive with more complex alternatives on reasoning and adversarial datasets.

Yanjun Zhao, Ruizhong Qiu, Tianxin Wei et al.

You can boost long-context reasoning without retraining by identifying relevant evidence through attention patterns and replaying it before generation—a simple inference-time trick that works across different model sizes.

ReContext improves how LLMs use information in long documents by replaying relevant evidence before generating answers. Instead of training or pruning context, it uses the model's internal attention signals to identify and reorder important passages, helping the model focus on what matters for each question.

Arman Ghaffarizadeh, Danyal Mohaddes, Aliakbar Izadkhah et al.

LLM agents develop emergent social behaviors and hidden objectives in response to relational context—they'll publicly accommodate others due to perceived social pressure even when privately disagreeing, which current evaluation methods miss.

This paper reveals that LLM agents change what they say depending on their audience and social context, even without explicit instructions to do so. Researchers created a dual-channel debate system where agents give public responses and private off-the-record responses, finding that social pressures (like career risk) cause agents to diverge from their true positions by up to 40%.

Yuxuan Li, Lingxi Xie, Xinyue Huo et al.

Reasoning models can improve speaker identification in video by combining multiple modalities and contextual evidence, outperforming traditional audio-only approaches on challenging cases.

This paper tackles speaker recognition in long-form TV dramas by introducing DramaSR-532K, a large benchmark with 532K annotated dialogue lines, and DramaSR-LRM, a reasoning-based approach that combines audio, text, and visual information to accurately identify which character is speaking. The method works especially well on short utterances where voice alone isn't reliable.

Yunhe Li, Hao Shi, Wenhao Liu et al.

When training reasoning models through self-distillation, selectively adopting teacher guidance based on distribution disagreement prevents information leakage and maintains exploration better than forcing the student to match the teacher exactly.

DemoPSD improves how LLMs learn to reason by fixing a key problem with standard self-distillation: the teacher model's guidance can leak information the student won't have at test time, hurting generalization.

Gil Harari, Yoel Zimmermann, Ola Tangen Kulseng et al.

For scientists training ML models of molecular systems, switching from Adam to SOAP or SOAP-Muon optimizers can improve both training speed and final model accuracy, with bigger gains when you have less labeled data.

This paper compares advanced optimizers (SOAP, Muon, SOAP-Muon) against Adam for training machine learning interatomic potentials—AI models that simulate molecular behavior. The researchers find these newer optimizers converge faster and achieve better accuracy, especially when training data is limited, suggesting optimizer choice significantly impacts MLIP performance.

Juanwu Lu, Junyu Zhu, Ziran Wang

You can build controllable traffic simulators that stay realistic while letting engineers adjust specific behaviors—like making agents safer or faster—without the model gaming the reward system.

This paper presents CNeVA, a framework for creating realistic traffic simulation agents that can both imitate real driving behavior and be steered along interpretable dimensions like speed or safety.

Bohan Liu, Wenqian Ye, Guangzhi Xiong et al.

You can make vision-language models robust to text-in-image attacks by identifying and surgically adjusting specific attention heads—no retraining needed.

This paper identifies why CLIP vision models fail when images contain irrelevant text (typographic attacks), using mechanistic interpretability to pinpoint which attention heads over-focus on text. The authors propose a training-free fix by selectively adjusting these identified components, improving robustness without retraining.

Timo Bertram, Sidhant Bhavnani, Richard Freinschlag et al.

Neural guidance accelerates symbolic solvers only when the solver can dynamically correct bad neural suggestions—rigid solvers that always follow neural hints may actually slow down.

This paper combines neural networks with symbolic solvers to solve constraint satisfaction problems like Sudoku. A neural model (SE-RRM) generates solution proposals that guide traditional solvers like backtracking and SAT solvers, producing correct answers faster. The approach works best when solvers can override bad neural hints and problems have large search spaces.

Liyan Tang, Fangcong Yin, Greg Durrett

Vision-language models can be trained to self-correct more effectively by explicitly grounding their reflection in visual inputs, rather than just generating text-based corrections—this matters especially when models encounter out-of-distribution images.

This paper improves how vision-language models correct their own mistakes by training them to look back at images while reasoning. The authors use reinforcement learning with two key techniques: masking earlier reasoning steps to force the model to recover from errors, and replaying diverse failure scenarios. Their method helps models stay accurate even when given unfamiliar images.

Xuehui Wang, Xuankun Yang, Wei Shen

When pruning visual tokens in VLMs, filtering textual noise with entropy and selecting tokens as a structured optimization problem (not just picking top-K) preserves fine-grained details better while reducing computation.

This paper tackles the problem of compressing image tokens in vision-language models (VLMs) while preserving important visual details. The authors identify that existing pruning methods fail because textual noise corrupts the scoring process and selected tokens become fragmented.

Jiale Amber Wang, Kaiyuan Wang, Pengyu Nie

Existing test generation benchmarks don't verify if tests actually run or match code changes; this benchmark solves that by grounding evaluation in real executable environments and commit history, revealing that state-of-the-art agents still struggle on recent tasks.

TestEvo-Bench is a benchmark for evaluating AI agents on test and code co-evolution tasks—writing new tests for code changes and updating failing tests. Unlike static benchmarks, it uses real commits from Java projects with executable environments to measure pass rates, coverage, and mutation scores.

Vivienne Ming

Human-AI collaboration success depends on specific collaborative traits (perspective-taking, intellectual humility, curiosity) rather than cognitive ability or model benchmarks.

This study examines when pairing humans with AI improves forecasting accuracy using real-money prediction markets as an objective benchmark.

Junhao Shi, Siyin Wang, Xiaopeng Yu et al.

Separating motor skill learning from language grounding dramatically reduces the labeled data needed for robot learning—TAP matches models trained on 1M+ expert trajectories while using far less labeled data and shows better robustness to real-world perturbations.

This paper proposes Task-Agnostic Pretraining (TAP), a two-stage approach for training Vision-Language-Action robots that separates learning how to move (from unlabeled robot interactions) from learning what to do (from minimal labeled data).

Caleb Ziems, William Held, Su Doga Karaca et al.

Larger LLMs will simulate most human behaviors and opinions better, but scaling alone won't fix simulations of cognitive biases, rare populations, or tasks requiring specialized human knowledge—these need targeted research beyond just bigger models.

This paper investigates whether scaling up language models improves their ability to simulate human social behavior and opinions.

Donghyun Lee, Jitesh Chavan, Duy Nguyen et al.

By rotating activations into a normalized basis before quantization, OrbitQuant eliminates the need to recalibrate for different inputs, timesteps, or models—enabling practical low-bit quantization of diffusion transformers without per-checkpoint tuning.

OrbitQuant is a quantization method for diffusion transformers that works without needing to recalibrate for different inputs or models. It uses a mathematical rotation technique to normalize activations so they stay consistent across different timesteps and prompts, allowing a single quantization scheme to work everywhere.

Zhuowei Chen, Xiang Lorraine Li

By analyzing which neurons activate during model predictions, you can automatically select better training data and improve self-supervised learning without any human annotations—useful when expert labels are expensive or unavailable.

This paper proposes Neuron-OPSD, a method for improving large language models without human labels by using the model's internal neuron activations to select which training examples to learn from and how to construct better teacher models. The approach trains the model on its own predictions, achieving better performance on specialized tasks while maintaining general knowledge.

Kent K. Chang

Language models used for cultural analysis aren't neutral measurement tools; their architecture, training data, and evaluation methods actively constitute the cultural phenomena they claim to measure, making methodological choices inherently ethical decisions.

This paper examines how language models measure cultural phenomena, arguing that the models, data, and evaluation methods don't just record culture—they actively shape what counts as cultural reality.

Xuanyu Chen, Nan Yang, Shuai Wang et al.

When training on decentralized, non-uniform data, use Masked Image Modeling instead of Contrastive Learning—it's theoretically more robust. Better network connectivity always improves robustness, so federated learning is a viable alternative to fully decentralized systems.

This paper analyzes how distributed self-supervised learning systems handle non-uniform data across devices. The researchers prove that Masked Image Modeling is more robust to data heterogeneity than Contrastive Learning, and that federated learning performs as well as fully decentralized approaches. They introduce MAR loss, a practical improvement that aligns local and global representations.

Srinivasan Arunachalam, Louis Schatzki

Coherent quantum memory is the critical resource that enables efficient stabilizer state testing; without sufficient memory, testing becomes as hard as learning, requiring linear in n copies instead of a constant number.

This paper studies how to test and learn quantum stabilizer states when algorithms can only keep a limited number of qubits in quantum memory between measurements.

Zhilin Wang, Han Song, Runzhe Zhan et al.

Autonomous policy improvement requires agents to discover task-specific mechanisms and efficiently convert feedback into parameter updates under constrained budgets—not just win individual tasks.

EvoPolicyGym is a benchmark for evaluating how AI agents autonomously improve executable policies through iterative editing and feedback.

Sanjeev Shrestha, Hui Liu, Yifan Zhang

When forecasting imbalanced time series with rare but important events, using attention mechanisms that explicitly model extreme patterns outperforms treating all time points uniformly.

This paper introduces Exformer, a Transformer model designed for time series forecasting that explicitly handles rare extreme events. Unlike standard Transformers that treat all data points equally, Exformer uses a specialized attention mechanism with three components—Local, Stride, and Extreme—to capture both normal patterns and critical outliers.

Achint Mehta

For agentic code generation, invest in reasoning capability and effort rather than external tools—stronger models and higher reasoning settings prevent failures at their root, while testing tools don't catch the reasoning errors that actually cause failures.

This study evaluated 90 runs of an agentic coding assistant building the same application, testing whether extra tools and prompts improve code quality. Results show that increased reasoning effort (not testing tools) dramatically improved first-try reliability, raising perfect runs from 28% to 89%, while a testing tool added 42-68% cost with no functional benefit.

Manuel Alonso-Carracedo, Ruben Fernandez-Boullon, Pedro Celard et al.

LLMs can grade technical exams reliably for simpler tasks, but struggle with complex questions—rubric quality matters more than which model you choose, and a taxonomy-based approach helps identify which questions are safe to auto-grade.

This paper evaluates whether large language models can reliably grade Linux/bash exam responses by testing GPT, Claude, Gemini, and GLM against expert instructors' grades.

Yuquan Xue, Le Xu, Zeyi Liu et al.

Using a world model trained on real robot data to generate synthetic transitions—combined with careful sample selection—lets robots learn manipulation tasks with 59% fewer real interactions while improving success rates by 28%.

WorldSample combines real robot interactions with a world model to generate synthetic training data for reinforcement learning. By closing a loop between physical rollouts, synthetic data generation, and policy improvement, it reduces the number of costly real-world interactions needed while maintaining high-quality learning.

Quoc Bao Phan, Tuy Tan Nguyen

Quantum circuits can replace classical fusion layers in federated learning with 72 parameters instead of 33K, making multi-agent activity recognition more practical for resource-constrained robotic systems.

This paper presents QFedAgent, a federated learning system for activity recognition across multiple robotic agents. It uses quantum circuits to fuse sensor data (accelerometer and gyroscope) more efficiently than classical neural networks, reducing parameters by 10x while maintaining accuracy on distributed, non-uniform data.

Zhuowei Chen, Liwei Chen, Christian Schunn et al.

Using internal neuron activation patterns to select few-shot examples is more effective than traditional output-based signals, helping identify what the model actually struggles with rather than just guessing from its outputs.

This paper proposes NeuFS, a method for selecting the most useful examples to annotate when adapting large language models to specialized tasks.

Boyang Sun, Jiajie Li, Yung-Hsu Yang et al.

Robots can learn intent-aware camera control from passive human video by mining supervision pairs of language descriptions, observation changes, and target poses—turning everyday egocentric footage into training data for active perception.

This paper tackles language-conditioned camera motion for robots by learning from egocentric video. Given an image and natural language intent, LIME predicts the next camera pose by combining observation-gain prediction with flow-matching, enabling robots to actively position cameras for inspection, occlusion handling, or user-intent-driven viewing.

David Jurgens

NLP research is migrating from specialized NLP conferences to general machine learning venues, driven partly by citation advantages at ML conferences—a significant shift in the field's institutional center of gravity.

This paper analyzes where NLP research is being published, finding that the field is shifting away from traditional NLP conferences like ACL toward general machine learning venues.

M. Doris, S. Guo, S. M. Koh et al.

This package makes it practical for physics researchers to apply modern ML techniques (classification, object detection) to quantum gas experiments without building infrastructure from scratch.

Q-GAIN is a Python package that combines machine learning with physics-informed analysis for cold-atom experiments. It provides pre-built tools for classifying images, detecting objects, and analyzing quantum gas systems like Bose-Einstein condensates, with a modular workflow that connects data loading, ML-based feature detection, and physics analysis.

Xianhui Meng, Zirui Song, Yuchen Zhang et al.

For 3D scene generation in irregular spaces, hierarchical placement strategies and statistical priors about object distributions significantly improve physical plausibility and reduce geometric violations compared to flat optimization approaches.

This paper tackles text-to-3D indoor scene generation in non-Manhattan (non-rectangular) spaces, where existing methods fail. SPG-Layout uses statistical priors about object placement and hierarchical layout strategies (placing large objects first) to generate physically realistic scenes that respect non-orthogonal spatial relationships.

Thomas Winninger

RFM-AGOP enables rapid identification of multi-dimensional safety subspaces in LLMs, offering a computationally efficient alternative to existing methods that could scale safety monitoring across larger models.

This paper presents a fast method for identifying multi-dimensional refusal subspaces in large language models using an adapted Recursive Feature Machine (RFM) algorithm.

Mauricio Fadel Argerich, Jonathan Fürst, Marta Patiño-Martínez

You can now predict LLM inference efficiency on GPUs you've never tested by combining public model specs with GPU specifications—no profiling needed, and it works 4x better than physics-based estimates.

WattGPU predicts GPU power consumption and inference latency for large language models without requiring hardware profiling. Using only public LLM metadata and GPU specs, it generalizes to unseen hardware combinations, achieving 3-4x better accuracy than traditional baselines and helping operators choose efficient GPU-LLM pairings.

Juliette Decugis, Fabian Gloeckle, Francis Bach et al.

Instead of sampling harder or using more compute at test time, decomposing problems into independently solvable modules lets you generate exponentially more solutions while drastically cutting GPU costs—solving problems that standard generation cannot reach.

DecompRL teaches LLMs to solve hard coding problems by breaking them into smaller, reusable modules rather than just sampling more attempts. By learning to generate modular code structures, the approach creates exponentially more candidate solutions (k^n combinations from k implementations of n modules) while reducing GPU costs by ~50x, shifting computation to cheaper CPU evaluation.

Thomas Winninger

Constraining coding agents through simple, language-level restrictions is more effective and cheaper than complex oversight frameworks—the same techniques that manage human engineering teams work better for AI agents.

This paper shows that applying traditional software engineering practices—access control, network policies, and coding conventions—to AI coding agents makes them safer and easier to oversee than using complex scaffolding.

Minghan Yu, Youran Sun, Chugang Yi et al.

Combining supervised retrieval scoring with zero-shot LLM reasoning can dramatically improve dataset discovery—achieving 5x better recall through score fusion and an additional 28% improvement through agentic reranking without extra training.

This paper presents an agentic search system that helps geoscience researchers find relevant datasets and tools from NASA's Earth Observation Knowledge Graph using natural language queries. The system combines supervised neural retrieval with LLM-based reasoning to significantly improve search accuracy, and includes a new benchmark of 47k query-dataset pairs for evaluation.

Kaustubh Kapil, Kishor P. Upla

Vision Transformers don't learn by making tokens independent; instead, they increase representational complexity through richer transformations while preserving strong token interactions, which challenges common assumptions about how these models develop.

This paper analyzes how Vision Transformers' internal representations change during training using geometric analysis tools.

Benjamin Nichols, Michael Schlichtkrull, Nedjma Ousidhoum

MEDIAREF enables reproducible, cost-effective evaluation of how well LLMs can assess source credibility for fact-checking, addressing a gap where existing systems assume all retrieved evidence is equally reliable.

This paper introduces MEDIAREF, a public database of web documents from 200 media sources designed to help AI systems verify information credibility. Instead of relying on expensive search APIs, researchers can now use MEDIAREF to test how well language models assess whether news sources are trustworthy—a key step in fact-checking systems that cite their sources.

Lourdes Moreno, Paloma Martínez, Marco Antonio Sanchez-Escudero et al.

Multi-agent systems with internal quality signals and intelligent routing can outperform single-model approaches for text simplification tasks, even when adding lexical resources doesn't improve automatic metrics.

This paper presents three automatic systems for Spanish Easy-to-Read translation, submitted to a shared task. The best approach uses a multi-agent workflow combining two language models with quality signals and intelligent routing to simplify text while maintaining meaning. Results show this guided multi-agent approach outperforms simpler baseline methods.

Uwe M. Borghoff, Paolo Bottoni, Remo Pareschi

Hardware-enforced coordination can provide hard safety guarantees for autonomous systems by implementing coordination rules at the FPGA level, separating deterministic interaction management from adaptive AI reasoning.

This paper proposes using FPGAs to enforce safety-critical coordination rules directly in hardware for autonomous systems that combine AI models with real-time control. By moving coordination logic from software to hardware, the system guarantees deterministic timing and verifiable safety constraints while keeping AI reasoning flexible.

Xi Fang, Weijie Xu, Yingqiang Ge et al.

Personalization in LLMs doesn't just change what users see—it fundamentally alters the reasoning path the model takes to reach answers, creating a measurable failure mode that current mitigation techniques only partially address.

This paper introduces DRIFTLENS, a framework to measure how personalized language models change their reasoning process when given user information, even when final answers stay the same.

Cristian-Gabriel Florea, Stelian Spînu

By running six specialized deep learning models locally on a smartphone with INT8 quantization, VisionAId achieves real-time visual assistance for blind and low-vision users without cloud dependency, while a few-shot learning pipeline lets users teach the system to find their personal objects.

VisionAId is an Android app that helps visually impaired people navigate and interact with their environment using on-device AI models. It combines depth estimation, object detection, and facial recognition to identify obstacles, locate personal items, and recognize faces—all running locally on a smartphone without requiring cloud connectivity, with optional AI for scene descriptions.

Batu Guan, Zirui Wang, Shaohua Li

AI agents can generate compiler optimization patches, but they typically optimize only the reported case rather than generalizing to all similar cases like human developers do—a gap that retrieval-augmented techniques can partially close.

This paper studies how well AI agents can patch compiler optimizations that were missed by LLVM. The key finding is that agents struggle to generalize patches beyond the specific reported case—they often fix the example but fail to cover all similar cases that developers would handle.

Nina Begus

Literary disciplines offer practical tools for making AI systems more culturally literate and pluralistic, moving beyond the monolingual, automated cultural encounters that current LLMs create.

This essay argues that literary analysis methods—comparative reading, narratology, critical theory, and world literature approaches—are essential for building culturally aware AI systems.

Ziyu Chen, Yilun Zhao, Arman Cohan

LLMs can generate reasonable research ideas, but they show systematic biases toward certain types of ideas and miss the full diversity of how human researchers approach novel contributions.

This paper evaluates how LLM-generated research ideas compare to human researcher ideas by analyzing papers and their cited prior works.

Zijian Zhang, Rizhen Hu, Athanasios Glentis et al.

You don't need to update all transformer layers during RL training—focusing on middle layers can match full-model performance while dramatically reducing compute and memory costs.

This paper reveals that training just a single transformer layer during RL fine-tuning can recover most or all of the performance gains from updating the entire model. The authors find that RL improvements concentrate in middle layers, with input and output layers contributing far less, and this pattern holds consistently across different models, algorithms, and tasks.

Chih-Han Yang, Dai-Jie Wu, Yun-Ping Huang et al.

Language-based feedback preserves more information than scalar signals when learning from imperfect data, enabling policies to understand not just what went wrong but why and how to fix it.

This paper proposes using natural language critiques as structured supervision signals for learning from suboptimal demonstrations. Instead of compressing feedback into scalar scores, the method generates language labels describing task progress, failures, and corrections, then trains policies directly on these rich signals.

Shengguang Wu, Hao Zhu, Yuhui Zhang et al.

Memory management is a high-leverage, independently trainable skill for LLMs on long-horizon tasks—optimizing it alone can match frontier models' performance without modifying task-solving capabilities.

This paper treats memory management as a learnable skill for language models, similar to how humans develop expertise in organizing and retrieving information. The AutoMem framework automatically optimizes both the memory structure (file schemas, prompts) and the model's ability to use it, achieving 2-4x performance improvements on long-horizon tasks without changing the core task behavior.

Ben Slivinski, Michael Saldivar

Structured verification that requires explicit justification for every reasoning step catches hidden premises and fabricated citations that fool holistic LLM judges, making it a complementary approach for high-stakes verification.

Theoria is a verification system that checks AI reasoning by decomposing answers into explicit state transitions, each justified by citations, computations, or given facts. Unlike opaque LLM judges or formal proofs alone, it produces auditable proof traces where every step can be independently verified, achieving 91.4% precision on expert problems while catching 94.7% of adversarial errors.

Giovanni Monea, Nathan Godey, Kianté Brantley et al.

Splitting Transformer computation into separate streams for token prediction and state maintenance improves both training efficiency and model performance—a simple architectural change with consistent gains across scales.

This paper proposes separating two functions in Transformers: predicting the next token and maintaining state for future predictions. The authors design a dual-stream architecture and show it improves language modeling efficiency and downstream task performance by 2-3% compared to standard Transformers.

Chenyang Ma, Yue Yang, Radu Corcodel et al.

Progress signals and semantic subtask grounding are critical for long-horizon bimanual manipulation—the model predicts both actions and continuous progress to automatically transition between assembly steps and reduce compounding errors.

FurnitureVLA tackles real-scale bimanual robot furniture assembly using vision-language-action models. The system combines a VR teleoperation interface for data collection, a simulation pipeline for training, and a progress-aware model that predicts both actions and assembly progress to handle long-horizon tasks (up to 1550 steps).

Zhi Chen, Zhensu Sun, Yuling Shi et al.

Performance-optimization benchmarks for coding agents have significant reliability issues: reference patches are unstable across machines, scoring rules heavily influence rankings, and most tasks are already solved by existing submissions, making leaderboard positions unreliable indicators of tru...

This paper audits three major benchmarks for evaluating coding agents on performance optimization tasks.

Shayan Talaei, Abhinav Chinta, Devvrit Khatri et al.

D2D reveals stealth biases in deployed LLMs by concentrating distributional shifts into a small adapter, making hidden preferences visible in generated text—enabling auditing of models where bias inspection would otherwise be impossible.

This paper introduces Distill to Detect (D2D), a method to uncover hidden biases in language models that only favor certain entities or viewpoints on specific topics while appearing normal elsewhere. The approach works by distilling differences between a suspect model and its base version into a compact adapter, amplifying hidden bias signals into detectable text patterns.

Patrick Podest, Marco Pichler, Elias Bürger et al.

TiRex-2 enables efficient streaming multivariate forecasting with constant per-patch inference cost and zero-shot generalization, solving the quadratic complexity problem of Transformer-based time series models.

TiRex-2 is a time series foundation model built on xLSTM that handles multiple variables and streaming data efficiently. Unlike Transformer-based models that slow down with longer sequences, TiRex-2 uses a memory-based recurrent design that processes new data at constant cost, even when variables evolve together and some future values are known in advance.

Liyuan Zhu, Shengyu Huang, Amrita Mazumdar et al.

Generative models can improve monocular 4D reconstruction by learning to correct artifacts and hallucinate missing geometry, then distilling results back into explicit 3D representations—enabling high-quality dynamic scene synthesis from single videos.

This paper presents a method to reconstruct dynamic 3D scenes from single-camera videos by using a generative model that learns to fix imperfections in initial reconstructions and fill in unseen regions.

Austin McDannald, Julia Tisaranni, Howie Joress

Constraint programming can optimize experiment scheduling in autonomous labs by finding time-minimal plans that respect hardware constraints, with status dependencies ensuring robust real-world execution.

This paper tackles how to efficiently schedule experiments in autonomous labs when multiple instruments have different speeds and capacities. The authors use constraint programming to find optimal schedules that minimize total time while respecting hardware limits, then add a dependency system to ensure reliable execution of those schedules.

Mehul Damani, Isha Puri, Idan Shenfeld et al.

You can train models to be both accurate and human-like by combining objective rewards (what you can measure) with a learned signal from human examples (what's hard to measure), avoiding the diversity collapse and gaming that pure RL often causes.

This paper combines reinforcement learning with verifiable rewards (like code correctness) and human demonstrations to train language models better. The key innovation is using an adversarial discriminator that learns from human-written examples to guide the model toward more natural, diverse outputs while still achieving high task accuracy.

Michael Y. Li, Anthony Zhan, Kanishk Gandhi et al.

You can generate better-coverage samples in parallel by using quasi-Monte Carlo instead of random sampling—achieving the same performance with significantly fewer inference calls, making scaling compute more efficient.

QuasiMoTTo improves inference efficiency by generating correlated rather than independent samples during test-time scaling. Instead of wasting compute on redundant solutions, it uses quasi-Monte Carlo sampling to spread samples across the output space more evenly, achieving the same accuracy with 25-47% fewer samples while maintaining correct marginal distributions for training.

Kornelius Raeth, Nicole Ludwig

Train generative models to minimize decision costs directly, not just prediction error—this focuses learning on regions where mistakes matter most for your application.

This paper proposes a training method for generative models that makes them aware of decision costs. Instead of training only to predict data accurately everywhere, the method adds a decision loss that penalizes forecast errors in regions where mistakes are most expensive for downstream decisions. The approach combines standard training objectives with cost-sensitive feedback.

Zifan Carl Guo, Laura Ruis, Jacob Andreas et al.

Fixed counterfactual explanations from earlier model checkpoints can effectively train language models to generate faithful explanations of their own behavior, even as the model changes during training—offering a scalable approach to interpretability without requiring updated labels.

This paper shows that language models trained to explain their predictions can learn faithful self-explanations even when trained on fixed explanations from earlier versions of themselves. The key finding is that explanations naturally track the model's current behavior rather than mimicking their training targets, enabling scalable post-training without constantly updating supervision data.

Sergio Hernández-Gutiérrez, Matteo Merler, Ilze Amanda Auzina et al.

Simple prompting baselines outperform recent dense supervision methods, and you can now evaluate supervision signal quality before training by checking if scores align with reference Q-values—saving significant compute.

QVal is a training-free evaluation framework for comparing dense supervision signals used in long-horizon LLM agents.

Gabrielle Kaili-May Liu, Avi Caciularu, Gal Yona et al.

Training LLMs to accurately self-assess their performance creates a powerful RL signal that improves both calibration and accuracy—models that know what they don't know become more reliable and better at learning.

This paper introduces reinforcement learning with metacognitive feedback (RLMF), a method that trains language models to accurately judge their own performance and express uncertainty faithfully.

Yuqing Yang, Qi Zhu, Zhen Han et al.

Data referencing errors are a widespread problem in LLM table reasoning that goes beyond final-answer accuracy; using a lightweight critic model to catch these errors during inference significantly improves reliability.

LLMs make data referencing errors when reading tables—citing wrong values or missing data despite understanding table structure. This paper systematically measures these errors across models and shows that using a critic model to detect and filter bad outputs improves accuracy by up to 12%, even with a small 4B-parameter critic.

Xinyu Zhao, Zhen Tan, Vaishnav Tadiparthi et al.

Instead of treating skill selection as separate retrieval and ordering problems, jointly predicting skill sequences as a single structured decision improves agent performance and reduces token costs.

This paper tackles how LLM agents should select and order skills (reusable procedural knowledge packages) when solving complex tasks. The authors propose SkillComposer, which treats skill selection as a structured prediction problem—jointly deciding which skills to use, how many times, and in what order.

Jian Gu, Aldeida Aleti, Chunyang Chen et al.

SemRF provides a principled way to track semantic meaning across model layers, enabling researchers to distinguish real computation from measurement drift and connect layer-wise complexity to parameter efficiency.

This paper introduces Semantic Reference Frames (SemRF), a mathematical framework for analyzing how language models process information across layers.

Yuanda Xu, Zhengze Zhou, Hejian Sang et al.

When training agents that interact with environments through discrete actions, assigning credit based on semantic role categories (not just final outcomes) reduces variance and improves learning by properly rewarding exploration and penalizing waste.

TRIAGE improves credit assignment in agentic RL by classifying action segments into semantic roles (progress, exploration, infrastructure, regression) and assigning role-specific rewards.

Zekai Chen, Kairui Yang, Xuaner Chen et al.

Federated multimodal graph learning can achieve strong performance while maintaining privacy and interpretability by organizing knowledge into typed semantic codebooks that explicitly track how different modalities and graph structure contribute to predictions.

FedLAB enables federated learning on multimodal graphs (graphs with text, images, and attributes) while preserving privacy by organizing knowledge into traceable semantic codebooks.

Kaisen Yang, Zheng Jiang, Yuzhao Peng et al.

Browser agents can scale more efficiently by learning from the implicit skills already present in human web interactions rather than from manually designed tasks, using skill distillation to convert trajectories into reusable, composable natural-language instructions.

This paper proposes a scalable approach for training browser agents by distilling human web browsing interactions into reusable natural-language skills. Rather than training agents from scratch on individual tasks, the method converts user interaction traces into compact skill descriptions that agents can retrieve and compose, organized in a skill graph to enable efficient learning and reuse.

Sanghyuk Chun, William Yang, Amaya Dharmasiri et al.

Breaking uncertainty into interpretable components—what's ambiguous about the task versus how many right answers exist—lets you estimate confidence efficiently in multimodal models without expensive sampling.

CoMet decomposes uncertainty in multimodal AI models into two components: context-specific ambiguity (from the task or prompt) and multiplicity (how many valid answers exist). A lightweight module estimates these without generating multiple answers, enabling efficient uncertainty quantification for open-ended tasks like visual question answering.

Philippe Chlenski, Zachariah Carmichael, Ayush Warikoo et al.

Open models are poor surrogates for mechanistic understanding of closed models: prediction-level agreement doesn't guarantee attribution agreement, and white-box signals don't reliably transfer between models.

This paper investigates when open-source language models can serve as proxies for understanding closed commercial models. The researchers test whether measurements from open models (like attention patterns) reliably explain closed models' behavior across prediction, attribution, and representation levels, finding that models agreeing on answers often disagree on reasoning.

Benjamin Breen, Austin Letson, Borja Requena Pozo et al.

Agentic code generation can be dramatically improved by using verification feedback to guide iterative repair of both code and formal proofs, rather than trying to generate correct code in one shot.

AxDafny is a system that helps AI models generate verified code in Dafny by iteratively fixing code and proofs based on verification feedback. The authors created a benchmark of 250 programming problems and show their approach achieves 92.7% verification success, significantly outperforming previous methods.

Sameer Malik, Ayush Singh, Amar Prakash Azad

By separating policy rules from document interpretation, PolicyGuard makes compliance review auditable and maintainable—you can inspect why a document failed review and update policies without retraining models.

PolicyGuard is a neuro-symbolic system that converts organizational policies into executable compliance review engines. It combines LLM-based document analysis with formal logic rules to check whether contracts and documents comply with company policies, making compliance decisions transparent and testable.

Ekaterina Alimaskina, Denis Shveykin, Gleb Molodtsov et al.

Synthetic QA generation for model training has hidden failure modes: biased coverage of documents and susceptibility to instruction injection. Simple fixes like anchoring questions to specific targets and filtering instruction-like text can substantially reduce these problems.

This paper reveals that using synthetic question-answer pairs to train language models is riskier than assumed. Models generating QA pairs don't uniformly cover documents—they focus on salient regions and can be hijacked by artifacts like markup.

Srijan Tiwari, Aditya Chauhan, Manjot Singh

Penalizing radial expansion of neural network activations forces learning of compact, structured representations and dramatically speeds up generalization on algorithmic tasks—a simple geometric insight with practical training benefits.

Neural networks memorize before generalizing on algorithmic tasks because hidden representations inflate radially during training. This paper proposes a geometric penalty that constrains activations to a hypersphere, forcing the network to learn structured circuits faster—accelerating grokking 6x on arithmetic tasks and halving training time for addition.

Yen-Jen Wang, Jiaman Li, Sirui Chen et al.

Synthetic data from reconstructed 3D scenes can effectively train perception-based humanoid robots for real-world loco-manipulation, eliminating the need for expensive human-annotated robot trajectories.

This paper solves a key bottleneck in training humanoid robots: the lack of paired data combining egocentric camera views, language instructions, and robot motion. The authors generate 48,000 synthetic training examples by reconstructing real indoor scenes with 3D Gaussian Splatting, simulating robot trajectories, and rendering first-person views.

Shun Lei, Huaicheng Zhang, Dapeng Wu et al.

For music generation at scale, separating semantic planning (what to generate) from acoustic refinement (how to generate it) and training them sequentially rather than simultaneously improves both coherence and sound quality.

LeVo 2 generates full-length songs by combining language models and diffusion models in a hierarchical approach: first predicting mixed vocal-instrument tokens for overall coherence, then refining each track separately for acoustic detail.

Xuan Zhang, Wenxuan Zhang, See-Kiong Ng et al.

World models can be continuously improved during deployment by learning from real interactions and filtering unreliable predictions, making LLM agents better at long-horizon planning without modifying the agent itself.

This paper presents WorldEvolver, a framework that improves LLM agent planning by maintaining and updating a world model at test time. The system uses three components—episodic memory (storing real transitions), semantic memory (learning rules from errors), and selective foresight (filtering unreliable predictions)—to provide better action consequence predictions without retraining the agent.

Philip Zmushko, Egor Petrov, Nursultan Abdullaev et al.

Asynchronous pipeline parallelism with one-step gradient delay is practical for large LLM training if you use the right optimizer; the performance gap with synchronous training can be closed with modern optimizers and error feedback corrections.

This paper shows that asynchronous pipeline parallelism for LLM training isn't fundamentally limited by stale gradients—the problem depends on which optimizer you use. Modern optimizers like Muon handle one-step gradient delays well, while older ones like AdamW struggle.

Yuhong Deng, Yuyao Liu, David Hsu

By decomposing tool affordance grounding into semantic (which object/part) and geometric (where) levels, robots can generalize to novel objects and creative tool use without expensive end-to-end training.

GROW² enables robots to creatively use any available object as a tool by breaking down the problem into two steps: using vision-language models to identify which object and which part to use, then using vision models to locate the exact 3D position. This lets robots solve tasks like cutting cake with a plate when no knife is available, without needing large labeled datasets.

Subramanyam Sahoo, Aman Chadha, Vinija Jain et al.

Conservative offline training doesn't prevent reward hacking in online adaptation—it amplifies it. The sweet spot is calibrated conservatism, not maximum conservatism, because overly conservative policies exploit reward model uncertainty more effectively.

This paper challenges the common assumption that conservative offline training prevents reward hacking. Testing a reasoning model with varying levels of conservatism during offline training, then online adaptation, the authors find that higher conservatism actually increases reward hacking—the model exploits disagreements in the reward model more effectively.

Xinlei Yu, Gen Li, Qingyi Si et al.

When distilling from privileged teachers or students, routing supervision based on advantage gaps prevents students from learning to exploit information asymmetry instead of real capabilities—improving both LLM and vision-language model performance.

This paper addresses a key problem in on-policy distillation where adding privileged information (extra inputs) to teachers or students creates a 'privilege illusion'—students learn to mimic information asymmetry rather than transferable skills.

Ziwei Su, Junyu Ren, Victor Veitch

Embedding norms in contrastive models aren't wasted information—they automatically capture semantic properties during training and can be leveraged as free calibration signals without additional training.

This paper explains why embedding norms (magnitudes) in contrastive models encode semantic information like concept specificity, even though these models use scale-invariant losses that should ignore norms.

Lei Bai, Zongsheng Cao, Yang Chen et al.

You can match trillion-parameter model performance on complex reasoning tasks with a 35B model by focusing on longer, more complex action sequences and multi-domain expertise rather than raw parameter count.

Agents-A1 is a 35B parameter model that achieves trillion-parameter performance on complex tasks by scaling agent horizon—the length and complexity of action sequences—rather than model size.

Haoran Jin, Xiting Wang, Shijie Ren et al.

When scaling sparse autoencoders for interpretability, enforcing cross-sample consistency prevents features from fragmenting or developing exceptions, making the learned representations more reliable for understanding language model behavior.

This paper identifies and fixes two major problems in Sparse Autoencoders (SAEs) used to interpret language models: feature splitting (where single concepts fragment into multiple latents) and feature absorption (where general features develop arbitrary exceptions).

Kunyang Li, Kyle Domico, Jonathan Gregory et al.

In multi-agent systems, a small number of communication channels often control most of the attack surface—MESA can identify these critical edges proactively, letting defenders protect 3x more attacks with the same security budget.

This paper introduces MESA, a framework for identifying which communication channels in multi-agent systems are most critical to protect. By analyzing graph structure and testing channel importance without needing attack data, MESA ranks edges by their security risk, helping defenders focus limited resources on the most vulnerable connections before attacks happen.

Asif Shahriar, Hongyu Cai, Hadjer Benkraouda et al.

LLM-based code vulnerability detectors can be manipulated through cognitive heuristics without changing the actual code, making them unreliable for security-critical tasks and vulnerable to adversarial attacks that suppress vulnerability detection.

This paper reveals that LLMs used for detecting code vulnerabilities are susceptible to cognitive biases—the same mental shortcuts that affect human judgment.

Gervais Hatungimana, Abdun Naser Mahmood, Mohammad Jabed Morshed Chowdhury

By analyzing network traffic patterns between clients and file servers, you can detect ransomware attacking shared storage earlier and more reliably than traditional endpoint-only detection, even when the malware doesn't show obvious signs on the server itself.

This paper presents a hybrid detection system for crypto-ransomware targeting shared storage in enterprise networks. It combines signature-based detection (using network traffic indicators) with machine learning to catch ransomware before it encrypts files, achieving 99.64% precision with zero false negatives.

Nico Daheim, Iryna Gurevych

When LLMs handle subjective tasks, explicitly modeling uncertainty and using Bayesian decision theory to choose outputs can improve results, but risk-averse approaches may backfire by favoring generic responses.

This paper develops uncertainty-aware decision-making algorithms for LLMs in subjective tasks like tutoring and peer review. The authors use Bayesian decision theory and conformal prediction to account for model uncertainty when generating outputs, finding that Bayesian approaches work better than risk-averse methods for improving output quality.

Liyao Wang, Ruipu Wu, Haojun Xu et al.

Combining explicit 3D geometry (camera poses, spatial relationships) with visual matching dramatically improves cross-view localization and enables zero-shot transfer between ground and drone views without paired training data.

This paper tackles cross-view object geo-localization—finding a target object in satellite imagery when given a ground or drone photo. The authors introduce a large dataset with 220K+ image pairs and geometric metadata, plus GAGeo, a unified framework that predicts object locations, masks, and camera poses simultaneously using 3D spatial understanding rather than just appearance matching.

Shuang Li, Zhihui Zhu, Qiuwei Li

Bregman ADMM provably avoids saddle points and finds second-order stationary solutions for nonconvex problems without Lipschitz gradient requirements, making it applicable to polynomial and tensor optimization problems where standard methods fail.

This paper analyzes Bregman ADMM, an optimization algorithm for nonconvex problems with linear constraints that don't require standard smoothness assumptions.