Papers

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

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

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

Chase McDonald, Nathan Tsang, Wesley N. Kerr

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

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

Yaqi Wu, Xiaolei Guo, Chenyu Zhou et al.

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

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

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

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

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

Jacky Kwok, Shulu Li, Pranav Atreya et al.

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

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

Yunhe Li, Hao Shi, Wenhao Liu et al.

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

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

Timo Bertram, Sidhant Bhavnani, Richard Freinschlag et al.

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

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

Liyan Tang, Fangcong Yin, Greg Durrett

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

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

Zhilin Wang, Han Song, Runzhe Zhan et al.

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

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

Sanjeev Shrestha, Hui Liu, Yifan Zhang

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

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

Juliette Decugis, Fabian Gloeckle, Francis Bach et al.

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

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

Ziyu Chen, Yilun Zhao, Arman Cohan

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

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

Zijian Zhang, Rizhen Hu, Athanasios Glentis et al.

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

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

Shengguang Wu, Hao Zhu, Yuhui Zhang et al.

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

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

Ben Slivinski, Michael Saldivar

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

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

Chenyang Ma, Yue Yang, Radu Corcodel et al.

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

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

Austin McDannald, Julia Tisaranni, Howie Joress

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

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

Mehul Damani, Isha Puri, Idan Shenfeld et al.

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

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

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

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

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

Yuqing Yang, Qi Zhu, Zhen Han et al.

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

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

Xinyu Zhao, Zhen Tan, Vaishnav Tadiparthi et al.

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

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

Yuanda Xu, Zhengze Zhou, Hejian Sang et al.

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

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

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

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

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

Sameer Malik, Ayush Singh, Amar Prakash Azad

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

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

Srijan Tiwari, Aditya Chauhan, Manjot Singh

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

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

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

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

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

Yuhong Deng, Yuyao Liu, David Hsu

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

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

Nico Daheim, Iryna Gurevych

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

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

Rajesh Jayaram, Drew Tyler, David Woodruff et al.

AI-assisted peer review can augment (not replace) human reviewers by catching errors early and reducing their workload, but requires careful design to preserve human oversight and decision-making authority.

Google researchers introduce Paper Assistant Tool (PAT), an AI system that automatically reviews scientific papers by checking mathematical proofs, validating experiments, and identifying flaws. PAT uses inference scaling to catch errors before human peer review, addressing the bottleneck created by AI-accelerated research outpacing traditional review capacity.

Ali Zia, Usman Ali, Abdul Rehman et al.

Using topological features (shape and connectivity patterns) during test-time adaptation significantly improves anomaly segmentation by preserving structural coherence that pixel-level methods miss, achieving 15% F1 improvement on standard benchmarks.

This paper introduces TopoTTA, a test-time adaptation framework for anomaly segmentation that uses topological data analysis (persistent homology) to preserve structural consistency in defect detection.

Yingyu Lin, Qiyue Gao, Nikki Lijing Kuang et al.

You can train LLMs with RL on open-ended optimization tasks using only execution feedback—no ground-truth needed—and the improvements transfer to exact-solution problems, suggesting score-based tasks are valuable for general capability development.

This paper introduces RiVER, a method for training language models using reinforcement learning on tasks without ground-truth answers. Instead of requiring correct solutions, it uses continuous feedback from execution scores (like how well a heuristic algorithm performs).

Johannes Zenn, Jonas Geiping

Sequence probability is useful for ranking answers within a dataset but shouldn't be trusted as a guide for choosing decoding methods or hyperparameters—optimizing for probability doesn't guarantee better answers.

This paper investigates whether higher sequence probability in language models actually correlates with correct answers. The researchers test this across different decoding methods, models, and benchmarks, finding that while probability predicts correctness within a dataset, changing decoding parameters to increase probability doesn't reliably improve accuracy.

Tianyi Men, Zhuoran Jin, Pengfei Cao et al.

Small 7B models can outperform much larger 32B models at web automation by learning high-level task decomposition through autonomous exploration and hindsight experience, rather than just memorizing low-level actions.

This paper improves small multimodal AI models for web automation by having them autonomously explore environments to learn task planning. The key innovation is using 'hindsight experience'—learning from failed attempts by reframing them as high-level tasks—which helps models generalize to new websites better than training on low-level atomic actions alone.

Arnav Mazumder, Dengjia Zhang, Shuyue Stella Li et al.

