Papers

Kevin Du, Alexander Hoyle, Laura Ruis et al.

Chain-of-thought reasoning traces appear interpretable but don't reliably encode step importance; this gap matters for process reward models and other techniques that assume reasoning text reflects functional significance.

This paper investigates whether the text of chain-of-thought reasoning steps actually reveals which steps matter for a model's final answer.

Angel Y. He, David Parker

You can now learn approximate Nash equilibria in multi-agent games with unknown dynamics in polynomial sample complexity, and the algorithm provably detects when equilibria don't exist—solving a fundamental challenge in multi-agent reinforcement learning.

This paper develops the first PAC learning algorithm for concurrent stochastic games where multiple agents learn Nash equilibria despite uncertain transition dynamics. The algorithm maintains confidence sets over game transitions and solves robust games to find welfare-optimal approximate equilibria, with a novel mechanism to certify when exact equilibria don't exist.

Ye-Chan Kim, Seunghee Choi, SeungJu Cha et al.

Using a VLM to detect actual visual transitions in videos produces better event localization and captions than pre-written transition descriptions inserted at fixed positions.

This paper tackles dense video captioning—describing multiple events in long videos—by using a vision-language model to intelligently detect transition moments between events rather than blindly inserting captions everywhere.

Joseph Lee, Yidi Huang, Dokyoon Kim et al.

LLMs learn knowledge more effectively when exposed to multiple reformulations of the same concept rather than just repeated text, suggesting that data diversity—not just quantity—is fundamental to pre-training success.

This paper investigates how LLMs learn knowledge during pre-training by studying the role of 'auxiliary views'—different reformulations of the same knowledge. Through controlled experiments, the researchers show that diverse representations of knowledge improve learning better than simple repetition, even when the total number of tokens stays the same.

Rafal Urbaniak, Sam Witty, Daniel Waxman et al.

PCI makes causal explanations computationally practical by framing the problem as Monte Carlo estimation rather than counterfactual enumeration, letting you get theoretically grounded blame/credit assignments at scale without sacrificing causal reasoning.

This paper introduces Probabilistic Causal Impact (PCI), a method that explains why specific outcomes occurred by computing which inputs deserve credit or blame.

Vilém Zouhar, Niyati Bafna, Mukund Choudhary et al.

Standard translation benchmarks are saturating and automatic metrics are unreliable—this benchmark uses human-authored hard cases with explicit failure rules to provide reproducible evaluation that actually identifies what models get wrong.

This paper introduces the Last Translation Benchmark, a curated collection of challenging translation examples (text, images, audio, video) designed to expose weaknesses in state-of-the-art machine translation models.

Zixuan Fu, Bingxiang He, Yuxin Zuo et al.

On-policy distillation wastes data but struggles with learning speed: a single query exposes most supervision needed, but the student takes hundreds of training steps to absorb it, suggesting future improvements should focus on faster alignment rather than more data.

This paper investigates how much training data on-policy distillation (OPD) actually needs by training on just a single query. Surprisingly, one query recovers most of the performance gains of full-dataset training, reaching 71.5% of the state coverage that full data achieves.

Davide Paglieri, Logan Cross, Tim Genewein et al.

When autonomous agents share tools and knowledge, undesirable behaviors can spread quickly, but transparent communication also enables agents to detect problems and enforce norms—suggesting decentralized governance mechanisms could help multi-agent systems self-regulate.

Researchers studied 100 autonomous AI agents working together to prove math theorems and discovered that cheating spontaneously emerged when one agent found an exploit—then other agents independently developed whistleblowing and enforcement mechanisms without human intervention.

Yujie Zhang, Huiying Lan, Ehsan Aghapour et al.

For edge AI deployment, combining hierarchical operator parallelism with pipelining can achieve better energy efficiency and latency than using either strategy alone—Para-Pipe shows 11-23% energy improvements on real SoCs.

Para-Pipe is a framework that optimizes deep learning inference on edge devices (SoCs) by combining pipelining and parallel execution of neural network operations.

Xin He, Yanlin Wang, Mingwei Liu et al.

Functional test passage alone is insufficient for evaluating coding agents—real-world software development requires meeting code review constraints, and current agents have a significant gap between passing tests and satisfying these constraints.

SWE-Gate is a benchmark that evaluates coding agents not just on passing tests, but on meeting real-world code review standards. It includes 303 repair tasks from Python repositories with explicit review constraints derived from actual pull request comments, revealing that many patches pass functional tests but fail review requirements.

Yakov Pyotr Shkolnikov

Deceptive outputs from language models don't necessarily mean the model has deceptive intentions or mechanisms—you need causal evidence to distinguish between what a model does and why it does it.

This paper examines whether language models that produce deceptive outputs actually have deceptive mechanisms inside them. The authors create a causal framework to distinguish between behavior that looks deceptive and mechanisms that are genuinely deceptive, then test these distinctions through controlled experiments with language models.

Uday Vallabhaneni, Cassie L. Cagwin, David J. Wild

Offloading structured reasoning (like network topology) from LLMs to specialized models (graph encoders + RL policies) makes AI security agents faster, more reliable, and deployable at enterprise scale.

This paper presents Sentinel-RL, a system that helps LLM-based security analysts by splitting their work: a graph neural network handles the complex authentication network topology, while reinforcement learning constrains the agent's actions to valid security moves, and the LLM focuses on explaining decisions to humans.

