Papers

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.

Nicolás Vera Zúñiga

Prompt effects on models are irreducibly about the specific prompt-model pair, not properties of either alone—and this interaction is detectable in task-free structural readouts where traditional mechanistic explanations break down.

This paper investigates how prompts interact with language models by examining a task-free structural property: the fixed-point behavior of short-window token prediction.

Haonan Jia, Shichao Dong, Zenghui Sun et al.

Retrieval can guide reinforcement learning to improve vision-language models for image captioning by helping identify and correct errors, outperforming standard supervised fine-tuning approaches.

This paper proposes Re³Cap, a method that uses retrieval-guided reasoning to improve image captioning with reinforcement learning. Instead of just fine-tuning models, it retrieves similar images and captions to help identify and fix errors (hallucinations and omissions) in generated descriptions, achieving better results than supervised fine-tuning without needing extra labeled data.

Huizu Lin, Chengkai Huang, Tianqi Gao et al.

Skills should be treated as dynamic learning tools that transition from external supervision to internalized decision knowledge, with their usefulness evaluated at the action level rather than uniformly across entire trajectories.

This paper presents AUSO, a method that helps AI agents learn when to use skills throughout their training lifecycle.

Yizhe Chi, Wenyi Li, Deyao Hong et al.

Current LLM agents struggle to design better training algorithms: even the best system closes only 20% of the gap between existing algorithms and optimal ones, suggesting recursive self-improvement through algorithmic design remains far out of reach.

This paper introduces AI4AI-Bench, a benchmark that tests whether AI agents can improve training algorithms themselves—a key capability for recursive self-improvement. The benchmark uses 10 frozen code repositories where agents get 4 hours to rewrite training algorithms, then the code runs for 12 hours and is scored against the original.

Yiyang Feng, Biddut Sarker Bijoy, Niranjan Balasubramanian et al.

Subtask-level skills expressed as text transfer more reliably across tasks than task-level or code-based skills, and you can predict skill usefulness by balancing how specific it is versus how broadly applicable it is.

This paper studies how LLM agents can learn and reuse skills from completed tasks. The researchers compare different ways of capturing skills—at the task level versus subtask level, and as text versus code—and find that breaking skills into subtasks and expressing them as text leads to better transfer across new tasks.

Gijs Kassenaar, Zhao Yang, Vincent François-Lavet

Language models can learn to self-allocate reasoning effort by choosing between predefined modes, reducing wasted computation on easy problems while maintaining performance—a practical way to make reasoning models more efficient without separate routing networks.

This paper shows that reasoning language models can learn to adaptively choose how much to think for each problem. Rather than using a fixed token budget, the model picks one of three modes at the start (quick answer, brief reasoning, or extended reasoning) and learns which mode fits each problem's difficulty.

Yu Chen, Ting Lei, Yaoyi Li et al.

Breaking down rule-following tasks into separate perception, rule interpretation, and planning steps helps multimodal models generalize better to new rules and constraints than end-to-end approaches.

This paper introduces RuleMaze, a benchmark for testing whether multimodal AI models can navigate mazes while following natural-language rules. The authors propose a method called Disentangled Multimodal Planning that breaks down the task into separate steps—understanding the scene, interpreting rules, and planning actions—to help models follow complex constraints more reliably.

Mengru Wang, Haozhe Luo, Zhenqian Xu et al.

Memory in LLMs can hurt performance even when perfectly accurate and relevant—the problem isn't retrieval quality but how retrieved information biases reasoning. A simple prompt-based fix can recover performance without redesigning memory systems.

This paper identifies and benchmarks 'cognitive traps' where LLMs with memory systems retrieve accurate, relevant information that paradoxically harms reasoning on current tasks. The authors introduce MemTrapBench to evaluate two failure modes (reasoning fixation and belief distortion) and propose AdaptiveMem, an inference-time method to mitigate these traps while maintaining memory benefits.

Wei Lin, Tao Zhou, Zhaofei Xie et al.

Future software will be built from three components—storage, models, and agents—replacing traditional layered architecture. This shift means developers must rethink how they structure applications, with AI models handling logic and interfaces rather than hand-coded layers.

This paper argues that software architecture is undergoing a third major shift—from instruction-based (Software 1.0) and data-driven (Software 2.0) systems to context-and-reasoning-driven systems (Software 3.0).

Haoxiang Cao, Jiajiong Cao, Xuanpu Zhang et al.

By decomposing credit assignment across both pipeline stages and within the planner's reasoning trace, DARS enables more efficient training of complex multi-stage image editing systems compared to naive joint optimization.

DARS is a reinforcement learning system for training instruction-based image editing that uses a two-stage pipeline (planner + renderer). It solves the credit assignment problem—figuring out whether failures come from bad planning or bad rendering—using structured reasoning outputs and multi-level reward analysis to provide targeted feedback to each component.

Dingzirui Wang, Xuanliang Zhang, Keyan Xu et al.

LLMs struggle most with converting informal mathematical claims into formal statements—not with proving them—suggesting that bridging the gap between natural language mathematics and formal verification is the key challenge for autonomous mathematical research.

This paper introduces FormalTCS, a benchmark of 175 frontier theoretical computer science research problems from top venues, with expert-verified formal proofs in Lean.

Mehdi Azarafza, Faezeh Pasandideh, Ali Ehteshami Bejnordi et al.