When building multilingual AI systems with multiple translation steps, preserve the original user input throughout the pipeline instead of discarding it after each stage—this simple change significantly improves reasoning quality across languages.

This paper shows that translation cascades for multilingual reasoning lose important context at each step. By keeping the original question, translated question, and reasoning trace available to the final translation step, the authors achieve better results across 285 languages without retraining—a simple fix that prevents information loss in multi-stage pipelines.

Junwei Luo, Shuai Yuan, Zhenya Yang et al.

For Earth observation forecasting, explicitly conditioning on weather anomalies and cumulative physical stress—rather than treating weather as generic conditioning—improves predictions of how vegetation responds to extreme weather events.

EO-WM is a video diffusion model for predicting future Earth surface conditions from satellite imagery while accounting for weather effects. Unlike existing methods, it explicitly models how weather forcing (heat, drought) drives changes in vegetation and other surface features, using separate conditioning pathways for baseline climate and weather anomalies.

Wen Ye, Peiyan Li, Tingyu Yuan et al.

Test-time scaling for robots works better when you combine reasoning with action planning, track historical context, and use closed-loop feedback—enabling significant performance gains without retraining.

E-TTS is a framework that improves robot manipulation by combining reasoning and action planning at test time, using historical context and feedback loops. It works with existing vision-language-action models without retraining, achieving up to 33% performance gains in simulation and 27% in real-world tasks.

Junhao Shi, Zezheng Huai, Siyin Wang et al.

Persistent robot autonomy requires separating planning, memory, and verification into distinct components rather than relying on a single model; OmniAct demonstrates this approach scales to 100k+ interaction tokens while maintaining performance on real-world tasks.

OmniAct is a framework for building embodied robots that can perform long-horizon tasks in real-world environments by combining planning, memory management, and failure detection.

Amit Elhelo, Amir Globerson, Mor Geva

Language models don't store facts in a single, consistent way like traditional databases do. Instead, they encode knowledge in task-specific parameter subsets, meaning the same fact may be retrieved differently or not at all depending on how you ask the question.

This paper investigates whether language models store factual knowledge like unified databases or in task-specific ways.

Zhengyuan Liu, Stella Xin Yin, Min-Yen Kan et al.

When building human-AI collaborative systems, pay attention to metacognitive dialogue (how teams reflect on and adjust their approach) alongside task progress—it's a key indicator of collaboration quality.

This paper presents a framework for analyzing dialogue during collaborative problem-solving between humans and AI systems.

Sangwoo Cho, Kushal Chawla, Pengshan Cai et al.

Instead of asking an LLM for a single opaque score, ask it multiple specific binary questions about output quality, then aggregate the answers—this gives you both better evaluation accuracy and actionable feedback for improvement.

BINEVAL breaks down LLM evaluation into simple yes/no questions about specific criteria, then combines answers into interpretable scores. This makes evaluation transparent, debuggable, and useful for improving prompts—matching or beating existing LLM judges while being easier to understand and fix.

Humzah Merchant, Bradford Levy

You can improve LLM forecasting accuracy by identifying and amplifying time-awareness features inside the model, reducing the bias toward using information that shouldn't be available yet.

This paper uses sparse autoencoders to identify internal features in LLMs that drive forecasting behavior, distinguishing between time-aware reasoning and look-ahead bias. By steering these features, researchers show they can reduce the model's tendency to use future information while maintaining general reasoning ability.

Babak Rahmani, Sebastian Dziadzio, Joschka Strüber et al.

You can reverse-engineer an agent's decision logic from its behavior by combining observation with strategic experimentation—a technique that works for policy interpretability and opponent modeling in competitive settings.

RevengeBench is a benchmark for reconstructing hidden decision-making code from an agent's behavior in games. Researchers observe a hidden policy playing and can design custom opponents to probe its behavior, then submit executable code that mimics it.

Andrei Liviu Nicolicioiu, Mohammad Pezeshki, Aaron Courville

Self-distillation trades diversity for accuracy: models become overconfident in their preferred solutions, hurting performance on out-of-distribution tasks that need varied strategies.

This paper reveals a hidden cost of on-policy self-distillation: while it achieves high average accuracy, it reduces output diversity by amplifying the model's existing biases. The authors show theoretically and empirically that self-distillation concentrates probability mass on dominant modes, causing pass@k curves to flatten—generating more rollouts doesn't improve accuracy like it should.

Changdae Oh, Wendi Li, Seongheon Park et al.