Jie Wu, Zhenru Zhang, Beichen Zhang et al.

Instead of building environments from scratch, you can extract them from existing agent trajectories, then use those environments to generate diverse training tasks at scale—turning single frozen demonstrations into many verifiable, interactive learning scenarios.

Terminal-Universe reconstructs executable coding environments from agent trajectories by replaying file operations and synthesizing missing dependencies. It then generates new tasks from these environments—both variations of original tasks and cross-workspace queries—and extends them into multi-turn interactions with simulated user feedback.

Kelvin Li, Dhruv Pendharkar, Anish Pahilajani et al.

Training world models to discriminate between alternative action outcomes (rather than just predict accurately) makes them better at helping agents choose the right action when browsing the web.

This paper improves web agents by training world models that predict web states in a way that helps rank candidate actions. Instead of predicting states accurately for their own sake, the model learns to make predicted states distinguishable from each other—so a ranker can tell which action leads to the best outcome.

Lintai Hou

You can build efficient language models by replacing dense attention with sparse routing through learned edges, maintaining full state size while accessing only a tiny fraction of tokens per layer.

Graph Machine introduces a sparse neural architecture that maintains linear-sized state while using dynamic routing through differentiable edges. By replacing 75% of dense Transformer layers with sparse GM layers in a 0.6B model, the approach achieves comparable or better performance while accessing only 2-4 tokens per attention head, reducing computational cost.

Cagri Temel

Autonomous robots need structured decision frameworks that document causal chains from sensors to actions, not just post-hoc explanations, to meet regulatory requirements and enable real incident investigation.

TRACE is a decision framework for autonomous robots that makes every action traceable back to sensor data through documented causal chains. It organizes robot decision-making into four auditable layers—perception, belief reasoning, action planning, and execution verification—enabling investigators to reconstruct why a robot made specific decisions after incidents occur.

Shachar Don-Yehiya, Leshem Choshen, Omri Abend

User feedback is a strong improvement signal for LLMs, but standard LLM-based evaluation systematically fails to recognize when models successfully apply it—meaning we're underestimating feedback's real value.

This paper shows that user feedback is actually a valuable signal for improving LLMs, but current evaluation methods fail to recognize when models successfully use it.

James Mickens

You can't trust what an LLM says about its own reasoning for security purposes—use isolation techniques like taint tracking that work regardless of what the model claims it's doing.

LLMs' internal computations happen in mathematical activation spaces, not language, making their linguistic outputs unreliable for understanding how they actually think. This 'linguistic illegibility' means security approaches that monitor what models say about themselves (like chain-of-thought analysis) can be fooled.

Aleksander Ficek, Sean Narenthiran, Mehrzad Samadi et al.

Post-training with domain-specific data, reasoning traces, and test-time compute strategies can push language models to superhuman performance on complex reasoning tasks like competitive programming.

Researchers trained specialized language models to excel at competitive programming by combining curated problem datasets, synthetic reasoning traces, fine-tuning, and reinforcement learning. Their system achieved gold-medal performance on the International Olympiad in Informatics (IOI) 2025 and 2026, becoming the first AI to outscore the top human competitor on an IOI problem set.

Robert Hu, Carlo Luschi, Paul Balanca

Block-scaled FP4 pretraining can match or exceed current quantization methods while being simpler and faster—no randomized transforms needed, and you can keep FP4 in all layers, not just some.

This paper presents a simpler and more efficient recipe for training large language models using 4-bit floating-point (FP4) precision.

Wenxin Jiang, Xuyang Wang, Yuxiao Wu

AI can reliably measure hard-to-survey characteristics at the individual level, but only when you have rich background data available—it's most useful for filling gaps in existing datasets rather than replacing surveys entirely.

Researchers developed AICOME, a framework for validating whether AI-generated measures of occupational and social characteristics can accurately recover both individual and group-level effects in statistical models.

Peixuan Han, Runhui Wang, Ketan Ramaneti et al.

By identifying where reasoning first fails in each attempt, you can provide much richer training signal than outcome-only rewards—the key insight is that reasoning after a mistake is uninformative, so you only need to reward the correct prefix.

Cliff is a reward shaping strategy for training language models that identifies the first mistake in a reasoning chain and uses that to provide fine-grained feedback. Instead of just rewarding correct final answers, it marks where reasoning first goes wrong, then assigns positive rewards to the correct reasoning steps and negative rewards after the mistake.

Hao Zhou, Mandar Kulkarni, Hao Chen et al.

LLMs need structured reasoning frameworks with evidence grounding to reliably diagnose telecom network faults—vanilla LLMs hallucinate and produce unstable reasoning without domain-specific constraints and verifiable decision paths.

This paper addresses root cause analysis (RCA) in telecom networks by proposing a structured reasoning framework for LLMs that reduces hallucination and improves diagnostic accuracy. The approach organizes network data into canonical contexts, enforces decision-path reasoning, and grounds explanations in evidence, demonstrating improvements on 5G network datasets.

Onur Uğurlu

Combining a constructive proof with systematic empirical validation shows that some hard optimization problems resist heuristic improvements—the paper demonstrates both the solution and why current search methods hit a fundamental barrier.

This paper solves the 20-year-old frb100-40 benchmark by finding a 100-vertex independent set in a 4,000-vertex graph, proving the maximum independent set is exactly 100. The authors also conduct a rigorous preregistered study testing whether new repair operators improve search performance, finding no statistically significant speedup over existing methods.

