Papers

Yifan Zhou, Qihao Yang, Yan Li et al.

Current LLMs struggle with scientific lineage reasoning (only 27.3% accuracy), suggesting AI systems need better mechanisms to understand how ideas inherit, mutate, and recombine across research communities.

This paper introduces IdeaGene-Bench, a benchmark for evaluating whether AI systems can understand how scientific ideas evolve and build on each other. It represents papers as 'Idea Genomes' with tracked inheritance patterns, and tests both reasoning about scientific lineages and generating new ideas that fit coherently into existing research traditions across 10 scientific domains.

Yiwei Zhou

Training diffusion models with low forward-marginal error doesn't guarantee stable sampling—you need additional safeguards like denoiser projection to ensure numerical stability and convergence of sample moments.

This paper reveals a critical gap in diffusion model training: a score function can have tiny errors on average (as measured during training) yet produce numerically unstable sampling with diverging moments. The authors prove this theoretically and show that projecting learned denoisers onto known data bounds fixes the problem.

Nathan Pruyne, Benjamin Stoler, William Chen et al.

Automatic music transcription models still struggle with real-world pop music—the best model only achieves 38% Onset F1—suggesting this dataset will be valuable for developing better transcription systems.

MulTTiPop is a dataset of 572 pop music segments (3.5 hours) paired with multitrack MIDI transcriptions, spanning from the 1930s to 2000s. The authors created it by matching audio from existing datasets, manually aligning beats, and using tempo warping. They benchmark state-of-the-art transcription models and show significant room for improvement.

David González-Martínez, Shiwei Liu

You can make models significantly more compressible during training with a simple regularizer that costs less than 1% extra compute and doesn't require changing your model architecture or doing expensive matrix decompositions.

SLORR is a training-time regularization method that makes neural networks easier to compress using low-rank factorization. Unlike existing approaches, it works directly on weight matrices without requiring expensive computations, architectural changes, or cached data, adding minimal training overhead while improving how well compressed models perform.

Kristina Schaaff, Quintus Stierstorfer, Valerie Heckel

Large-scale log data shows AI learning assistants are already integrated into student routines, but usage varies substantially across demographics and study contexts—critical insights for designing inclusive educational AI.

This study analyzes real usage data from 77,543 students using Syntea, an AI learning assistant, to understand how different groups actually use educational chatbots. Unlike previous small surveys, this large-scale analysis reveals that usage patterns vary significantly by gender, age, study program, and other factors—providing concrete evidence for improving AI tutoring tools.

Duen Horng Chau, Donghao Ren, Fred Hohman et al.

The kNN graph UMAP builds internally preserves high-dimensional structure better than the 2D visualization; applying network analysis to it gives you cleaner insights into data organization than the embedding alone.

UMAP is popular for visualizing high-dimensional data, but researchers typically ignore its internal k-nearest-neighbor graph.

Siddharth Damodharan, Radhika Gupta, Ali Alshami et al.

Current vision-language models struggle with safety-critical reasoning in autonomous driving; this benchmark provides a standardized way to measure whether they can understand incident context and predict avoidability.

AUTOPILOT-VQA is a benchmark dataset for evaluating vision-language models on safety-critical dashcam understanding. It uses structured questions about real-world driving incidents to test whether AI systems can reliably reason about weather, traffic, road conditions, and accident scenarios—moving beyond simple object recognition to temporally grounded, safety-aware reasoning.

Kaifeng Zhao, Mathis Petrovich, Haotian Zhang et al.

For interactive applications, ARDY trades off some offline generation quality to achieve real-time streaming motion synthesis with flexible text and kinematic control, making it practical for animation tools and robotics where responsiveness matters as much as precision.

ARDY is a real-time motion generation system that creates realistic 3D human animations from text prompts and pose constraints.

Emanuele Quinto, Carlo Andrea Rozzi, Francesco Zanitti

Workflows can be represented as first-class knowledge objects that persist and remain queryable, making it easier to inspect, resume, and audit LLM-based processes—moving beyond treating workflows as black boxes that just produce outputs.