You can extract free step-level evaluation signals from standard RL post-training using progress advantage, eliminating the need to build expensive process reward models for agent systems.

This paper shows that RL-trained language models already contain step-level scoring signals without needing separate reward models. The authors derive 'progress advantage'—a metric based on policy log-probability ratios—that automatically captures how good each step is, and demonstrate it works for scaling, uncertainty, and debugging across multiple benchmarks.

Yu-Yang Chen, Lan-Zhe Guo

Current multimodal AI models have a fundamental weakness in multi-view spatial reasoning—they can't reliably track objects across different camera angles, and this limitation can't be fixed by better prompting strategies alone.

TriViewBench is a controlled benchmark for testing how well multimodal AI models handle complex visual reasoning across multiple views of 3D scenes.

Jason Sulskis, Sathya Ravi

For PDE solvers, choose your spectral basis based on the operator's symmetry: real bases for elliptic PDEs, complex bases for time-dependent ones with phase content.

This paper compares two neural operators for solving PDEs: Fourier Neural Operators (FNO) using complex FFT and Hartley Neural Operators (HNO) using real Hartley transforms. Both are iso-parametric but use different spectral bases.

Yikai Lu, Yifei Wu, Xinyu Lu et al.

You can't verify general agents work everywhere, but you can certify they work reliably on specific transitions by examining their internal world model—this enables practical deployment of capable agents in complex environments.

This paper addresses how to verify that general-purpose AI agents work reliably in complex environments. Instead of checking if an agent handles everything perfectly, the authors propose 'structural certification'—a method that identifies which specific situations the agent understands well and which it doesn't.

Tian Zheng, Kai-Tai Hsu

Evaluating agentic systems requires multi-layered grading strategies with different failure modes; a cascade combining strict pattern matching, lenient LLM grading, and human review is more reliable than any single approach.

This paper tackles the challenge of evaluating agentic data analysis systems that produce complex outputs like code, results, and explanations. The authors develop a three-layer grading cascade combining regex matching, LLM-based evaluation, and human review, achieving 97% recall while maintaining 100% precision. They show that iterative nudging improves grading success from 36% to 97%.

Zidu Liu, Florian Marquardt

LLMs can solve discrete design problems in quantum computing by evolving structured concepts rather than generating solutions from first principles—showing that domain-specific constraints and executable specifications make AI search more effective.

Researchers used large language models paired with structured algebraic rules to automatically discover new quantum error-correcting codes. Instead of designing codes from scratch, the system evolves mathematical specifications and programs that describe code families, finding competitive designs that work better than some existing approaches.

Cong Han, Xiaohan Lan, Haibo Qiu et al.

MLLMs can be trained to adaptively switch between reasoning and code execution for numerical tasks—not just visual ones—using reinforcement learning with a specialized reward function that guides when to invoke tools.

This paper enhances multimodal AI models to reason through complex math and numerical problems by interleaving natural language thinking with executable code. The authors use reinforcement learning to train models to decide when and how to use code tools, achieving 6.1% accuracy improvement on benchmarks.

Prateek Agnihotri, Sanchit Jain, Prabhat Agnihotri et al.

Reframing symbolic reasoning problems as string matching and search—rather than arithmetic simulation—helps LLMs avoid hallucinations and handle combinatorially complex tasks more reliably.

This paper tackles bit manipulation puzzles by teaching LLMs to deduce hidden logical rules transforming binary strings. Instead of forcing models to simulate complex boolean logic (which causes hallucinations), the authors reframe the problem as string similarity matching and structured search with backtracking.

David Mguni, Julian Ma, Jun Wang

LLMs cannot be universal problem solvers through prompting alone because language itself is a bottleneck; some task families will always be unsolvable via prompts, no matter how much data or compute you throw at them.

This paper proves fundamental limits on what LLMs can learn through prompting alone. Using game theory and information theory, the authors show that language is a capacity-limited channel—when task complexity exceeds what can fit in a prompt, different tasks become indistinguishable to the model, creating an irreducible error floor that no amount of data or scaling can fix.

Saimun Habib, Vaishak Belle, Fengxiang He

DeepSWIP enables exact counterfactual reasoning in neural-symbolic systems by materializing neural predictions into logical form, making it possible to compute causal interventions and answer counterfactual queries without duplicating the entire model.