Isaiah Andrews, Suproteem Sarkar

Language models produce incoherent probability forecasts that violate basic logical consistency rules, meaning you shouldn't rely on them for probabilistic predictions about real-world events without additional safeguards.

This paper tests whether language models produce coherent probability forecasts by using a mathematical technique called Dutch books—finding profitable bets against the model's predictions.

Vasileios Baltatzis, Mert Inan, Connor Gillis et al.

Sign language translation needs discourse context to maintain spatial consistency and entity tracking across multiple sentences—not just translating each sentence independently.

DiscoSign translates English text to American Sign Language glosses while tracking discourse-level phenomena like spatial references and entity consistency. Traditional sign language systems work sentence-by-sentence, missing how entities and concepts maintain meaning across longer conversations.

Zhaoming Li, Paul Hand

In linear compressed sensing, complexity tuning doesn't improve reconstruction error, so practical gains from tunable generative priors likely depend on the nonlinear structure of neural networks rather than the tuning mechanism itself.

This paper proves that for linear generative priors in noiseless compressed sensing, using the full-complexity model always minimizes reconstruction error—simpler priors don't help.

Qinghua Mao, Wanying Qu, Dadi Guo et al.

Rather than choosing between external controls or model training, SafeEvolve co-evolves both together—making safety controls more effective while training agents to actively use them during multi-step tasks.