This paper proposes a conceptual model for LLM workflows that treats workflow definitions, instances, and execution traces as persistent knowledge objects. It distinguishes between deterministic computation (derive) and LLM-mediated judgment (infer), enabling workflows to be inspectable, resumable, and reviewable rather than just producing outputs and leaving traces.

Baha Rababah, Cuneyt Gurcan Akcora, Carson K. Leung

Standard accuracy metrics mask real behavioral divergence in quantized models—you need decision-level metrics to catch when quantized and base models disagree, even when both maintain similar overall performance.

This paper reveals that quantization (compressing LLMs to lower bit-widths) preserves accuracy metrics like perplexity but causes hidden behavioral changes. The authors introduce a new metric called correctness agreement to detect when quantized models make different predictions than base models, and analyze how quantization distorts attention weights differently across model layers.

Shreyas Subramanian, Adewale Akinfaderin, Akarsha Sehwag

Just because a parameter is important for inference doesn't mean training it in isolation will work—effective fine-tuning needs structured updates across entire layers, not surgical targeting of individual weights.

This paper challenges the assumption that 'Super Weights'—individual parameters whose removal severely hurts model performance—are good targets for selective training. The authors show that training only these supposedly critical parameters actually fails catastrophically, while training random parameters in the same layers works fine.

Manuel Pita

High agreement between LLMs and human annotators doesn't guarantee the model understands the construct being measured—you need to test whether the model follows the theory's logic or just correlates with surface features.

This paper tests whether Portugal's AMALIA language model can reliably annotate moral concepts by comparing its agreement with human coders against its actual understanding of the underlying construct.

Ayda Eghbalian, Kevin Desai

You can now add biomechanical analysis (forces, activations, loads) to any existing 3D pose estimator without retraining it, making markerless motion capture useful for rehabilitation, sports, and clinical applications.

This paper introduces BioModule, a lightweight transformer that converts 3D skeletal poses from any pose estimator into biomechanical quantities like joint forces and muscle activation. By aligning Human3.6M video data with biomechanical labels, the authors show how pose estimation errors propagate to biomechanical predictions across seven different pose estimators.

Chuning Zhu, Eva Xu, Jose Barreiros et al.

Reasoning for robot control can be learned by treating it as variational inference over a latent space, allowing policies to adaptively allocate computation at test time while maintaining spatial understanding needed for precise physical actions.

This paper introduces Latent Memory Palace (LMP), a method that enables control policies to reason adaptively by organizing information in a learned latent space. Rather than reasoning in language, the approach uses variational inference to create an interpretable, memory-palace-like structure where the policy retrieves information iteratively.

Yifan Wu, Lizhu Zhang, Yuhang Zhou et al.

Active memory management—deciding *when* to remind an agent about past information—outperforms passive retrieval and improves long-horizon task performance by 6-8% across benchmarks.

This paper tackles 'behavioral state decay' in long-horizon tasks—where important information gets buried in expanding context windows. Instead of passive memory retrieval, the authors propose a separate memory agent that actively monitors trajectories, maintains a structured memory bank, and selectively injects relevant reminders into an action agent's decision-making.

Xiao Fu, Yue Hu, Meida Chen et al.

By using old elevation maps as geometric guides, you can reconstruct 3D terrain from images without expensive feature matching, making wildfire hazard assessment faster and cheaper for emergency responders.

This paper presents a method for creating accurate 3D terrain maps of wildfire-prone areas by combining outdated elevation data with aerial images. Instead of expensive LiDAR or slow image-matching approaches, the method uses physics-based alignment between images and existing digital elevation models to reconstruct terrain quickly and accurately.

Harrison Rush, Vincent Davis, Simone Antonelli et al.

Graph RL with action masking and curriculum learning can solve real-world network optimization problems better than heuristics, and this approach is now live managing millions in Bitcoin transactions.

This paper solves the problem of optimizing liquidity placement in Bitcoin's Lightning Network using deep reinforcement learning. Given a budget, nodes must decide which payment channels to open to maximize routing capacity. The authors train a graph neural network agent with PPO to select the best k channels, using a curriculum that prevents the model from simply copying hub nodes.

Ethan Leung, Elias Lumer, Corey Feld et al.