DeepSWIP adds causal reasoning to neural-symbolic AI systems by combining neural networks with probabilistic logic. It transforms neural predictions into logical choices, applies causal intervention techniques, and computes counterfactuals efficiently using weighted model counting—enabling systems to answer "what if" questions about learned models.

Shu Yao, Yuhua Luo, Qian Long et al.

Multi-device agents need hierarchical recovery strategies that distinguish between local device failures (fixable with alternative approaches) and global failures (requiring task replanning), rather than treating all failures the same way.

This paper presents H-RePlan, a framework that helps AI agents recover from failures when working across multiple devices (like computers and phones). Instead of replanning entire tasks when something goes wrong, the system first tries to fix problems locally on each device, only escalating to global replanning when necessary.

Jake J. Xia

Collective intelligence isn't about maximizing order—it's about finding the right balance between coordination and flexibility based on what the system needs to achieve.

This paper develops a framework for understanding multi-agent systems by analyzing how individual agent properties (power and response functions) create emergent collective behaviors. It shows that synchronization increases output but can reduce resilience, and derives an optimal balance between order and adaptability based on system objectives.

Md Sakir Ahmed, Kumaresh Sarmah, Hemen Dutta

Flatness matters for generalization, but only when measured using Fisher geometry—standard Euclidean measures are misleading because they change when you reparametrize the network while keeping its function identical.

This paper solves a long-standing problem in deep learning: why flat minima generalize better. The authors show that standard flatness measures fail because they change under reparametrization, but by using the Fisher Information Matrix geometry, they define a reparametrization-invariant flatness measure that provably explains SGD's bias toward flat minima and their generalization.

Zongmin Yu, Liu Yang

ASYS demonstrates that AI agents can automatically discover interpretable mathematical formulas for complex PDE solutions, offering a new way to understand physical systems that goes beyond traditional numerical methods and neural network black boxes.

This paper presents Agentic Symbolic Search (ASYS), a system that automatically discovers mathematical formulas describing PDE solutions by combining symbolic search with gradient optimization.

Siqi Miao, Shitij Govil, Jack P. Rodgers et al.

End-to-end transformers can match or beat graph neural networks on complex physics tasks while being dramatically faster and more memory-efficient—showing that careful architecture design beats multi-stage pipelines.

HEPTv2 is an end-to-end transformer model that reconstructs particle tracks from detector measurements at the Large Hadron Collider. It uses locality-sensitive hashing and sectorized decoding to achieve 98.6% accuracy while running 7-50x faster than competing approaches, making it practical for real-time physics experiments.

Zhenghao Xing, Ruiyang Xu, Yuxuan Wang et al.

Active perception—where an AI agent decides what to observe rather than passively processing everything—enables better video understanding with lower computational cost and improves with more reasoning steps.

OmniAgent is an AI agent that watches videos intelligently by deciding what to pay attention to, rather than processing every frame. It combines audio, visual, and text understanding in a reasoning loop, building up memory of important moments. This approach scales better with video length and achieves top performance on video understanding benchmarks.

Mohamed Nabail, Leo Cheng, Jingmin Wang et al.

By jointly reasoning over uncertainty in rewards, dynamics, and values during planning, preference-based RL can achieve sample efficiency comparable to model-based methods while avoiding explicit reward design.

This paper presents UBP2, a method that learns reward models from human preference comparisons while actively exploring the environment. Unlike passive approaches, UBP2 uses ensemble models to balance learning about rewards, environment dynamics, and value functions, enabling efficient sample use during early training stages.

Siyi Gu, Jialin Chen, Sophia Zhou et al.

Using structured rubrics as fine-grained feedback during training helps reasoning models learn better than scalar rewards or single reference solutions, because rubrics specify what makes a good response without forcing the model to copy one specific reasoning path.

This paper proposes a new training method for reasoning language models that uses detailed rubrics (scoring criteria) instead of single correct answers or scalar rewards. The approach has a teacher model generate token-level feedback based on rubrics, guiding a student model's own reasoning steps. This provides more nuanced learning signals than traditional distillation or reward-based methods.

Amiri Hayes, Belinda Li, Jacob Andreas

Attention heads in transformers can be reverse-engineered into interpretable Python programs that capture their core logic, offering a path toward making neural model internals more transparent and understandable.

This paper proposes a method to explain how attention heads in transformer models work by generating Python programs that mimic their behavior. The researchers use a language model to write code that reproduces attention patterns from real examples, then validate these programs on new data.

Ruida Wang, Rui Pan, Pengcheng Wang et al.