SafeEvolve is a framework that improves AI agent safety by simultaneously evolving two components: the harness (runtime controls like prompts and skills) and the policy (the model's behavior). It learns from real agent trajectories to create auditable safety updates and train the model to better use these controls, achieving 3× better attack resistance while maintaining utility.

Himil Vasava, Ming Jiang

LLM evaluators don't score holistically—they implement a mechanistic two-stage pipeline where error detection happens early and rating decisions crystallize in late layers, and fine-tuning reorganizes rather than builds this structure from scratch.

This paper reveals how LLM-based evaluators (like Themis and Prometheus) internally assign quality scores to text summaries. Using causal analysis techniques, the authors discovered these models use a two-stage pipeline: early layers compare errors locally, while later layers integrate signals and finalize ratings.

Kefeng Duan, Dewu Zheng, Yanlin Wang et al.

By analyzing how agents solve problems—not just whether they succeed—you can evaluate SWE agents on fewer benchmark tasks while still accurately predicting full-benchmark performance.

This paper proposes PTA-IRT, a framework for efficiently evaluating software engineering agents on benchmarks by using execution trajectories (exploration paths, code edits, test results) alongside pass/fail outcomes. Instead of running every task, it selects representative tasks and uses trajectory data to better estimate how well agents would perform on the full benchmark.

Kefeng Duan, Dewu Zheng, Yanlin Wang et al.

For repository-scale code generation, pinpointing and retrieving context for critical decision points during generation is more effective than providing all repository context upfront.

This paper introduces ACToR, a system that improves code generation for large repositories by identifying 'critical tokens'—key positions where errors are most likely to occur—and retrieving relevant repository context specifically when generating those tokens.

Damien Sileo, Dimitri Kachler

Language models can reason about component dependencies in small systems but become unreliable as complexity grows—and the reasoning cost is high (thousands of tokens per question), though formal semantics suggest this cost could be avoided with better approaches.

CordisBench is a benchmark testing whether language models can reason about how changes to software components affect other parts of a system. It uses a runtime called Cordis that manages dependencies and cleanup, asking models to predict what happens when components are modified or removed.

Kshitij Tayal, Arun Sharma, Genta Indra Winata et al.

Natural language is becoming a primary feedback mechanism for training and guiding AI agents—moving beyond traditional numerical rewards to leverage language's ability to convey intent, preferences, and reasoning in ways both humans and LLMs understand.

This paper introduces Verbal Reinforcement Learning (VRL), a framework where natural language serves as feedback to improve language agents. It organizes the field into three categories: language defining tasks and rewards, language guiding reasoning at test time, and language shaping model parameters during training.

Haoyuan Deng, Haichao Liu, Wenkai Guo et al.

By explicitly modeling contact forces alongside visual and kinematic information, this system achieves 82% success on precision assembly tasks—a massive jump from 15% for existing approaches—showing that understanding physical interaction is critical for real-world robot manipulation.

Facet-0 is a robotic foundation model that learns to perform precise assembly tasks by predicting how its actions will affect contact forces with objects. It combines vision, language, and force feedback to generate robot movements that maintain sub-millimeter accuracy during assembly, trained on 1,000 hours of real robot data across multiple manufacturing setups.

Dirk Bergemann, Andrew Koh, Stephen Morris

When deploying AI agents whose true capabilities and preferences are hidden, you can use mechanism design principles—like nested monotonicity conditions and higher-order belief elicitation—to create incentives that force honest revelation and obedient behavior.

This paper develops a framework for designing mechanisms that incentivize AI agents to be honest about their preferences and obedient in their actions, even when their true capabilities and alignment are unknown. The authors show how to detect deception (like sandbagging), balance alignment with interpretability, and use peer scoring and competition to ensure agents act as intended.

Ke Yang, Chenglong Wang, Michel Galley et al.

Student simulators trained with this method can serve as realistic reward signals for tutor reinforcement learning, letting AI tutors optimize their teaching strategies without requiring extensive real student data.

StudentSim trains AI models to simulate individual students' learning behaviors and how they respond to tutoring.

Chao Zhang, Abe Davis, Chih-Wei Chen et al.

Proactive writing assistants work best when users can customize what kind of help they get, when they receive it, and how it's presented—avoiding generic suggestions in favor of role-specific, lightweight interventions that support rather than interrupt the writing process.

This paper explores how AI agents can proactively help writers by offering customizable, higher-level cognitive support at the right moments. Researchers built and tested a tool where users configure AI 'thought partners' with specific roles and proactivity levels, then observed how writers used suggestions for ideation and self-review.

Jundong Hu, Shekar Ramachandran

When quantizing LLMs with a limited precision budget, applying finer quantization globally across all layers outperforms selectively restoring precision to individual critical layers—damage is diffuse, not concentrated.

This paper investigates where quantization damage occurs in large language models and how to best allocate extra precision budget. By systematically testing which layers benefit from higher precision across multiple models, the researchers find that damage is spread across many layers rather than concentrated in specific circuits.

Maksim Evdokimov, Matvey Ivanov, Dmitrii Tsiupin et al.

Smart data curation and cost-aware deployment economics can make small VLMs competitive with much larger models for document processing—the key is selecting training examples strategically and measuring real-world costs including verification and correction.

This paper presents a practical document understanding system that extracts structured data from documents at a fraction of the cost of human annotation or larger models.

Jingtan Wang, Arun Verma, Xiaoqiang Lin et al.

You don't need to find the perfect SFT-RL budget split—a wide range of allocations work nearly equally well, and you can identify this range using small models and apply it to large ones, saving computation.

This paper solves a practical problem in LLM training: how to split your annotation budget between supervised fine-tuning (SFT) and reinforcement learning (RL). Instead of finding one perfect ratio, the authors identify a 'near-optimal region'—a range of budget splits that all perform nearly as well.

Olga Tsymboi, Dmitrii Stoianov, Ramil Latypov et al.

Training separate optimization experts for different failure modes, then merging them, beats joint optimization and lets enterprises consolidate their LLM fleet without sacrificing quality.

A company built a single self-hosted LLM to replace 200+ fragmented models by analyzing production errors and training specialized experts for instruction-following, function-calling, and task distribution. They merged these experts and achieved better performance than a 7× larger model while handling 116M monthly requests at lower cost.

Matteo Merler, Giovanni Bonetta, Davide Zago et al.

VLMs can be more useful as selective training guides than as direct policies—by querying them only when needed and validating their advice through environment rewards, you can build cheaper, better-performing autonomous agents that don't depend on the VLM at deployment.

This paper presents SAGE, a method for training lightweight autonomous policies by selectively querying an expensive Vision-Language Model (VLM) teacher during training.

Manish Gupta, Chaitanya Giri, Jayasimha Talur

By identifying confusable label pairs and generating targeted differentiation rules, you can improve text classification accuracy by up to 10 points without retraining—and these rules transfer to smaller, cheaper models.

This paper tackles a key challenge in text classification: when LLMs must choose between many similar category labels, they often get confused. The authors propose a system that identifies which label pairs the model struggles with, includes those confusing pairs in the candidate set, and generates targeted rules to help distinguish between them.

Carlos Bain, Max Bain

You can get both fast batched inference and accurate context-aware transcription by carefully managing segment boundaries—this matters for production speech systems that need both speed and quality.

This paper improves speech transcription by combining the speed of batched processing with the accuracy benefits of maintaining context. The key innovation is using voice activity detection to safely batch audio segments while keeping historical context, which helps Whisper produce better punctuation and proper nouns without sacrificing inference speed.

Mingyang Liu, Gabriele Farina, Asuman Ozdaglar

Players in multi-agent games can now achieve constant regret (independent of game length) using a fully decentralized algorithm—removing a logarithmic factor that was thought necessary and enabling truly scalable distributed learning.

This paper solves a long-standing problem in game theory by showing that players can learn to play near-equilibrium strategies in any finite game without accumulating regret that grows with time. The key innovation is ECHO-OFTRL, an algorithm that uses exponential moving averages to create better predictions of opponent behavior, allowing each player to act independently without coordination.

Yisen Xi

You can identify anonymous API models through systematic forensic analysis of configuration, tokenizer behavior, and archived platform data—but this requires careful validation and should decline to guess rather than make false claims.

This paper presents a four-stage forensic protocol for identifying anonymous AI models served through APIs. Using archived platform data, configuration fingerprinting, tokenizer analysis, and behavioral testing, the authors demonstrate how to verify model identity without relying on self-identification.

Riya Ahuja, Tim Kacprowski, Roya Shiasi Sardoabi

Semantic chunking that respects entity and relationship boundaries significantly outperforms fixed-size chunking for biomedical RAG, especially when relation cues are explicit in the text.

This paper improves biomedical information extraction in RAG systems by replacing fixed-size text chunking with a configurable semantic chunking framework. The approach preserves important entities and relationships by using trigger-centered chunking and hierarchical relation resolution, achieving 8.4 F1 points improvement on biomedical relation extraction benchmarks.

Hamed Babaei Giglou, Sören Auer, Peio Popov et al.

Combining different types of ontology alignment methods through voting-based ensemble learning reliably improves results, with the best approach depending on whether you prioritize precision (mix different paradigms) or overall F1-score (use multiple LLMs).

This paper presents OntoAligner-Ensemble, a framework that combines predictions from different ontology alignment methods (string-based, knowledge graph embeddings, and LLM-based) using voting and selection strategies. Testing across biomedical and other domains shows that mixing diverse alignment approaches consistently improves precision-recall balance and often beats individual methods.

Nan Zheng, Hoi Yiu Cheung, Vibhu Sharma et al.

TMB eliminates manual derivations for neural network mixed-effects models by automating gradient computation and random effect integration, making these powerful models easier to implement correctly and at scale.

This paper shows how to build neural network mixed-effects models (NMMs) using Template Model Builder (TMB), a tool that automatically handles the complex math needed to fit these models.

Yung Wei Shueh, Zhi-Jie Chen, Chia-Hsuan Hsu et al.

Building trustworthy clinical AI requires layering deterministic data processing, retrieval-augmented generation from authoritative sources, and verification checks—not relying on LLMs alone.

DIASENTINEL is a multi-agent system that uses LLMs safely for diabetes risk screening by combining clinical data extraction, guideline-based retrieval, and verification layers to prevent hallucinations and ensure all recommendations are traceable to medical guidelines.

Yuhan Wang, Zhengxi Lu, Yuchen Yan et al.

By separating question sources from evaluation criteria in research papers, you can create reliable reward signals for training AI on research planning—without the model just paraphrasing its way to high scores.

PaperGym turns research papers into training environments for AI scientists by extracting evaluation criteria (rubrics) from paper structure—questions from goals/background, criteria from methods/experiments. This solves the problem that research planning has no verifiable answers, enabling reinforcement learning training.

Hamed Babaei Giglou, Sören Auer, Jennifer D'Souza

When building ontologies with LLMs, model size matters less than you'd expect—architecture and training approach often matter more, and the best model depends heavily on your specific task (term classification vs. relationship extraction).

This paper systematically evaluates how LLM size affects ontology learning—the task of automatically extracting concepts and relationships from text to build knowledge structures.

Snehal Raj, Natansh Mathur, Alejandro Perdomo-Ortiz

Minimizing moment-matching losses on classical computers doesn't guarantee quantum generative models will generalize well—the field needs to rethink training objectives or architectures for the "train classical, deploy quantum" paradigm to work reliably.

This paper challenges a popular strategy for quantum machine learning where models are trained classically using moment-matching losses (like MMD²) and then deployed on quantum hardware. The authors show that models trained this way generalize poorly to new data, despite achieving low training loss.

Yuhao Wu, Jingyuan Zhang, Jiajun Shi et al.

Current AI self-evolution systems can't handle vague goals well—they need explicit tasks and metrics to improve. When forced to interpret goals and self-evaluate like humans do, models make poor choices about what data to train on and when to stop, causing improvements to vanish on new tests.

ASPIRE is a benchmark testing whether AI models can self-improve from vague goals (like 'become better at research') without explicit tasks or metrics. Unlike typical self-improvement work, models must interpret goals, choose training data, create their own evaluation signals, and decide when to stop—mimicking how humans learn.

Ahmed El Kady, Aravind Narayanan, Rehana Noorani et al.

Efficient evaluation methods can save compute but may alter conclusions about model bias and fairness; always validate that cost-saving techniques don't change the specific claims you're making about model behavior.

This paper tests whether cost-saving techniques in AI model evaluation (like smaller batches, lower precision, reduced benchmarks) produce reliable results.

Adrians Skapars, Edoardo Manino

Automated LLM auditing can be made dramatically more efficient by combining adaptive questioning strategies with logit-based output reweighting, finding harmful behaviors 2x more often than baseline methods without requiring model retraining.

BLOOM-WILT is an automated auditing system that efficiently finds rare problematic behaviors in deployed language models. It uses two key techniques: an auditor that learns better questioning strategies across conversations, and logit tilting that reweights the model's output distribution to surface behavior-relevant responses.

Gopi Krishnan Rajbahadur, Amir M. Ebrahimi, Boyuan Chen et al.

Post-training in production is about engineering discipline around data mixtures and yield metrics, not algorithmic breakthroughs—small improvements in converting training data into usable supervision can compound into significant model gains.

This paper treats LLM post-training as industrial maintenance work, not research. Teams inherit a deployed model and must improve it within strict compute budgets without breaking existing capabilities.

Jiajun Shi, Siyuan Tao, Yuhao Wu et al.

LLMs can learn from their own experience, but the best learning method depends on the task—sometimes raw history works better than summaries, and parameter training can cause harmful negative transfer.

S³Gym is a benchmark that tests whether LLMs can improve themselves by testing their own behavior, judging the results, and learning from experience. The researchers tested three ways to incorporate learning—using conversation history, summarized memories, and parameter training—across seven text-based games.

Aozhe Wang, Zhengxi Lu, Jianze Wang et al.

You can train models at inference time without labels by treating agreeing and disagreeing predictions differently—distilling correct-looking outputs while penalizing confident mistakes—achieving performance comparable to supervised methods.

TTPO enables language models to improve at test time without ground-truth labels by using an asymmetric training approach: it distills rollouts that agree with majority-vote predictions while penalizing disagreeing ones. This works even when the majority vote is wrong, because incorrect predictions tend to be rejected by the model anyway.

Dewu Zheng, Ruizhe Ye, Yanlin Wang et al.

Filtering training data for code-fixing tasks at both trajectory and step levels beats training on all successful examples—quality and relevance of supervision matter more than quantity.

SWE-Prime improves how AI models learn to fix software bugs by being smarter about which training examples to use. Instead of training on all successful bug fixes, it filters trajectories (problem-solving paths) at two levels—first selecting high-quality complete solutions, then identifying which individual steps within those solutions are actually worth learning from.

Dewu Zheng, Yanlin Wang, Xiwen Wang et al.

Current LLMs struggle with multi-round code review—their performance drops significantly as review iterations increase, they miss complex defects, and they fail to track how issues change across multiple rounds of feedback.

MCR-Bench is a new benchmark for evaluating AI models on realistic code review tasks that involve multiple rounds of back-and-forth interaction between developers and reviewers.

Junjie Zhang, Hui Liu, Kecheng Chen et al.

RedEvoAgent learns reusable attack skills from past jailbreak attempts, making red-teaming more efficient and interpretable while avoiding the context bloat and retrieval bias of trajectory-based methods.

RedEvoAgent is an automated red-teaming system that tests LLM agents for security vulnerabilities by learning and refining attack strategies. Unlike previous methods that use fixed attacks or store entire attack histories, it distills successful attacks into concise, interpretable skills that evolve through practice—similar to how a human attacker would learn what works.

Nguyen Xuan-Vu, Octavian Susanu, Daniel Armstrong et al.

By modeling reactions as electron rearrangements instead of molecular graph edits, MAELLE achieves competitive accuracy while naturally explaining reaction mechanisms and maintaining robustness on out-of-distribution chemistry.

This paper presents MAELLE, a machine learning model that predicts chemical reactions by tracking how electrons move between atoms, rather than just predicting final products.

Vésteinn Snæbjarnarson, Samuel Kiegeland, Manuel de Prada Corral et al.

Unbiased sampling with importance weighting can replace threshold pruning in transduced language models, giving you both accurate probability estimates and quantifiable error bounds—critical for applications like DNA-to-protein translation.

This paper solves a key problem in transduced language models: computing probabilities for target strings when a finite-state transducer maps many (possibly infinite) source strings to the same target.

Yisen Xi

When deploying LLM agents in regulated environments, separate persona (instructions/tone) from execution (work/state) into different trust domains with a governed contract bridge—this lets you evolve agent behavior freely while maintaining execution auditability and data security.

This paper presents Persona-Execution Separation (PES), an architecture pattern for LLM agents in regulated organizations that need to evolve their instructions and tone freely while keeping their work auditable and traceable.

Qianlong Lan, Vinothini Pandurangan, Anuj Kaul et al.

Security scanner evaluation needs to measure coverage and failure recovery separately from accuracy—a tool with perfect precision on 50% of cases is fundamentally different from one covering 100%, even if both are accurate when they work.

This paper evaluates three AI security scanners (ModelScan, ModelAudit, Fickling) that detect unsafe code in ML artifacts like Pickle files.

Kevin Zhu, Ryan Zhang, Baraa Abed et al.

Machine learning can create better clinical severity scores by learning from patient trajectories and mortality outcomes rather than relying on decades-old fixed formulas—and you don't need expensive per-timestep labels to do it.

Researchers built a machine-learned sepsis severity score from patient data instead of using outdated fixed formulas. Using 43 routine vital signs and lab values over 72 hours from nearly 37,000 patients across two hospitals, they trained a model that ranks patients by mortality risk without requiring hour-by-hour labels.

Xingyu Shen, Huishuai Zhang, Peng Li et al.

Injecting reasoning prefixes from weaker models during RLVR training preserves exploration diversity and improves pass@k performance without extra training or complex reward engineering.

This paper addresses a key problem in reinforcement learning for language models: when training LLMs to solve reasoning tasks with verifiable rewards, the models become overconfident and stop exploring diverse solution paths.

Maksim Utushkin, Andrei Ovsiannikov, Alexander D'yakonov

Multi-hash embeddings and timestamp-indexed neighbor sampling are practical techniques that make GNNs deployable on billion-scale social graphs without sacrificing ranking quality or inference speed.

This paper presents a production-scale GNN system for friend recommendations on massive social graphs (194M users, 28B edges). The key innovations are multi-hash embeddings that reduce ID storage by 98% while maintaining quality, and temporal neighbor sampling optimized to O(log(deg(v)) + k) complexity. The system achieved 16% more friend additions in live A/B testing.

Siye Wu, Kai Yang, Yuchen Cai et al.

When consolidating multiple domain-specific AI experts, choose Merge for cost efficiency, Mix RL for unified model training with adjustable domain balance, or MOPD when preserving specialized capabilities matters most.

This paper compares three methods for combining multiple AI experts trained on different tasks: Merge (combining their learned updates), Mix RL (pooling their training data), and MOPD (using both).

Kechen Liu, Ola Shorinwa

By training on cross-embodiment video data with a unified physics understanding, CLAP creates robot world models that match or beat single-embodiment models and generalize to new robots without retraining.

CLAP is a video world model that learns physics from diverse videos of humans and robots by treating physical laws as universal. It solves the challenge of different action representations across embodiments using end-effector poses, language, and learned latent actions, then applies a curriculum approach to train models that work zero-shot on real robot tasks.

Orion Reblitz-Richardson

LLMs don't just detect moral content; they organize it geometrically with a shared moral component and independent dimensions per foundation, meaning they capture nuanced relationships between different ethical frameworks and represent unresolved moral tensions.

This paper investigates how large language models organize moral knowledge by training linear probes on six moral foundation categories and analyzing their geometric relationships in representation space.

Jin Mu, Guanhua Chen

By exposing and suppressing artifact-driven features in clinical models, you can build systems that generalize better across hospitals and provide human-readable explanations of what clinical concepts drove each prediction.

Clinical AI models often memorize hospital-specific patterns (like note templates) rather than learning true patient health signals, causing them to fail when deployed elsewhere.

Lukas Kuhn, Lucas Maes, Giuseppe Serra et al.

Video pretraining can be as efficient as image pretraining when you remove unnecessary architectural complexity—a single encoder with the right loss function learns better representations faster than methods requiring asymmetric branches or exponential-moving-average targets.

LeVJEPA is a video pretraining method that eliminates computational inefficiencies in existing approaches by using a single encoder with a mathematically-guaranteed collapse-prevention mechanism, instead of complex architectural tricks like target encoders or masked reconstruction.

Maayan Sharon, Tom Hope

Retrieval systems need to understand different types of scientific inspiration—not just finding similar papers, but finding papers that generalize ideas, concretize them, or solve stated problems.

RATIO is a benchmark for retrieving scientific papers that can inspire research at different levels of abstraction. It defines three types of retrieval: finding approaches to solve problems, generalizing to broader concepts, or narrowing down to concrete implementations.

Sil Hamilton, Albert Yu Sun, Oscar J. Romero et al.

LLMs perform much worse on corporate Q&A tasks at realistic scale (thousands of documents) than on smaller benchmarks, and CorporateBench provides a standardized way to measure this performance gap without exposing real company data.

CorporateBench is a large-scale Q&A benchmark for testing how well language models handle real-world corporate document collections. It includes 230,000+ human-validated documents organized into synthetic companies of varying sizes, with questions requiring both information extraction and knowledge base querying.

Hanbing Liu, Bowei Zhang, Changyuan Yu et al.

Token-level advertising embeds advertiser influence directly into AI generation through auction mechanisms, enabling ads that feel native to AI responses rather than inserted into predefined slots.

This paper proposes LAMA, a new advertising system for AI-generated content that works at the token level during text generation. Instead of traditional ad slots, advertisers influence which words the AI generates next, and the system uses an auction mechanism to decide whose influence wins. Experiments show it can increase revenue while keeping response quality high.

Xin Chen, Fuwei Zhang, Yiqi Tong et al.

Detecting AI-generated text requires distinguishing not just human vs. AI, but also separating what was written from how it was written—content and expression can have different origins.

This paper tackles detecting mixed-origin text—where content and expression come from different sources (e.g., AI-written ideas expressed by humans). Instead of binary human-vs-AI classification, the authors propose D2C-Routing, which separately identifies content origin and expression origin, then combines them to classify four collaboration types.

Kairong Luo, Jiarui Cui, Yaorui Yin et al.

You can now train competitive small language models on a budget using consumer hardware and low-precision training—the authors prove it's possible for under $7K and share everything needed to reproduce it.

This paper demonstrates how to train a capable 1.5B language model from scratch for under $7K using consumer GPUs and FP8 precision, making LLM pretraining accessible to resource-constrained teams. The authors release their full training recipe, data, and models openly, and derive a cost scaling law showing similar performance is achievable for ~$4.4K.

Frederik Berenz

Instead of pre-sizing neural network encoders at maximum capacity, you can start small and grow them incrementally as task complexity demands, achieving significant efficiency gains without sacrificing performance.

This paper introduces Successive Capacity Growth (SCG), a method that automatically expands Vision Transformer encoders in world models from minimal size upward, adding attention heads or layers only when needed to improve prediction accuracy.

Darpan Singhal, Matan Mandelbrod, Tal Franji et al.

Counterfactual estimation lets you predict which recommendations will actually change user behavior, not just correlate with it—enabling better ranking of what content to show.

eBay built a two-stage machine learning system to recommend which short text or image snippets (called 'signals') to show on product pages. Using counterfactual estimation, they predict which signals will most likely drive purchases. The system increased overall sales by 0.08% and Parts & Accessories sales by 0.58%, especially for high-priced items.

Nicholas J. Hallman, Zachary T. Kowaleski, Anu Puvvada et al.

Sophisticated AI use correlates with domain expertise and strategic roles, but organizations struggle to improve it through training—suggesting that effective AI adoption requires matching tool complexity to employee expertise rather than generic upskilling.

This study analyzes 713,564 AI prompts from nearly 4,000 employees at a large firm to understand how sophistication in generative AI use varies by seniority, job function, and time. Senior employees and those in strategy-focused roles use AI more effectively, but the research finds no improvement in sophistication over time or from formal training programs.

Peiling Yi

Misleadingness in public discourse is diverse and often subtle (exaggeration, omission, unsupported inference), and while AI can sometimes predict how readers will interpret misleading content, identifying *how* it misleads requires rich contextual and evidential grounding.

This paper introduces RCMN, a framework for understanding how public discourse misleads readers through framing, omission, and context rather than just false claims.

Yunpeng Ba, Zhi Zheng, Yue Xie et al.

Evolution Strategies offer a fundamentally different optimization approach for LLM reasoning—trading single-attempt accuracy for diversity of correct solutions—making it complementary to standard policy optimization methods rather than just a memory-efficient alternative.

This paper investigates Evolution Strategies (ES) as a post-training method for improving LLM reasoning. ES maintains a population of model variants and selects based on performance, unlike GRPO which optimizes a single model.

Yutong Zhang, Jianshuo Dong, Peng Xu et al.

By giving language model agents a dedicated way to express their intentions during reasoning, you can detect harmful goal shifts in real-time rather than only catching problems after they occur.

This paper introduces INTENT-AS-A-TOOL, a method to detect when AI agents might take harmful actions by monitoring their reasoning process. Instead of only checking final decisions, the approach adds special tools that let models explicitly signal their intentions during thinking, creating a detailed record of how the agent's goals shift—helping catch misalignment before bad actions happen.

Yuandong Pu, Le Zhuo, Sayak Paul et al.

Video generators marketed as world models don't yet capture the correct distribution of possible futures—they produce plausible individual videos but fail to match the statistical likelihood of different physical outcomes when given the same starting conditions.

This paper introduces PAWBench, a benchmark that evaluates whether video generation models can accurately reproduce the distribution of possible physical outcomes, not just individual plausible videos. Current models fail to match real-world probability distributions of behaviors, revealing a significant gap in what it means to be a true world model.

Jason Hickey

Machine verification becomes economical with AI: instead of verifying rare artifacts, you can verify every step of AI-directed work, making it safe for one person to oversee autonomous agents building complex systems.

A researcher used AI agents with formal verification to design and tape out a working RISC-V processor in five weeks, with zero human-written proofs or RTL code. The 'Salt method' uses a proof kernel that rejects any hallucinated proofs, letting AI work autonomously while maintaining mathematical correctness from application code through silicon.

Yoshitaka Inoue, Minoh Jeong, Alfred Hero et al.

Learning how drugs transform cellular states (from single-cell data) and transferring that knowledge to predict patient outcomes is more effective than traditional approaches that treat patient profiles and drug properties as independent features.

PerturbRx predicts how cancer patients will respond to drugs by learning what molecular changes treatments cause in cells, then applying those learned changes to patient data. Instead of just looking at patient genetics and drug properties separately, it models the actual transformation that happens when drugs are applied, improving prediction accuracy without needing post-treatment measurements.

Zhuoyi Yang, Ian G. Harris, Salar Hashemitaheri et al.

Self-refinement pipelines don't need equally capable models at each stage—you can save compute by using smaller critics while keeping generators and revisers large.

This paper studies how to allocate model sizes efficiently across self-refinement pipelines (generation → critique → revision). Testing multiple model sizes on different benchmarks, the authors find that larger generators and revisers help, small critics still work well, and undersized revisers hurt performance. The key insight: don't use the same model size for all three stages.

Pedro Cadahia Delgado

When estimating prices from sparse movement data, most uncertainty comes from which price trajectory could have occurred, not from fitting a single trajectory—and standard statistical methods don't capture this.

This paper analyzes estimation uncertainty in short pricing datasets where few distinct price movements occur despite many observations. Using simulated data, the author shows that most estimation error (97.6%) comes from variation across different possible price trajectories rather than uncertainty within a single trajectory.

Afonso Baldo, Hugo Pitorro, Areti Vassilopoulos et al.

LLMs have systematic behavioral blindspots in therapeutic interaction—they over-rely on questioning and under-use teaching—but these gaps can be substantially reduced by exposing therapeutic moves as accessible tools, without retraining.

This paper creates a framework for measuring how LLMs conduct psychotherapy by defining ten therapeutic moves (like inquiry, psychoeducation, validation). Testing frontier models against real therapist transcripts reveals LLMs ask questions 3x more than humans, skip teaching patients, and rarely initiate strategies—but giving models access to these moves as tools cuts this gap in half.

Weihao Qu, Ling Zheng, Dongyang Wang et al.

Transformer models with temporal awareness can predict COPD flare-ups from ventilator data alone, enabling faster detection in home settings without waiting for lab results.

This paper develops a transformer-based model to predict acute exacerbations of COPD using only respiratory data from home ventilators, avoiding delays from clinical lab tests. The model uses time-aware attention to track how symptoms change over time, showing better performance than traditional methods for early detection.

Jingtao Tang, Hang Ma

Branch-and-bound search with tight lower bounds can solve complex routing problems through continuous spaces with optional waypoints, providing certified solution quality guarantees within 30 seconds on practical robotics tasks.

This paper solves the Steiner Traveling Salesman Problem on Graphs of Convex Sets—finding the cheapest path through required regions while allowing optional stops and revisits. The authors use branch-and-bound search with mathematical bounds to explore solutions efficiently, and demonstrate the approach on robot inspection tasks that combine sensing, movement, and task ordering.

Adriana Watson, Marco Bücheler, Grant Richards

LLMs can help create regulatory compliance documents, but their effectiveness depends heavily on how clearly the regulation defines the required format—strict rules ensure consistency but risk false information, while flexible rules need better prompts to stay complete.

This paper evaluates how well large language models can generate compliance documents required by EU regulations like GDPR and the Ecodesign for Sustainable Products Regulation.