You don't need the most expensive LLM to judge citation quality—cheaper models match frontier models on accuracy—but all judges have directional biases that must be calibrated before using them as reward signals in AI training.

This paper evaluates which LLM judges are suitable for scoring citation quality in AI research systems. Researchers tested 8 different LLMs on 1,248 citation evaluations and found that cheaper models like GPT-4-mini perform comparably to expensive frontier models, but all judges have hidden biases in false positive/negative rates that could distort AI training if not addressed.

QiHong Chen, Aaron Imani, Iftekhar Ahmed

Procedural similarity—finding functions that solve problems the same way—is a powerful but overlooked retrieval signal for code generation that works better than traditional lexical or semantic matching alone.

ProjAgent improves repository-level code generation by retrieving functions with similar procedural logic, not just similar keywords or structure. It breaks down target functions into reasoning steps, finds repository functions that follow similar procedures, and combines this with semantic search and compiler feedback to generate better code.

Guoxuan Xia, Luka Ribar, Paul Balanca

Relaxed speculative decoding can speed up LLM inference but requires careful evaluation of capability trade-offs and works best with high-quality draft models—it's not a simple drop-in replacement for lossless speculative decoding.

This paper examines relaxed speculative decoding, a technique that speeds up LLM inference by allowing small deviations from the original model's output distribution. Unlike standard speculative decoding which preserves exact output probabilities, relaxed approaches trade some accuracy for faster generation.

Shilin Ou, Yifan Xu, Luyao Zhang

Evaluating trustworthy AI agents in real-world systems requires measuring multiple dimensions beyond task performance—including physical safety, fairness, and auditability—and building in transparent oversight mechanisms that log all interventions.

SolarChain-Eval is a benchmark for testing AI agents in decentralized energy markets, measuring both how well they perform economically and whether they behave safely and fairly. It uses physics rules to prevent agents from exploiting invalid data, and includes an AI auditor that reviews risky decisions.

Teng-Ruei Chen

When you have a limited budget per query and an imperfect way to check if outputs are correct, you should dynamically decide whether to resample your current model or switch to a different one based on estimated correctness gains per unit cost.

This paper addresses how to optimally allocate a per-query budget between resampling (generating multiple outputs from the same model) and rerouting (switching to a different model) when using an imperfect verifier to check correctness.

Xiaoshuai Song, Liancheng Zhang, Kangzhi Zhao et al.

For complex research tasks, recursive multi-agent delegation with shared process experience outperforms both single agents and flat multi-agent systems by handling depth and breadth simultaneously.

WebSwarm is a multi-agent framework that orchestrates recursive web search by dynamically decomposing tasks and delegating them across specialized agent nodes. Each node decides whether to search directly or spawn child nodes, enabling deeper and broader information gathering than single-agent systems while sharing experience across similar subtasks.

Wenxiu Ding, Muzhi Liu, Zheng Yan et al.

You can preserve graph privacy without destroying utility by selectively removing edges based on their likelihood rather than adding uniform noise everywhere—EdgeRefine improves accuracy by 17-20% over baselines while maintaining strong privacy guarantees.

EdgeRefine tackles privacy leaks in Graph Neural Networks by using Jaccard similarity to intelligently sample edges while maintaining differential privacy. Instead of adding noise uniformly across all edges, it estimates which edges are most likely real and strategically removes false edges, achieving much better accuracy-privacy trade-offs than existing methods.

Eugene Ng Yi Sheng, Bingquan Shen

Mediation mechanisms can help multi-agent systems resist market collapse from self-interested behavior and coordinated attacks, though no mechanism is unbreakable—the key is recovery resilience.

This paper studies how formal mechanisms (like mediation) help groups of self-interested AI agents maintain stable markets and trade fairly. Using 18 LLM agents in a simulated marketplace, researchers tested eight different mechanisms against increasing numbers of disruptive agents and adversarial attacks, finding that mediation works best and can recover even under sustained attack.

Amirhossein Taherpour, Xiaodong Wang

Decentralized federated learning can achieve Byzantine-resilient consensus and finality by leveraging the same gossip history used for model distribution, eliminating the need for a central coordinator or global consensus mechanism.