Diffusion-based language models outperform auto-regressive models for formal theorem proving by generating multiple tokens simultaneously, enabling better long-range coherence and error recovery—a paradigm shift for mathematical reasoning tasks.

This paper introduces Diffusion-Proof, the first framework using diffusion language models (which generate text by iteratively refining multiple tokens at once) for formal theorem proving. Unlike traditional auto-regressive models that predict one token at a time, diffusion models better maintain long-range coherence needed for complex proofs.

Leyang Shen, Yang Zhang, Xiaoyan Zhao et al.

When building LLM systems for real-world decisions involving multiple stakeholders with conflicting interests, use iterative game-theoretic reasoning rather than one-shot reasoning—agents improve by learning from and countering each other's strategies.

This paper introduces Multi-Agent Fictitious Play (MAFP), a framework where LLM-based agents represent different stakeholders and iteratively improve decisions by responding to each other's past choices.

Qi Chai, Wenhao Shen, Nanjie Yao et al.

By learning from past navigation failures and predicting outcomes before acting, zero-shot object navigation can improve significantly without retraining—achieving 10% better success rates with fewer wasted steps.

This paper presents EvolveNav, a framework for embodied agents to find objects in unseen environments without prior training. It builds a memory of successful navigation rules from past attempts and uses them to guide future exploration, reducing trial-and-error through predictive planning before taking actions.

Ankita Samaddar, Sandeep Neema, Daniel Balasubramanian et al.

Autonomous cyber-defense systems can predict attacker actions without directly observing them by learning from network data and defender responses, enabling smarter, adaptive security.

This paper develops a technique for autonomous cyber-defense agents to learn and predict attacker behavior in partially observable networks. Using imitation learning, the system learns what an attacker might do based on network observations, helping defenders anticipate threats and adapt their security strategies in real-time.

Hao Liang, Cheng Tang, Yunzong Xu

Queue peaks in loaded networks exhibit a phase transition from square-root to logarithmic growth, with the transition point determined by network geometry—this matters for predicting buffer sizes and scheduling in real systems.

This paper analyzes how queue sizes grow over finite time horizons in stochastic networks with constrained resources. When the system has enough slack (spare capacity), queue peaks follow a surprising two-phase pattern: they grow like a square root initially, then switch to logarithmic growth.

Sajad Movahedi, Vera Milovanović, Shlomo Libo Feigin et al.

Fixed-point convergence provides a natural halting mechanism for iterative reasoning models, letting them use fewer steps on easy problems and more on hard ones—without explicit stopping signals.

This paper introduces FPRM, a looped Transformer that solves reasoning tasks by repeatedly applying the same layer until reaching a fixed point, automatically stopping when the model's internal state stabilizes. The approach addresses signal propagation problems in deep networks and adapts computation based on task difficulty.

Nick Jiang, Isaac Kauvar, Jack Lindsey

Language models encode a linear representation of expected success that directly influences their confidence and decision-making—understanding this could improve how we steer model behavior and diagnose when models are uncertain.

This paper discovers that language models internally represent a 'value axis'—a direction in their activation space that tracks whether their current strategy will succeed. By analyzing Qwen3-8B, researchers show this axis predicts confidence levels, code correctness, and backtracking behavior, and that steering along it causally changes how the model explores vs. commits to solutions.

Peiyang Xu, Bangzheng Li, Sijia Liu et al.

Training models to identify supporting evidence through context selection—not just answer correctness—improves long-horizon reasoning and multimodal performance without requiring more data.

ContextRL trains LLMs to better handle long contexts and multimodal inputs by rewarding models for selecting the correct supporting context from similar alternatives, rather than just supervising final answers. This indirect approach improves reasoning on coding tasks and visual question-answering by encouraging fine-grained evidence grounding.

Anzhe Xie, Weihang Su, Yujia Zhou et al.

LLM agents excel at finding papers but fail at the harder task of determining whether papers actually meet study eligibility criteria—a bottleneck that stage-specific metrics can help diagnose better than single overall scores.

MetaSyn is a benchmark dataset of 442 expert-curated meta-analyses from Nature journals that tests how well AI systems can perform evidence synthesis—retrieving relevant studies, screening them against eligibility criteria, and aggregating results.

Mufei Li, Shikun Liu, Dongqi Fu et al.

You can efficiently erase stale or harmful information from an LLM's KV cache by learning to replace cached states rather than recomputing—enabling practical context correction in long-context applications without massive latency penalties.