LLMs work best in autonomous systems when used for reasoning and planning rather than direct control—this hybrid approach maintains safety while gaining contextual understanding for complex driving decisions.

This paper proposes a hybrid autonomous driving system that combines reinforcement learning, PID control, and LLM reasoning through an orchestrator.

Lohithsai Yadala Chanchu, Hany Abdulsamad, Christian A. Naesseth

Nested sequential Monte Carlo methods provide a principled way to steer discrete diffusion language models at inference time, outperforming simpler sampling approaches by better managing the exploration-exploitation tradeoff without model retraining.

This paper improves how language models can be steered toward desired outputs (like less toxic or more fluent text) during generation without retraining.

Mattia Carletti, Edward Phillips, Fredrik K. Gustafsson et al.

LLMs don't arbitrate evidence rationally—they rely on predictable heuristics like recency bias and text preference, which can cause failures in real-world decision systems that combine multiple information sources.

This paper studies how large language models decide between conflicting evidence from text, numbers, and external tools.

Bo Liu, Simon Yu, Yiding Jiang et al.

Making environment design itself learnable—rather than hand-curated or static—enables continuous self-improvement in language agents by automatically generating appropriately-difficult, diverse training tasks.

SPADE is a self-play framework where a single language model learns two roles: designing custom training environments as executable code, and solving problems within them. The environment designer learns to create challenges at the edge of the agent's abilities, automatically adapting as the agent improves.

Zhu Zhang, Jixun Wang, Xiaoang Xu et al.

When training smaller models on long-context tasks, combining token-level teacher guidance with task-level verifier rewards—by measuring and distributing their disagreement—works better than either signal alone.

This paper addresses a key problem in training smaller language models for long-context tasks: teacher models give token-level guidance that looks locally correct but misses global evidence or violates task constraints.

Anran Wang, Wen Shi, Yong Luo et al.

AI climate predictions become more trustworthy when you can explain which physical mechanisms drive the forecast; here, interpretability methods confirmed the model's drought prediction is based on real atmospheric physics, not spurious patterns.

Researchers used a deep learning model combined with interpretability techniques to predict a summer 2026 drought in central China.

Tomasz R. Bielecki, Thibaut Mastrolia, Haoze Yan

You can apply continuous-time reinforcement learning to complex, memory-dependent systems by first converting them to Markovian approximations—this opens up RL applications to event-driven processes like financial markets and network dynamics.

This paper tackles reinforcement learning for systems driven by Hawkes processes—mathematical models where events cluster in time and influence future events. The key challenge is that these systems have memory and aren't Markovian, so standard RL doesn't apply.

Bingxin Xu, Yuzhang Shang, Emilio Ferrara

Breaking long robot tasks into independently explored subtasks with explicit transition management reduces exploration cost from exponential to linear and improves success rates by 15% on benchmarks.

This paper presents BATON, a system for long-horizon robot manipulation that combines vision-language-action models with LLM planning. Instead of learning end-to-end, BATON explores individual subtasks cheaply, stores solutions in memory, and chains them together while managing transitions between subtasks using a verifier agent and handoff mechanisms.

Kejia Zhang, Youran Sun, Xinyu Ren et al.

Symbolic regression works better when you preserve the scientific reasoning behind each equation candidate—not just the formula itself—allowing AI agents to learn from failed attempts and build credible explanations for why one equation is better than others.

AutoSR is an automated system that discovers scientific equations from data by treating symbolic regression as a research investigation rather than just equation fitting.

Shuai Huang, Zhe Qu, Zhaowei Hua et al.

Quantile-based survival prediction reveals how treatment effects vary across the survival distribution—some patients benefit early, others late—information hidden by standard hazard ratios and now achievable without crossing quantile curves.