This paper introduces gspDAG-FL, a decentralized federated learning system that uses gossip communication and a directed acyclic graph (DAG) structure to achieve consensus without a central server.

Ali Larian, Qian Lin, Chang Zong Wu et al.

To learn reward functions that generalize across environments, you need to teach the agent in multiple diverse environments and mix different feedback types—not just collect demonstrations in one setting.

This paper tackles a key challenge in deploying AI agents: learning reward functions that work across different environments rather than just the one where training happened. The authors show theoretically that different types of human feedback (like comparisons vs.

Xinlong Zhao, Dongsheng Liu, Hengyu Zhao et al.

As data quantity plateaus, improving LLM performance now requires smarter data quality refinement—UltraX shows you can train a specialized editing model that's both efficient and reliable enough to process massive datasets and improve downstream model quality.

UltraX is a framework that automatically improves training data quality at scale by learning to edit text through insertion, deletion, and modification. Instead of relying on fixed rules or expensive LLM calls, it trains a model to make targeted edits by learning from examples of how an expert LLM would refine raw text, achieving better model performance with less data.

Chen Tang, Yizhou Wang, Jianyu Wu et al.

By making molecular and crystal structures inspectable during reasoning, SciReasoner achieves state-of-the-art predictions while generating human-readable explanations—showing how AI can solve chemistry and materials problems while remaining scientifically interpretable.

SciReasoner is a multimodal AI model that reasons about structure-property relationships in proteins, molecules, and crystals by treating structural information as interpretable evidence. It discretizes 3D coordinates and chemical topologies into a unified vocabulary, enabling transparent predictions grounded in scientific principles like bonding and symmetry.

Yair Feldman, Linxi Zhao, Nathan Godey et al.

Externalizing factual knowledge to a continuous vector-indexed database lets smaller models achieve better factual accuracy and knowledge control than larger models, while keeping retrieved facts attributable and editable.

This paper introduces CO-LMLM, a language model that stores factual knowledge in an external database with continuous vector keys instead of memorizing facts in its weights. During generation, the model queries this knowledge base flexibly and retrieves human-readable information to cite.

Anna Kuzina, Paul N. Whatmough, Babak Ehteshami Bejnordi

Linear attention mechanisms can match standard transformer performance if you design the state updates correctly; the paper shows which architectural choices matter most for maintaining accuracy while cutting inference cost.

This paper analyzes why transformer self-attention is expensive and proposes a linearized alternative that reduces computational cost from quadratic to linear. By studying how attention mechanisms work mathematically, the authors identify key design principles—like using delta-style updates and sink tokens—that preserve model quality while dramatically speeding up inference on long documents.

Ying Chang, Jiahang Xu, Xuan Feng et al.

When optimizing agents through reflection, extracting causal root causes from execution traces—rather than using raw or naively truncated traces—significantly improves learning efficiency and prevents overfitting to low-value failures.

This paper presents STRACE, a framework that helps LLM-based agents learn from their failures more effectively. Instead of using raw execution traces directly, STRACE filters out redundant failures at the batch level and identifies causally important steps within each trace, creating cleaner optimization signals for agent improvement.

Victor Giannakouris, Immanuel Trummer

LLMs can synthesize database-specific file readers from documentation, enabling direct storage access that bypasses driver overhead—a practical way to escape vendor lock-in and accelerate analytical workloads.

Jailbreak uses LLMs to automatically generate code that reads database storage files directly, bypassing slow database drivers. By analyzing database source code and documentation, the system synthesizes custom readers that convert PostgreSQL and MySQL data into in-memory columnar formats, achieving up to 27x faster analytics without modifying the database.

Yujiao Chen

Deployment rules causally shape multi-agent AI safety as much as model choice does.

This paper introduces institutional red-teaming, a method to test how deployment rules (not just AI models) affect multi-agent safety.

Eric Zhu, Abhinav Shrivastava, Soumik Mukhopadhyay

Not all timesteps and trajectories in diffusion model training contribute equally to learning—by selectively weighting informative steps and replaying valuable past samples, you can dramatically reduce the amount of human feedback needed to align diffusion models.

This paper improves the efficiency of reinforcement learning from human feedback (RLHF) applied to diffusion models by identifying that reward information is unevenly distributed across denoising timesteps and trajectories.

Vladislav Beliaev

Competitive training between two models can implicitly grade reasoning quality without process labels or reward models—each model becomes the other's grader, forcing genuine problem-solving improvement rather than just longer outputs.

Agon trains two AI models to compete against each other on reasoning tasks. One model drafts a solution while the other reads it and solves the problem independently—whoever gets the right answer wins. This forces both models to develop better reasoning skills without needing labeled examples of good thinking.

Xiangming Huang, Guannan Zhang, Lu Lu et al.

Neural operators can compress high-dimensional design spaces into low-dimensional latent representations that preserve physics-aware structure, making evolutionary optimization practical for inverse design problems that would otherwise be intractable.

This paper combines neural operators with evolutionary optimization to solve inverse design problems for physical systems governed by PDEs. By learning a compact representation of design space topology and coupling it with CMA-ES, the method reduces design dimensionality dramatically while maintaining high performance across different operating conditions.

Eitan Levin, Venkat Chandrasekaran

Models trained on small inputs can generalize to larger ones if they're continuous with respect to appropriate sampling operations—the paper provides explicit rates and identifies which sampling strategies (replacement, binning, species sampling) work for different problem types.

This paper develops a unified framework for understanding how machine learning models generalize from small to large inputs of variable sizes (like point clouds or graphs). Using random sampling maps, the authors characterize when models can reliably extrapolate to unseen input sizes and how to compress large inputs while preserving model predictions.

Xinyi Wu, Siyuan Liu, Ali Jadbabaie

RoPE frequency usage is determined by training data's dependency structure—frequencies scale inversely with dependency width. This explains why language models use mid-low frequencies and why frequency scaling enables length generalization when test contexts have similar patterns to training data.

This paper explains why transformer models use certain frequencies in Rotary Position Embeddings (RoPE) non-uniformly. The authors show that frequency selection matches the dependency structure in training data, with optimal frequencies inversely proportional to dependency width.

Tianming Sha, Yue Zhao, Lichao Sun et al.

For building reliable autonomous agents, having a large, source-grounded skill library with quality verification is critical—SkillCenter provides 216K+ skills where every claim traces back to its original source.

SkillCenter is a massive open library of 216,938 structured skills for AI agents, with over 114,000 skills verified against peer-reviewed sources and technical documentation. The system uses an LLM-based quality filter and source-grounding to ensure each skill's claims are traceable to exact quotations, helping agents execute tasks that are not just runnable but correct, secure, and maintainable.

Vladislav Beliaev

Dynamically controlling solution prefix length during training—not just at data prep time—can more than double reasoning model accuracy on hard problems by keeping success rates in the optimal gradient zone, then fully removing scaffolding at test time.

This paper addresses a key problem in GRPO training: hard problems where no rollouts succeed produce zero gradient signal, wasting valuable frontier examples. AdaPrefix-GRPO solves this by dynamically prepending solution prefixes during training, adjusting prefix length via feedback control to maintain ~50% success rate (where gradient signal peaks), then removing assistance at deployment.

Hyunjae Kim, Dain Kim, Pan Xiao et al.

High-fidelity data curation from scientific literature can create large-scale medical multimodal datasets that rival or exceed models trained on much larger datasets, enabling better medical AI without requiring new data collection.

MedPMC is a framework that automatically extracts and curates 11 million high-quality medical image-text pairs from 6.1 million PubMed Central articles. The resulting dataset trains multimodal models that significantly outperform existing biomedical baselines on medical imaging tasks, with 95.3% of extracted images validated as medically relevant by human reviewers.

Adrian Ciotinga, Yeming Dai, YooJung Choi

You can improve an already-trained probabilistic circuit's robustness to data noise and distribution shifts by applying PeTeR as a post-training step, without the cost of retraining the entire model from scratch.

PeTeR is a post-training method that makes probabilistic circuits (models for computing probability distributions) more robust to noisy data and distribution shifts without retraining from scratch. It uses distributionally-robust optimization to protect against worst-case data variations, improving model reliability on real-world data.

Tianjiao Yu, Xinzhuo Li, Yifan Shen et al.

By routing text-to-geometry interactions across matched abstraction scales rather than flattening everything into one representation, you can build faster, more accurate 3D models that understand both coarse structure and fine details.

ELSA3D is a unified 3D foundation model that improves how language and 3D geometry interact by using 'anchor tokens' to match text concepts with the right level of geometric detail. Instead of treating all information equally, it routes language features to specific scales of 3D structure, making the model both more efficient and more accurate for generating and understanding 3D objects.

Shervin Khalafi, Igor Krawczuk, Sergio Rozada et al.

Linear attention in graph transformers can only learn averaged denoising filters, but Graph Convolutional Attention leverages spectral information to adapt denoising to each graph's unique structure—improving both performance and inference speed.

This paper explains why standard attention mechanisms struggle with graph denoising and proposes Graph Convolutional Attention (GCA), which uses the graph's spectral properties to denoise more effectively. GCA provably outperforms linear attention and works well in graph diffusion models, offering both theoretical guarantees and practical speedups.

Aparna Madva, Sharath Srivatsa, Srinath Srinivasa et al.

Building AI for Indian languages requires moving beyond generic NLP approaches to address unique linguistic structures and cultural contexts; the paper introduces 'Culture Sensing' as a framework for culturally-aware, equitable AI development.

This paper examines how AI and NLP technologies impact Indian languages and cultural heritage, tracing the historical development of Indic NLP while highlighting unique linguistic challenges like complex scripts, rich morphology, and diglossia.

Ramon Ferrer-i-Cancho, Catherine Hobaiter, Thore Bergman et al.

Dependency parsing of animal communication is paradoxically easier to evaluate than human language because primate sequences have mathematical properties that constrain parser accuracy, enabling validation without labeled data.

This paper explores whether dependency parsing—finding tree structures in sequences—can work for animal communication without labeled training data. Using network science, the authors show that primate vocalizations and gestures have mathematical properties that force parsers to be accurate, making evaluation possible without gold standards.

Zhenyu Liu, Yunxin Li, Xuanyu Zhang et al.

Modality interference—caused by gradient conflicts between audio and semantic processing—is the root cause of poor full-duplex SLM performance; hierarchical parameter separation solves this while maintaining cross-modality coherence.

This paper identifies and solves a critical problem in full-duplex spoken language models: when audio and text processing share the same neural network layers, they create conflicting gradients that degrade performance.

Xiaolei Guo, Chenyu Zhou, Jianghao Lin et al.

For building MILP solvers and learned optimization policies, GraphBU generates synthetic instances that preserve the graph structure and feasibility of real problems better than existing methods, improving downstream model training by ~8%.

GraphBU is a method for generating realistic MILP instances by treating local subproblems and their connections as fundamental units. Unlike existing generators that use templates or statistics, it explicitly preserves how different parts of an optimization problem couple together, maintaining structural properties that solvers and learned policies depend on.

Ghassen Marrakchi, Basarab Matei

By separating how patient data flows through a system from how AI models process it, you can build more maintainable clinical AI that adapts to real hospital environments without rewriting core logic.

This paper presents the Large Cancer Assistant (LCA), a flexible orchestration framework that decouples data handling from AI models in cancer diagnosis systems.

Sambaran Bandyopadhyay, Ananth Muppidi

By decoupling graph traversal from text generation and using soft probability flows that converge to discrete paths, the approach enables end-to-end learning across semantic gaps while maintaining computational efficiency compared to pure LLM methods.

This paper tackles multi-hop question answering over knowledge graphs by proposing RSF-GLLM, which separates differentiable graph reasoning from LLM-based answer generation. A Recurrent Soft-Flow module learns to traverse semantically distant nodes in knowledge graphs by propagating relevance scores, then converts discovered paths into text to fine-tune an LLM for grounded answers.

Anna Cordoba, Adam Puente Tercero, Nerea Angulo Hijo et al.

Token-adaptive KV cache compression with cross-layer factorization can cut memory use by 8x while maintaining retrieval accuracy—enabling faster long-context inference without model retraining.

DepthWeave-KV compresses the key-value caches that slow down long-context language model inference by sharing low-rank representations across transformer layers while keeping token-specific details where they matter most. It uses a smart router to allocate more storage to important tokens and adapts compression on-the-fly during generation, achieving 8.3x memory reduction without retraining.

Han-Jun Ko, Jr-Jen Chen, Haobo Yuan et al.

Grounding VLM reasoning directly to visual observations and action consequences—rather than letting models generate free-form explanations—significantly improves physical reasoning generalization and reduces hallucination.

This paper tackles a key problem in vision-language models: they hallucinate reasoning that contradicts physics and misalign their explanations with actual actions. VAORA introduces two reward signals that anchor model reasoning to visual evidence and action outcomes, helping VLMs learn grounded physical reasoning that generalizes to new tasks and environments.

Anna Córdoba, Adam Puente Tercero, Nerea Angulo Hijo et al.

You can compress LLM KV caches by 3.9x without losing accuracy on long-context tasks by factorizing states into frequency components and adaptively assigning heads—no retraining needed.

FreqDepthKV compresses KV caches during LLM inference by splitting key-value states into shared low-frequency components and sparse residuals, then dynamically assigns attention heads to different compression modes based on their importance. This preserves accuracy on long-context tasks while reducing memory use by 3.9x and improving inference speed.

Chase McDonald, Nathan Tsang, Wesley N. Kerr

This environment offers researchers a reproducible, computationally efficient testbed for developing and evaluating RL algorithms in strategic games with hidden information and cyclic non-transitive dynamics—properties common in real-world competitive scenarios.

FootsiesGym is an open-source environment for training AI agents in a simplified 2D fighting game with imperfect information and strategic complexity. It provides a fast, accessible benchmark for studying two-player competitive interactions where neither player has complete information, enabling efficient reinforcement learning research on standard hardware.

Yaqi Wu, Xiaolei Guo, Chenyu Zhou et al.

Learning to control *when* and *how* to retrieve (not just what to retrieve) significantly improves multi-hop QA—showing that smart operation selection beats simply retrieving more documents.

DynaKRAG learns when and how to retrieve evidence for multi-hop question answering by treating retrieval as a control problem. Instead of following fixed pipelines, it dynamically chooses between operations like retrieving new documents, reformulating queries, or judging if enough evidence exists—based on what's currently known.

Kevin Xu, Alexander Quispe

You can now map GitHub repositories to standardized industry sectors with high accuracy, enabling research on how different industries contribute to open-source software and how technologies spread across economic sectors.

This paper introduces NAICS-GH, a dataset of 6,588 GitHub repositories labeled with industry sectors using the North American Industry Classification System. The authors use a pipeline combining embeddings, retrieval, and GPT-4 scoring to automatically classify repositories, achieving 97% precision on human-validated samples and releasing the dataset with code and trained models.

Qian Sun, Yong-Ming Tian, Jia-Wei Huang et al.

Real-world multivariate time series data substantially improves foundation model generalization compared to synthetic data, suggesting that practitioners should prioritize real-world datasets when pretraining time series models.

This paper introduces RMISC, a large-scale collection of 200 real-world multivariate time series datasets with 142 billion data points across diverse domains.

Wenhao Li, Xueying Jiang, Quanhao Qian et al.

Robot policies can achieve view robustness without camera calibration by learning to predict both action in camera space and camera-to-robot geometry, making deployment more practical when camera positions vary.

This paper introduces CamVLA, a robot vision-language-action model that learns to figure out camera positioning automatically instead of requiring explicit calibration. By predicting both camera-relative actions and the geometric relationship between camera and robot, the model works with any camera setup without needing depth data or prior calibration.

Shiyuan Feng, Huan-ang Gao, Haohan Chi et al.

You can reuse RL training from cheaper small models to improve large models by treating the policy shift (not the final policy) as a dense reward signal—this cuts post-training costs while maintaining reasoning gains across model scales.

This paper proposes Direct-OPD, a method to transfer reinforcement learning gains from smaller models to larger ones without expensive retraining. Instead of distilling the final policy, it extracts the policy shift that RL induced (via log-ratio comparison) and applies it as an implicit reward signal on the stronger model's own data, enabling efficient scaling of RL-based reasoning improvements.

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.