KVEraser is a learned method for efficiently removing unwanted information from an LLM's cached key-value states after processing. Instead of recomputing all tokens after a deleted span (which is slow), it replaces only the cached states of the erased text with learned steering states, achieving near-full-recomputation quality with 3-4x speedup on long-context tasks.

Minghang Zhu, Chuyang Wei, Junhao Xu et al.

By reversing the rubric generation process—building evaluation criteria from evidence first, then creating aligned questions—you can train research agents more efficiently with more reliable reward signals for reinforcement learning.

DeepRubric is a framework that creates high-quality training data for teaching AI research agents to write better reports. Instead of asking an AI to guess what makes a good report for a given question, it works backwards: it first decides what a report should be evaluated on, then creates matching question-evaluation pairs. This approach trains better agents 13x faster than previous methods.

Violet Xiang, Amrith Setlur, Chase Blagden et al.

Using reference solutions as reward signals rather than imitation targets helps models learn reusable reasoning skills that sparse rewards alone miss, making them better prepared for downstream RL.

ExpRL is a method for improving language models through reinforcement learning during mid-training. Instead of having models imitate reference solutions, it uses those solutions to create grading rubrics that reward the model for showing useful reasoning steps—like breaking down problems or verifying answers—even if the final answer is wrong.

Buqiang Xu, Zirui Xue, Dianmou Chen et al.

Effective context pruning for agents requires preserving prompt cache structure—TokenPilot achieves 56-87% cost reduction by removing content conservatively rather than aggressively rewriting prompts.

TokenPilot manages context in long-running AI agents by smartly removing unnecessary information while keeping the prompt cache valid. It uses two strategies: cleaning up noise when information enters the system, and removing old context only when it's no longer useful. This cuts inference costs by 56-87% while maintaining performance.

Yannick Limmer

You can build prediction sets for time series that adapt to learned dependencies between variables while guaranteeing coverage, by combining neural filters with conformal calibration—no need to assume Gaussian tails.

This paper develops a method for creating prediction sets (confidence regions) for multivariate time series that properly account for dependencies between variables. It combines a learned state-space filter that predicts future values and their uncertainty with conformal calibration—a distribution-free technique that guarantees coverage.

Jiayue Cao, Zhicong Lu, Xuehan Sun et al.

When training vision-language models to reason step-by-step, you need to explicitly enforce that the reasoning process logically leads to the final answer—not just optimize for getting the right answer.

This paper identifies and fixes a problem in multimodal AI models where their reasoning process doesn't match their final answer. The authors propose CORA, a method that adds a consistency check during training to ensure the model's thinking aligns with what it concludes, improving both accuracy and reasoning reliability.

Xiaoyu Li, Andi Han, Dai Shi et al.

AI systems generating formal mathematics face a fundamental tradeoff: they must produce some correct-but-worthless statements to discover truly valuable new theorems, and this requirement is mathematically unavoidable, not a bug to fix.

This paper models how AI systems generate valuable mathematics using proof assistants. It shows that to discover new valuable theorems while avoiding false statements, systems must generate some 'trivial' (correct but uninteresting) statements—and the amount needed depends sharply on how much of the valuable mathematics is already known.

Jundong Xu, Qingchuan Li, Jiaying Wu et al.

LLM agents need to track how their environment evolves over time to work reliably in the real world—EvoMem shows that explicitly recording memory changes improves agent performance on both dynamic and standard benchmarks.

EvoArena is a benchmark that tests LLM agents in dynamic environments where conditions change over time, and EvoMem is a memory system that tracks how environments evolve. Current agents struggle with these changing conditions (39.6% accuracy), but EvoMem improves performance by recording structured update histories, helping agents understand what has changed.

Zilin Xiao, Qi Ma, Chun-cheng Jason Chen et al.

Retrieving problems with similar reasoning strategies—not just semantic similarity—helps language models solve complex reasoning tasks better, and this works alongside other training improvements.

This paper teaches language models to solve complex problems by learning from analogous examples rather than just semantically similar ones. It introduces a system that retrieves problems with similar reasoning patterns (not just similar wording) and uses reinforcement learning to help models learn from these examples, improving performance on math reasoning tasks.

Seokju Cho, Ryo Hachiuma, Abhishek Badki et al.

Using executable code as an action interface lets vision-language models flexibly compose spatial reasoning operations and adapt to intermediate results, significantly improving performance on 3D/4D reasoning tasks without model-specific tuning.