This paper introduces a method for predicting survival times that captures how different patients respond differently at early vs. late stages of disease. Unlike traditional survival models that give a single risk number, this approach estimates the full distribution of survival times while ensuring predictions stay logically consistent (quantiles don't cross).

Jonathan Sadeghi, Jenny Seidenschwarz, Jesse Allardice et al.

Popular video generation models systematically fail to match real-world probability distributions—they collapse to a few likely outcomes rather than capturing the full range of possible physical events, which matters for any application requiring accurate uncertainty quantification.

CaliBench tests whether video world models accurately reproduce the probability distributions of physical outcomes.

Yubo Zhang, Yiyao Liu, Xiaodong Wang

Neural networks can learn efficient search strategies for MIMO detection that match or exceed traditional algorithms, and these learned policies can be transferred to soft-output receivers that improve when combined with iterative decoding.

This paper presents a learning-to-transition framework that uses Transformers and neural networks to efficiently detect high-order MIMO signals. The approach treats detection as a sequence of symbol transitions, learns to search the discrete symbol space effectively, and integrates with channel decoding through an iterative receiver that adapts based on decoder feedback.

Zhelun Wu

When combining evidence from multiple sources, separate the task of interpreting each source from aggregating those interpretations—use structured tuples and calibrated scoring rather than simple concatenation and vote counting.

This paper separates evidence interpretation from decision aggregation in multi-source reasoning systems. Instead of concatenating sources into one prompt, the authors propose a structured evidence tuple (hypothesis, reliability, rationale, provenance) and show how to properly combine interpretations using calibrated log-likelihood ratios.

Alexy Skoutnev, Kirill Acharya, Gaston Longhitano et al.

Test-time world model inference—where an AI builds and validates its own simulation of unknown environments—dramatically improves task performance (from 7.8% to 93.3%) and shows that learning game rules is easier than inferring goals.

Twin is a system where an AI agent builds executable world models to solve puzzle games by observing and simulating gameplay. Rather than hand-coding rules for each game, the system learns the game's mechanics through trial and error, validates predictions against actual outcomes, and fixes mismatches. It solves 97.8% of test games more efficiently than humans.

Ajith Anil Meera, Pablo Lanillos, Wouter Kouw

Expected Free Energy provides a single, tunable objective that lets robots efficiently explore unknown environments by balancing information gathering with resource constraints—useful for real-world autonomous missions.

This paper applies Expected Free Energy from active inference to robotic path planning for Mars exploration. The robot must balance two goals: building accurate maps and finding high-value regions (like water sources) while staying within travel and measurement budgets. The approach outperforms traditional information-seeking methods by unifying both objectives under one principled framework.

Ziyang Luo, Zhongyao Chu, Xinjie He et al.

You can improve a frozen language model's reasoning and confidence detection in one forward pass by reconstructing clean internal states after steering, rather than running separate passes or accepting interference between techniques.

This paper solves a key problem in frozen language models: they both misuse their internal knowledge and fail to recognize when they lack sufficient information to answer.

Yaxin Luo, Haobin Jiang, Jialv Zou et al.

You can automatically optimize how agents interact with tools by having them learn from rollout feedback—AutoDesign shows this approach consistently improves performance across different models and scales to real-world tasks.

AutoDesign is a framework that automatically improves how AI agents interact with tools by learning from feedback. It treats complex tasks like converting academic papers into posters as a long-horizon process where a meta-optimizer guides a code agent to refine its interaction patterns.

Bobo Li, Hao Fei, Tianjie Ju et al.

Direct perception of raw scientific data—not just text summaries—is critical for AI systems to conduct rigorous, evidence-grounded research. OmniScientist shows that multimodal input improves all aspects of automated scientific discovery.

OmniScientist is an AI system that conducts scientific research across multiple disciplines by directly processing raw data in many formats—images, videos, audio, 3D structures, tables, and more.

Zhe Ye, Hantao Lou, Yuechun Sun et al.

AI agents can generate code, but generating code with formal proofs that work together across entire repositories remains an unsolved problem—current best agents only solve 27 of 43 real-world instances.

Vero is a benchmark for evaluating whether AI agents can generate both correct code implementations and machine-checked formal proofs together across real multi-module software repositories.

Nestor R. Barraza, Gabriel Pena

Machine learning performance has hard mathematical limits set by data structure, not just algorithm choice. Understanding these limits requires proper models of how data is generated, especially for systems with feedback like LLM agents.

This paper examines fundamental limits on what machine learning systems can achieve, showing that performance is constrained by the structure of the data itself rather than just algorithm design.

Lei Bai, Jiaqi Cao, Chiyu Chen et al.

This work demonstrates how to build AI agents for science by combining multimodal pre-training with agentic reinforcement learning and memory-augmented architectures, achieving strong performance on scientific reasoning and forecasting tasks without requiring task-specific model modifications.

Intern-S2-Preview is a large multimodal AI system designed to tackle scientific discovery tasks by reasoning over diverse data types, using scientific tools, and working across long-horizon problems.

Sabin Roman, Ljupco Todorovski, Saso Dzeroski

SORT shifts equation discovery from brittle library selection to basis design: by learning sparse coefficients in well-chosen orthogonal bases, it provides a more stable intermediate representation that gracefully degrades under noise and sampling sparsity.

SORT is a machine learning technique that learns compact mathematical representations of dynamical systems from noisy, irregularly sampled data by fitting sparse coefficients in orthogonal basis expansions.

Saisha Shetty, Satvik Tripathi, Austin Lin et al.

For clinical AI, breaking monolithic prompts into traceable multi-agent workflows improves interpretability and failure diagnosis compared to single-LLM approaches, while remaining accessible to non-programmers.

MARC is an open-source framework that replaces single-prompt LLM calls with coordinated teams of specialized agents for clinical reasoning. Each agent handles a specific task (extracting data, reasoning, generating answers, evaluating results), with clear handoffs between stages so failures can be traced.

Mohammed Ayman Habib, Rylan Hart, Morteza Fayazi

LLMs can automate the full analog circuit design process—not just sizing or topology separately—by using multiple agents that debate and refine designs, achieving 40x faster results than manual approaches while discovering novel circuit topologies.

AaLLM is an end-to-end framework that uses multiple AI agents working together to automatically design analog circuits from scratch. It takes design requirements as input and outputs complete circuit designs (both the circuit structure and component values), reducing the time-consuming manual work that circuit engineers typically do.

Jim Woodcock, Gabriel Leite, Augusto Sampaio et al.

When using LLMs to modify formal proofs, you need independent verification beyond just checking if the code compiles—CAPRI shows that contract-based auditing can catch unauthorized changes that Isabelle alone would miss.

CAPRI is a system that uses LLMs to help repair broken Isabelle proofs while ensuring developers maintain control over what gets changed. It combines Isabelle's proof checker with an independent contract enforcer that tracks all changes, keeping an audit trail of prompts, proposals, and verdicts.

Avinash Kori, Fabrizio Russo

World models need to learn causal structure and entity interactions, not just predict observations. This enables agents to reason about why things happen and make better decisions outside their training distribution.

This paper proposes a framework for understanding world models through a causal lens, arguing that effective world models should capture not just how to generate future observations, but also the underlying causal structure—entity properties, interactions, and dynamics—that explains environmental behavior.

Andy Yang, Blerta Veseli, Corentin Barloy et al.

Transformers' ability to generalize to longer sequences depends on specific algebraic properties of the language being learned—properties that classical finite algebra misses but can be captured by extending decomposition theory to infinite groups.

This paper characterizes which regular languages transformers can generalize to longer sequences than they've seen during training. The authors develop new algebraic theory extending classical decomposition methods to handle transformers' unbounded counting abilities, providing a polynomial-time algorithm to predict length generalization on any regular language.

Yiwei Li, Wanli Yang, Hexiang Tan et al.

Current AI agents excel at combining existing techniques but lack the consistency and genuine innovation needed for autonomous research; improving their performance requires better experience management and more stable inference strategies, not just larger models.

This paper evaluates how well AI agents can autonomously improve technical systems through long-horizon experimentation. Rather than just looking at final scores, the researchers developed a framework to analyze what happens during the process—how agents formulate solutions, execute them, and learn from feedback.

Shivam Vats, Sudarshan Harithas, Mete Tuluhan Akbulut et al.

When robots have limited time to practice, you can use optimization to compute exactly which skills to learn and how long to spend on each—trading off learning difficulty against the reward value each skill unlocks.

This paper tackles how robots can learn skills efficiently when practice time is limited. The authors propose Deliberate Practice, an algorithm that decides which skills to practice and for how long to maximize task performance within a fixed budget. They use a mathematical optimization approach to find the best allocation of practice time across different skills.

Yan Deng, Fei Xu

For embodied AI agents navigating from visual instructions, explicitly modeling temporal context (past-only memory), multi-step planning with single-step execution, and decoupled termination detection significantly improves navigation success and efficiency.

DreamFly improves aerial drone navigation by combining three key techniques: a causal memory system that uses only past observations to avoid information leakage, a receding-horizon planning approach that predicts multiple future actions but executes one at a time, and explicit stop detection from action predictions.

Cheng Qian, Wenting Zhao, Liangwei Yang et al.

You can transfer capabilities from strong to weak models at inference time through clever prompt engineering and code scaffolding, achieving similar gains to training-time distillation without any parameter updates.

This paper shows that stronger AI models can help weaker ones solve tasks better at test time by building 'harnesses'—structured inference-time scaffolds like code templates and routing logic—without retraining. Testing on reasoning benchmarks, the approach nearly doubles weaker model performance by offloading unstable reasoning into deterministic code and enforcing strict output formats.

Saman Marandi, Yu-Shu Hu, Mohammad Modarres

LLMs with retrieval-augmented generation can automatically build executable functional models from technical docs, enabling scalable diagnostic reasoning for complex systems that traditionally required manual expert work.

This paper automates the construction of Dynamic Master Logic models—hierarchical diagrams showing how system failures propagate—by converting technical documentation into knowledge graphs using AI. The approach enables faster analysis of complex systems like nuclear reactors for safety and diagnostics without requiring manual expert interpretation.

Alireza Kargarzadeh, Nariman Khaledian, Navid Parvini et al.

LLM-extracted sentiment matters for trading, but how you separate firm-specific signals from macro-driven ones, and which allocation method you choose, matters just as much as which sentiment model you use.

This paper shows how large language models can improve small-cap stock trading by extracting sentiment from financial news and combining it with macro indicators and technical signals. Rather than treating portfolio risk as fixed, the authors feed model-predicted risk (split into two types of uncertainty) directly into portfolio construction.

Ankita Rajaram Naik, Anupama Murthi, Benjamin Elder et al.

Current LLMs fail at the reasoning layer when using APIs in realistic settings: they struggle to connect information across sources and understand policy constraints, not because they can't call tools, but because they can't figure out what to call and in what order.

VAKRA is a benchmark with 8,000+ real APIs across 62 domains that tests whether AI agents can reason across multiple data sources and follow tool-use policies. Unlike existing benchmarks that test API calling or retrieval separately, VAKRA combines both in realistic enterprise scenarios.

Alan Li, Rahul Saha, Anton Xue et al.

AI systems can make genuine research contributions in mathematics by discovering non-obvious insights, but their effectiveness depends heavily on how they're integrated into human workflows and problem formulation.

Researchers used an AI system to improve mathematical bounds on the Grothendieck constant, a fundamental problem in computational complexity. The AI discovered novel insights that human experts recognized as significant, demonstrating how AI agents can contribute meaningfully to pure mathematics research when given the right conditions.

Eric A. F. Reinhardt, Adam J. Hauser

Softmax attention has an exact quantum mechanical interpretation where attention scores become measurement statistics and the softmax function emerges naturally from quantum probability rules, opening a path to quantum implementations of transformers.

This paper shows how softmax attention in transformers can be exactly implemented using quantum computing. The researchers map each component of attention—from computing scores to aggregating values—to quantum operations like measurements and rotations. They prove this works mathematically and verify the core logic in formal proof software.

Shiqi Huang, Jiani He, Dingyan Shang et al.

For real supply-chain problems, choosing the best intervention requires balancing model complexity against domain knowledge—adaptive ranking improves outcomes by 5-16% in some cases, but simpler policies often work just as well or better, especially under uncertainty.

This paper introduces a benchmark for choosing interventions in supply-chain disruptions based on maximizing recoverable value, not just identifying what went wrong.

Minsoo Kim, Sungyoung Ji, Kisung Moon et al.

Model uncertainty isn't just about output confidence—it's also about whether confident predictions break down when you perturb the attention mechanisms that produced them. This fragility signal catches errors that confidence alone misses.

This paper introduces ASMI, a method to detect when large language models are uncertain about their predictions by measuring how fragile their answers are when attention pathways are perturbed. Unlike confidence scores alone, ASMI identifies 'confident-but-fragile' predictions that are likely wrong, cutting error rates in half on question-answering tasks without requiring multiple model samples.

Davide Rinaldi, Luciano Serafini

If you're building neurosymbolic systems that need to reason about ordered or connected data, sLTN lets you write logical rules about structure (like "event A happens before event B") and train them end-to-end with neural networks.

sLTN extends Logic Tensor Networks to handle structured data like sequences and graphs by treating structural dimensions (time steps, positions, nodes) as first-class elements in the logical language. This lets you express temporal and relational constraints directly in logic while keeping everything differentiable for neural learning.

Derin Gezgin, Jim O'Connor, Tanner Goodwin et al.

Dark Souls bosses are an extremely challenging RL benchmark—current deep RL methods achieve near-zero performance, suggesting the domain requires advances in long-horizon reasoning, sparse rewards, and real-time decision-making under pressure.

DSLE is a benchmark platform that turns Dark Souls boss fights into reinforcement learning environments. It provides 22 real-time combat scenarios with visual input and sparse rewards, plus a curated 5-boss subset for standardized evaluation. Current RL methods (PPO, DQN) fail dramatically, while even hand-crafted solutions barely beat the tutorial boss.

Lecheng Kong, Like Hui, Haitao Mao et al.

When scaling LLM reasoning at test time without external verifiers, don't just pick the most confident answer; instead, select reasoning paths that show exploratory uncertainty early and convergence to certainty later.

This paper identifies a critical flaw in confidence-based test-time scaling for LLMs: high confidence across all steps often signals failure to explore, leading to confidently wrong answers.

Congfeng Cao, Pengyu Zhang, Jelke Bloem

Training models for both fast responses and deep reasoning requires careful balancing—prioritizing one mode degrades the other, and the optimal training schedule depends on how much data you allocate to each mode.

This paper studies how to train language models that can switch between quick answers and detailed reasoning. The researchers found that training these two modes together creates a trade-off: focusing more on quick answers hurts the model's ability to reason deeply. They tested different training schedules and data ratios to find the best balance for math problems.

Björn Engdahl, Adrian Kosowski, Jan Chorowski et al.

Recurrent latent reasoning (thinking without verbalizing) combined with in-context learning enables smaller models to solve complex reasoning tasks more cost-efficiently than larger models that explain their work.

BDH-CQ is a reasoning model that learns from examples at inference time and solves problems through hidden, iterative computation rather than step-by-step explanations. On the ARC-AGI benchmark, a small 150M-parameter version achieves 29.5% accuracy while costing just $0.0007 per task—better cost-efficiency than previous approaches.

Xu Ouyang, Moontae Lee

Language models can be trained to output financial predictions and portfolio weights as constrained tokens, matching or beating traditional regression-based approaches while maintaining a unified model architecture.

This paper shows that language models can directly generate financial forecasts and investment decisions as tokens, rather than using separate prediction heads. FinATOM uses constrained token generation to predict stock returns and allocate across ETFs, achieving better risk-adjusted returns than traditional approaches when trained with ranking supervision and reinforcement learning.

Diandian Zhang, Tingyu Song, Lin Fu et al.

Visual realism in video generation doesn't guarantee scientific correctness: models that look good often fail at capturing accurate scientific and causal dynamics, a gap that needs targeted evaluation and improvement.

Sci-VBench is a benchmark with 1,253 expert-annotated examples for evaluating how well AI models generate videos that require scientific knowledge and reasoning across 60 subjects in science, healthcare, humanities, and engineering.

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

LLM-based agentic reasoning can solve open-ended chemistry problems requiring creative strategy, not just pattern-matching from reaction databases—suggesting AI can tackle frontier scientific challenges where training data is sparse.

SynthEx is an AI system that plans chemical synthesis routes for complex natural products by reasoning strategically like expert chemists.

Mingxuan Zheng, Yujin Zhou, Chuxue Cao et al.

Agents can evolve skills more effectively by coupling failure diagnosis with proximal optimization: diagnose what went wrong, test fixes on the same tasks, then systematically audit and remove unhelpful skill components.

SkillProx improves how AI agents learn and refine reusable task skills by combining diagnostic feedback loops with a mathematical optimization approach. Instead of treating skill edits generically, it explicitly diagnoses failures, rolls back unsuccessful changes, breaks skills into auditable components, and removes or demotes unhelpful knowledge—improving task accuracy by 3 percentage points.

MY Pitsane, Hope Mogale

For developers building with coding agents: smart context eviction can cut token costs by a quarter while maintaining byte-exact reversibility, making long-running agentic coding tasks more affordable.

Blast Radius is a memory management system for AI coding agents that predicts how much context a prompt needs and intelligently removes unused code/context to save tokens. It archives dead code reversibly and identifies repeated patterns, reducing token use by 17-26% while keeping everything recoverable.

Mohammad Amanlou, Parham Abed Azad, Farbod Davoodi et al.

Emotional significance and unresolved conflicts should shape what memories an AI agent retrieves, not just semantic similarity—this improves handling of complex, emotionally-laden scenarios.

PsychoAgent is a memory system for AI agents that mimics how humans remember—not just by topic relevance, but by emotional importance and unresolved conflicts. It separates factual and emotional memories, then uses an emotional filter to surface conflict-critical information when needed, showing better retrieval of conflict-relevant memories than standard similarity-based approaches.

Jiacheng Miao, Jin Mu, Guanhua Chen et al.

LLM agents need specialized training on verified statistical tasks to reliably conduct hypothesis testing—standard benchmarks miss inferential errors, and reinforcement learning with statistical rewards substantially improves correctness.

LLM agents often make subtle statistical errors when conducting hypothesis testing, even when code runs correctly. This paper introduces P-Bench, a benchmark of 425 realistic hypothesis-testing tasks, and Fisher-R1, an open-weight agent trained with reinforcement learning to perform rigorous statistical analysis.

Zhaoyu Zhu, Rui Gao, Shuang Li

Wasserstein policy gradient converges exponentially fast for entropy-regularized linear-quadratic control without exponential slowdown as regularization decreases, making it a theoretically sound alternative to standard policy gradient methods.

This paper studies how to optimize control policies using Wasserstein gradients—a method that updates action distributions by moving them in action space. For linear-quadratic control problems with entropy regularization, the authors prove that this approach reduces to a simple finite-dimensional system that converges reliably to the optimal policy, even as the regularization strength changes.

Sarvesh Baskar, Zikui Cai, Shayan Shabihi et al.

Video models fail not because they can't see events, but because they can't reliably track and count them over time—adding more frames helps slightly but doesn't fix the core temporal reasoning problem.

Video language models struggle with counting events in videos, especially when events happen frequently or repeatedly.

Xinye Wang, Junxiao Liu, Shujian Huang

By identifying and prioritizing training on critical reasoning decisions (pivots) rather than all tokens equally, multilingual reasoning transfer becomes more efficient and effective across 17 languages.

This paper improves how large language models learn to reason in multiple languages by focusing training on the most important decision points in reasoning—called 'reasoning pivots'—rather than treating all tokens equally.

Yunjia Qi, Zehua Yin, Xintong Shi et al.

When LLM agents fail at complex tasks, you need to trace which error actually caused the failure—not just find any mistake—because long trajectories have multiple errors with different downstream impacts.

TrajDebug is a framework for identifying critical errors in long agent trajectories by tracing error lifecycles and determining which mistakes actually caused final failures. It uses history compression and evidence-based analysis to handle scattered context, then tracks whether errors were resolved or led to terminal failure.

Donna Hooshmand, Shubham Shahi, Cameron Barrie et al.

Automating semantic schema construction lets non-technical users query databases without expert help, and TYTAN's hybrid symbolic-LLM approach achieves production-ready accuracy by knowing when to ask humans for clarification.

TYTAN automatically builds semantic schemas for relational databases by combining symbolic analysis with LLM inference to identify entities, relationships, and data roles. It asks targeted questions when ambiguous, achieving 100% coverage and correctness on real-world databases—eliminating the manual work that currently bottlenecks data analysis tools.

Chenglong Wang, Ziming Zhu, Yifu Huo et al.

Generative reward models work better in RL when you extract rewards from their ranking capabilities rather than forcing them to produce scalar scores—use pairwise or reference-based comparisons instead.

This paper shows how to use generative reward models (which rank responses) effectively in reinforcement learning for language models. The key insight is that generative models naturally compare responses rather than score them individually.

Yijiang Li, Bingyang Wang, Yijun Liang et al.

You can improve LLMs through self-distillation using only the model's own outputs and internal consistency, without needing ground-truth labels or external feedback—making it truly self-supervised post-training.

This paper introduces Unsupervised On-Policy Self-Distillation (U-OPSD), a method that improves language models without requiring external supervision like ground-truth answers or feedback from larger models.

Mutasim Fuad Sarker, Adiba Rahman Namira, Wafa Binte Alam et al.

Quantum-enhanced neural networks can match or exceed classical models for medical time-series prediction while using 100x fewer parameters—suggesting quantum computing may enable efficient clinical AI systems.

QuanTiMedAI combines quantum computing with AI agents to predict mortality in cardiac arrest patients using ICU time-series data. The system uses an LLM agent to select relevant clinical features and a quantum recurrent network to model how patient conditions change over time, achieving better accuracy with far fewer parameters than traditional approaches.

Jonas Gann, Michael Gertz

By converting retrieved text into executable Prolog rules, you get verifiable reasoning traces linked to sources and automatic detection of missing information—achieving 43% higher accuracy than standard RAG on a benchmark.

NeSy-RAG combines neural language models with symbolic logic (Prolog) to make question-answering systems more transparent and verifiable. Instead of treating retrieved information as black-box text, it converts document chunks into logical rules that can be executed step-by-step, showing exactly which sources support each conclusion and detecting when user context is missing.

Lev V. Utkin, Stanislav K. Kogan, Andrei V. Konstantinov

Attention mechanisms can effectively estimate personalized treatment benefits in survival analysis by learning to aggregate pairwise patient comparisons, especially when standard methods struggle with nonlinear treatment effects.

This paper introduces Surv-IPTB, an attention-based model that estimates the probability individual patients will benefit from a specific treatment using survival data.

Zhiheng Wang, Bo Peng, Lai Wei et al.

Visual tool-use in multimodal models often creates an illusion of improvement: while aggregate accuracy may increase, the returned visual evidence frequently has no causal effect on the final answer, making these expensive operations ineffective for most queries.

This paper investigates whether multimodal AI models actually benefit from visual tool-use operations like cropping and zooming. Using causal analysis, the authors discover that these operations often don't meaningfully improve answers despite higher computational cost—models either ignore the visual evidence they retrieve or use it incoherently.

Zonghuan Xu

When evaluating models, adaptively selecting tests based on previous responses can be quadratically more efficient than non-adaptive testing, but this advantage is fundamentally limited and cannot be exponential.

This paper studies how much interaction helps when testing statistical hypotheses. It compares two evaluation strategies: fixing all tests upfront versus adaptively choosing tests based on earlier results. The key finding is that interaction can reduce the number of required tests by a quadratic factor, but not exponentially—despite the apparent complexity of adaptive branching.

ZhiYan Hou, Xinyu Tang, Hongyan An et al.

Adaptive weighting of token-level supervision based on divergence sequences improves reasoning model training—the timing and context of prediction errors matter more than their magnitude alone.

This paper improves on-policy self-distillation for reasoning models by making supervision weights adaptive to how prediction errors evolve during generation. Instead of treating all mismatches between teacher and student equally, DASH uses gates to weight supervision based on local divergence patterns, improving math reasoning across model sizes without extra computation.

Sam Levang, Fran Bartolic, Ty Dickinson et al.

You can now configure forecast timesteps after training instead of before, letting one model handle both detailed short-range and stable long-range weather predictions without retraining.

GEM-3 is a weather forecasting model that solves a key problem: existing models must choose between short timesteps (detailed but error-prone) or long timesteps (stable but missing short-term details). This model lets you pick the timestep at inference time with a single trained model, and training on mixed timesteps makes forecasts more stable across longer periods.

Christo Kurisummoottil Thomas, Omar Hashash, Walid Saad

Networks can become active intelligence coordinators for physical AI by deploying reasoning agents (digital twins) that share spatiotemporal context through causal reasoning and transmit only beliefs with cognitive value, rather than optimizing for throughput alone.

This paper proposes holonic digital twins (HDT-Nets)—intelligent network agents that actively reason about their environment rather than passively mirroring physical systems.

Yixiong Xiao, Congxi Xiao, Jingbo Zhou

RAG can boost time series forecasting by retrieving similar past sequences and intelligently fusing them into the model, rather than just appending them like in language models.

This paper adapts retrieval-augmented generation (RAG) to time series forecasting by retrieving similar historical sequences and using special tokens to blend them with input data.

Zishan Xu, Zhiyuan Yao, Yuxin Chen et al.

Training agents with internal world rehearsal—where the agent simulates environment responses—is more efficient than external environment interaction and enables better generalization across tool-use tasks.

EnvACE trains AI agents to use tools by having them internally simulate environment responses instead of relying on external simulators. The agent learns to both act and play the environment's role, building an internal world model that predicts what happens after each action. This approach reduces the need for expensive external environments while improving performance on tool-use benchmarks.

Damien Sileo, Valentin Lacombe, Dimitri Kachler

Procedural datasets for training reasoning models need careful design beyond correctness: difficulty calibration, compact targets, and rigorous auditing (combining model review, human judgment, and testing) significantly impact training utility.

This paper introduces Reasoning Core, a collection of 50 procedural generators that create verifiable reasoning problems across diverse domains (math, logic, planning, code, etc.). The authors compare their dataset with three alternatives using completion-supervised fine-tuning on 3B models, showing Reasoning Core achieves better performance on reasoning benchmarks.

Boxiu Li, Zimo Wen, Yijia Fan et al.

A fixed-weight AI system can achieve strong performance on complex tasks (78% on SWE-Bench Pro) by using persistent runtime state, role-based review processes, and verification gates instead of model retraining—showing that intelligent behavior emerges from better control and memory, not just l...

Argus is a runtime system that enables AI agents to tackle complex, long-horizon tasks by persisting through failures and learning from experience.

Yinghui He, Ling Yang, Jiarui Liu et al.

Models struggle to switch between different reasoning skills in long tasks, and explicitly training them to recognize and predict which skill to use at each step dramatically improves their ability to handle complex multi-step reasoning.

This paper introduces Skill Entropy, a metric for measuring how difficult it is for language models to switch between different reasoning skills (like math, planning, coding) in long multi-step tasks. The authors create Skill²-Bench, a benchmark with 558 skills across 9 domains, and show that current models struggle more on tasks requiring frequent skill switches.

Purbesh Mitra, Sennur Ulukus

Breaking complex reasoning into multiple fresh inference passes with shared artifacts lets LLMs catch and correct mistakes earlier, improving accuracy on multi-step tasks like counting, ordering, and multi-hop reasoning.

This paper proposes Chained Recursive Language Models (Chained RLM), a system where an LLM is called multiple times in sequence to solve complex reasoning tasks. Instead of trying to do everything in one long response, each call gets the original problem plus a summary of previous work, allowing the model to inspect and fix earlier mistakes before moving forward.

Roberto Aliaga Medina, Paulina Quintanilla, Antonio del Rio Chanona

LLMs can significantly accelerate scientific model discovery by injecting domain expertise into symbolic regression, cutting experimental iterations roughly in half while maintaining prediction accuracy.

This paper combines symbolic regression with large language models to automatically discover kinetic models in chemistry and bioprocessing. The LLM critiques candidate models and proposes new ones based on chemical knowledge, reducing the number of iterations needed to find correct models by 41-79% compared to standard symbolic regression alone.

Jai Malegaonkar, Rohan Patil, Henrik I. Christensen

Exploration bonuses and memory architectures aren't independent tools—their effectiveness depends entirely on reward structure.

This paper reveals how reward structure fundamentally shapes whether exploration bonuses help or hurt reinforcement learning agents.

Arunava Majumder, Marius Krumm, Hendrik Poulsen Nautrup et al.

Shallow quantum generative models become strictly more powerful when augmented with classical randomness—a weak resource that enables long-range correlations impossible for unitary-only circuits at fixed depth.

This paper proves that adding shared classical randomness to shallow quantum circuits can generate probability distributions that require much deeper purely quantum circuits to replicate. The authors show this separation is achievable with simple local operations controlled by a single random bit, and demonstrate how measurement-based quantum computation naturally implements this approach.

Zhenran Wang, Zhonghan Bian, Jinsong Li et al.

Current frontier LLMs struggle with social forecasting (max 75/100), and their strengths in probability calibration don't guarantee temporal accuracy—revealing a gap between understanding likelihood and timing in real-world events.

SocietyBench is a benchmark that tests how well LLMs can forecast social events by understanding real-world timelines. It anonymizes events by replacing names and shifting dates to prevent models from relying on memorized information, then scores predictions on probability calibration and temporal accuracy across five real events in Chinese and English.

Zhenran Wang, Zhonghan Bian, Jinsong Li et al.

Current frontier LLMs struggle with genuine prospective forecasting and tend to converge on safe predictions rather than leverage their reasoning capabilities; live benchmarks reveal performance gaps invisible in retrospective evaluations.

Researchers evaluated six frontier LLMs with extended thinking and web search on live FIFA World Cup 2026 predictions before each match occurred, ensuring no data leakage.

Changle Qu, Sunhao Dai, Hengyi Cai et al.

Turn-level hindsight feedback with cross-horizon validation provides denser, more reliable training signals for tool-using AI agents than traditional trajectory-level approaches, improving learning efficiency in long-horizon reasoning tasks.

TurnSight improves how language models learn to use tools by providing better feedback during training. Instead of judging entire sequences at once, it gives turn-by-turn (step-by-step) feedback based on what actually happened, using multiple future perspectives to decide which feedback is most reliable. This helps models learn faster and more accurately in complex multi-step tasks.

Shuhan Xue, Zixin Ding, Yichen Shen et al.

Most agents show some improvement from retained experience, but the gains are uneven and often don't follow the intended learning pathway—suggesting that simply storing information doesn't guarantee agents will use it effectively to improve.

PAST-Bench is a benchmark that tests whether personal AI agents actually improve over time by learning from retained experience across sessions. The benchmark isolates this capability by running agents through task sequences with experience turned on and off, measuring both performance gains and whether improvements follow the intended save-retrieve-update pathway.

Mohsen Hariri, Weicong Chen, Nahal Shahini et al.

Test-time scaling isn't one thing: different inference strategies have different statistical structures and failure modes. Comparing them requires protocol-matched reporting of compute, uncertainty, and the exact inference method used—not just a single 'budget' number.

This paper systematizes how LLMs can solve harder problems by spending more compute at inference time. It clarifies that different 'test-time scaling' approaches (like trying multiple solutions or searching through partial answers) work fundamentally differently, making direct comparisons misleading.

Zhen Fang, Yu Zeng, Wenxuan Huang et al.

Multimodal agents need explicit architectural constraints to use visual tools and external knowledge rather than defaulting to text search and internal memory; decoupled perception-exploration pipelines with staged tool unlocking significantly improve performance.

Video-DeepResearch extends multimodal AI agents to handle continuous video streams with web search integration. The system addresses two key problems: agents ignoring visual information in favor of text search, and relying on memorized knowledge instead of actually using tools.

Jinhe Bi, Chennan Zhou, Zengjie Jin et al.

Failed expert trajectories are learning gold: teaching models to reflect on why attempts failed is often easier than solving hard problems from scratch, and this reflective skill transfers to direct problem-solving.

ReflectRL shows that when expert models fail on hard problems, their failed trajectories aren't wasted—they're valuable for learning. The method trains models to reflect on these flawed attempts, then transfers that reflective reasoning back to solving problems directly. This lightweight approach works across multiple benchmarks and training methods with minimal computational cost.

Yordan Raykov, Rodrigo Veiga

By treating forward-policy training as a geometric optimization problem, you can leverage the target distribution's structure (factorization, locality) to compute better gradient updates, leading to faster convergence and better exploration in GFlowNets.

This paper reformulates how to train the forward policy in GFlowNets (a framework for sampling from complex distributions) using information geometry.