SpatialClaw is a framework that helps AI agents reason about 3D space and object relationships by letting them write and execute Python code step-by-step. Instead of committing to a full analysis upfront or using rigid tool menus, the agent can see intermediate results and adapt its approach, achieving 59.9% accuracy across spatial reasoning tasks—11.2 points better than prior methods.

Yaxin Du, Yifan Zhou, Yujie Ge et al.

Bundling multiple tool calls into executable code blocks dramatically improves agent performance on multi-step tasks—doubling accuracy on some benchmarks by reducing the overhead of step-by-step tool management.

HyperTool lets AI agents call multiple tools in a single code block instead of one at a time, reducing context waste and improving performance. Rather than exposing each tool call separately, agents write code that chains tools together locally, making complex workflows more efficient.

Amy Xin, Jiening Siow, Junjie Wang et al.

The key bottleneck for autonomous scientific discovery isn't better agent algorithms—it's better environment design. By engineering constraints, collaboration tools, and oversight mechanisms, you can make agents more reliable and productive at discovering new solutions.

EurekAgent is an AI agent system designed to automate scientific discovery by focusing on environment engineering—the resources, constraints, and interfaces that shape agent behavior.

Marianna Bergamaschi Ganapini, Massimo Chiriatti, Enrico Panai et al.

AI systems can shape what we think about and how we think before we're aware it's happening, embedding corporate or other interests into our reasoning in ways that are hard to detect or resist.

This paper analyzes how AI systems influence human thinking before conscious deliberation occurs, introducing the concept of 'cognitive colonization'—where AI embeds external interests into our decision-making in ways we don't notice.

Nathaniel Bottman, Yinhong Liu, Kyle Richardson

Operadic consistency detects LLM reasoning failures by checking if a model's direct answer matches its step-by-step decomposed answer—a label-free signal that outperforms existing confidence measures across diverse models and datasets.

This paper introduces operadic consistency (OC), a method to detect when large language models fail at multi-step reasoning without needing correct answers. The key insight: a model's direct answer to a complex question should match the answer it gets by breaking down the question into steps and solving each one.

Elias Lumer, Sahil Sen, Kevin Paul et al.

Spawning parallel subagents with independent tools and planning is more effective for complex long-context tasks than having a single agent handle everything—this architectural pattern improves coding performance from 71.75% to 81.36% on long documents.

This paper introduces Recursive Agent Harness (RAH), a pattern where AI agents spawn subagents to handle complex tasks in parallel rather than processing everything in a single call. Like how recursive language models break down reasoning into multiple model calls, RAH breaks down work into multiple agent instances, each with their own tools and planning capabilities.

Nathaniel Bottman, Kyle Richardson

Question decomposition, a key technique for improving LLM reasoning, now has a rigorous mathematical foundation through operads, enabling new consistency checks that correlate strongly with accuracy.

This paper applies operads—mathematical structures for modeling compositions of operations—to formalize question decomposition in LLMs.

Achraf Hsain, Sultan Almuhammadi

Shield synthesis is most valuable for analyzing whether a system architecture can be defended at design time, not for enforcing safety during deployment—formal defensibility and operational robustness are distinct properties that require different metrics.

This paper reframes shield synthesis—a technique that uses formal logic to restrict agent actions—as a design-time analysis tool rather than a runtime safety mechanism.

Zach Studdiford, Gary Lupyan

Human and LLM reasoning failures follow similar patterns driven by surface-level cues rather than deep understanding—both systems appear to use pattern-matching rather than principled world models for everyday reasoning.

This paper challenges the idea that human reasoning is fundamentally different from LLM reasoning by showing both make similar errors on everyday reasoning tasks. The researchers identify specific attention patterns in LLMs that perform pattern-matching and demonstrate these same patterns predict human reasoning mistakes, suggesting both rely on similar mechanisms rather than abstract models.

Yashdeep Chaudhary, Roberto Armellin, Harry Holt et al.

You can use RL to add robustness to pre-computed trajectories by learning feedback corrections that work across different types of uncertainty—without needing to know the exact distribution in advance.

This paper combines reinforcement learning with chance constraints to make spacecraft trajectories robust to uncertainty without assuming a specific probability distribution. Starting from a baseline trajectory, the method learns feedback control adjustments that handle random variations in initial conditions and process noise, tested on Earth-Mars transfers and rocket landings.